Add Leetcode 20. Valid Parentheses

Author: manojbaishya

src/main/java/org/dojo/leetcode/Bracket.java

@@ -0,0 +1,32 @@
+package org.dojo.leetcode;
+
+public enum Bracket {
+    PARENTHESES_OPEN('('),
+    PARENTHESES_CLOSED(')'),
+    BRACES_OPEN('{'),
+    BRACES_CLOSED('}'),
+    BRACKETS_OPEN('['),
+    BRACKETS_CLOSED(']');
+
+    Bracket(char symbol) {
+        this.symbol = symbol;
+    }
+    private final char symbol;
+    public char getSymbol() { return symbol; }
+
+    public static Bracket fromSymbol(char symbol) {
+        for (Bracket bracket : Bracket.values()) {
+            if (bracket.getSymbol() == symbol) return bracket;
+        }
+        throw new IllegalArgumentException("Invalid symbol: " + symbol);
+    }
+
+    public boolean isMatching(Bracket other) {
+        return switch (this) {
+            case PARENTHESES_OPEN -> other.equals(PARENTHESES_CLOSED);
+            case BRACES_OPEN -> other.equals(BRACES_CLOSED);
+            case BRACKETS_OPEN -> other.equals(BRACKETS_CLOSED);
+            case PARENTHESES_CLOSED, BRACES_CLOSED, BRACKETS_CLOSED -> false;
+        };
+    }
+}

src/main/java/org/dojo/leetcode/Stacks.java

@@ -43,53 +43,24 @@ public int[] asteroidCollision(int[] asteroids) {
         return stack.reversed().stream().mapToInt(i -> i).toArray();
     }
 
-    // public boolean isValid(String s) {
-    //     Deque<Bracket> stack = new ArrayDeque<>();
-    //     for (int i = 0; i < s.length(); i++) {
-    //         char c = s.charAt(i);
-    //         Bracket bracket = Bracket.fromSymbol(c);
-    //
-    //         if (stack.isEmpty()) {stack.push(bracket)}
-    //
-    //         ;
-    //     }
-    //
-    //     return false;
-    // }
-
-    enum Bracket {
-        PARENTHESES('(', ')'),
-        BRACES('{', '}'),
-        BRACKETS('[', ']');
-
-        Bracket(char openSymbol, char closeSymbol) {
-            this.openSymbol = openSymbol;
-            this.closeSymbol = closeSymbol;
-        }
-        private final char openSymbol;
-        public char getOpenSymbol() { return openSymbol; }
+    public boolean isValid(String s) {
+        Deque<Character> bracketPairs = new ArrayDeque<>(s.length() / 2 + 1);
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
 
-        private final char closeSymbol;
-        public char getCloseSymbol() { return closeSymbol; }
+            if (bracketPairs.isEmpty()) {
+                bracketPairs.push(c);
+                continue;
+            }
 
-        enum State {
-            OPEN,
-            CLOSED
+            if (isMatching(bracketPairs.peek(), c)) bracketPairs.pop();
+            else bracketPairs.push(c);
         }
 
-        public char getSymbol(State state) { return state == State.OPEN ? openSymbol : closeSymbol; }
+        return bracketPairs.isEmpty();
+    }
+
+    boolean isMatching(char self, char other) { return (self == '(' && other == ')') || (self == '{' && other == '}') || (self == '[' && other == ']'); }
 
-        public static Bracket fromSymbol(char symbol) {
-            for (Bracket bracket : Bracket.values()) {
-                if (bracket.getOpenSymbol() == symbol || bracket.getCloseSymbol() == symbol) {
-                    return bracket;
-                }
-            }
-            throw new IllegalArgumentException("Unknown symbol: " + symbol);
-        }
 
-        public static boolean isMatching(char openSymbol, char closeSymbol) {
-            return fromSymbol(openSymbol).getCloseSymbol() == closeSymbol;
-        }
-    }
 }

src/test/java/org/dojo/leetcode/StacksTests.java

@@ -1,5 +1,6 @@
 package org.dojo.leetcode;
 
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -12,6 +13,7 @@
 class StacksTests {
     private final Stacks sut = new Stacks();
 
+
     static Stream<Arguments> asteroidCollisionProvider() {
         return Stream.of(
                 Arguments.of(new int[] {5, 10, -5}, new int[] {5, 10}),
@@ -29,4 +31,22 @@ public void asteroidCollision(int[] input, int[] expected) {
         System.out.printf("Actual: %s\n", Arrays.toString(actual));
         assertArrayEquals(expected, actual);
     }
+
+    public static Stream<Arguments> dataIsValid() {
+        return Stream.of(
+                Arguments.of("()", true),
+                Arguments.of("()[]{}", true),
+                Arguments.of("(]", false),
+                Arguments.of("([])", true)
+        );
+    }
+
+
+    @ParameterizedTest
+    @MethodSource("dataIsValid")
+    void isValid(String s, boolean expected) {
+        boolean actual = sut.isValid(s);
+        System.out.printf("Expected: %s, Actual: %s\n", expected, actual);
+        assert expected == actual;
+    }
 }