Initial commit

Hard/longest-valid-parentheses/Solution.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int longestValidParentheses(String str) {
+        Stack<Integer> stack = new Stack<>();
+        stack.push(-1);
+        
+        int max = 0;
+        for (int cur = 0; cur < str.length(); cur++) {
+            if (str.charAt(cur) == '(') {
+                stack.push(cur);
+            } else {
+                stack.pop();
+                if (stack.empty()) {
+                    stack.push(cur);
+                } else {
+                    max = Math.max(max, cur - stack.peek());
+                }
+            }
+        }
+        return max;
+    }
+}

Hard/longest-valid-parentheses/solution.cpp

@@ -0,0 +1,26 @@
+#include <stack>
+#include <string>
+
+class Solution {
+  public:
+    int longestValidParentheses(std::string line) {
+        std::stack<int> shelf;
+        shelf.push(-1);
+
+        int max = 0;
+        for (int i = 0; i < line.length(); ++i) {
+            if (line[i] == '(') {
+                shelf.push(i);
+            } else {
+                shelf.pop();
+                if (shelf.empty()) {
+                    shelf.push(i);
+                } else if (max < i - shelf.top()) {
+                    max = i - shelf.top();
+                }
+            }
+        }
+
+        return max;
+    }
+};

Hard/sudoku-solver/Solution.java

@@ -0,0 +1,57 @@
+class Solution {
+    char[][] BOARD;
+
+    boolean isValid(int row, int col, char num) {
+        for (int i = 0; i < 9; i++) {
+            if (BOARD[i][col] == num)
+                return false;
+            if (BOARD[row][i] == num)
+                return false;
+        }
+
+        row = row - row % 3;
+        col = col - col % 3;
+        for (int i = 0; i < 3; i++)
+            for (int j = 0; j < 3; j++)
+                if (BOARD[i + row][j + col] == num)
+                    return false;
+
+        return true;
+    }
+
+    int[] nextEmpty() {
+        for (int i = 0; i < 9; i++)
+            for (int j = 0; j < 9; j++)
+                if (BOARD[i][j] == '.')
+                    return new int[] { i, j };
+
+        return new int[] { -1, -1 };
+    }
+
+    boolean solver() {
+        int[] tmp = nextEmpty();
+        if (tmp[0] == -1)
+            return true;
+
+        int row = tmp[0];
+        int col = tmp[1];
+
+        for (int i = 1; i <= 9; i++) {
+            if (isValid(row, col, (char) (48 + i))) {
+                BOARD[row][col] = (char) (48 + i);
+
+                if (solver())
+                    return true;
+            }
+
+            BOARD[row][col] = '.';
+        }
+
+        return false;
+    }
+
+    public void solveSudoku(char[][] board) {
+        BOARD = board;
+        solver();
+    }
+}

Hard/sudoku-solver/solution.cpp

@@ -0,0 +1,67 @@
+#include <array>
+#include <vector>
+
+class Solution {
+  public:
+    std::array<int, 2> nextEmpty(std::vector<std::vector<char>> &board) {
+        for (int i = 0; i < 9; ++i) {
+            for (int j = 0; j < 9; ++j) {
+                if (board[i][j] == '.') {
+                    return {i, j};
+                }
+            }
+        }
+
+        return {-1, -1};
+    }
+
+    bool valid(std::vector<std::vector<char>> &board, int row, int col,
+               char dgt) {
+        for (int i = 0; i < 9; ++i) {
+            if (board[i][col] == dgt || board[row][i] == dgt) {
+                return false;
+            }
+        }
+
+        row = row - row % 3;
+        col = col - col % 3;
+        for (int i = 0; i < 3; ++i) {
+            for (int j = 0; j < 3; ++j) {
+                if (board[i + row][j + col] == dgt) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool boardFiller(std::vector<std::vector<char>> &board) {
+        std::array<int, 2> index = nextEmpty(board);
+
+        if (index[0] == -1) {
+            return true;
+        }
+
+        int row = index[0];
+        int col = index[1];
+
+        for (int i = 0; i < 9; ++i) {
+            if (valid(board, row, col, (char)((int)'1' + i))) {
+                board[row][col] = (char)((int)'1' + i);
+
+                if (boardFiller(board)) {
+                    return true;
+                }
+            }
+
+            board[row][col] = '.';
+        }
+
+        return false;
+    }
+
+    void solveSudoku(std::vector<std::vector<char>> &board) {
+        boardFiller(board);
+    }
+};