more problems

Author: MaiDeveloper

__test__/letter-case-permutation.test.js

@@ -0,0 +1,23 @@
+import letterCasePermutation from '../letter-case-permutation';
+
+describe('Letter Case Permutation', () => {
+
+  test('a1b2', () => {
+    const result = letterCasePermutation('a1b2');
+    const expected = ['a1b2', 'a1B2', 'A1b2', 'A1B2'];
+    expect(result).toEqual(expected);
+  });
+
+  test('3z4', () => {
+    const result = letterCasePermutation('3z4');
+    const expected = ['3z4', '3Z4'];
+    expect(result).toEqual(expected);
+  });
+
+  test('12345', () => {
+    const result = letterCasePermutation('12345');
+    const expected = ['12345'];
+    expect(result).toEqual(expected);
+  });
+
+});

__test__/word-search.test.js

@@ -0,0 +1,33 @@
+import wordSearch from '../word-search';
+
+describe('Word Search', () => {
+
+  let board;
+
+  beforeEach(() => {
+    board = [
+      ['A','B','C','E'],
+      ['S','F','C','S'],
+      ['A','D','E','E']
+    ];
+  });
+
+  test('ABCCED', () => {
+    const result = wordSearch(board, 'ABCCED');
+    const expected = true;
+    expect(result).toEqual(expected);
+  });
+
+  test('SEE', () => {
+    const result = wordSearch(board, 'SEE');
+    const expected = true;
+    expect(result).toEqual(expected);
+  });
+
+  test('ABCB', () => {
+    const result = wordSearch(board, 'ABCB');
+    const expected = false;
+    expect(result).toEqual(expected);
+  });
+
+});

balance-parentheses-stack.js

@@ -0,0 +1,41 @@
+class Stack {
+  constructor() {
+    this.stack = [];
+  }
+
+  push(item) {
+    this.stack.push(item);
+  }
+
+  pop() {
+    return this.stack.pop();
+  }
+
+  isEmpty() {
+    return this.stack.length === 0;
+  }
+}
+
+const isBalanced = (parentheses) => {
+  const stack = new Stack();
+  const pairs = {
+    '(': ')',
+    '[': ']',
+    '{': '}',
+  };
+
+  for (const single of parentheses) {
+    if (pairs[single] !== undefined) {
+      stack.push(pairs[single]);
+    } else if (stack.isEmpty()) {
+      return false;
+    } else if (stack.pop() !== single) {
+      return false;
+    }
+  }
+
+  return stack.isEmpty();
+};
+
+console.log(isBalanced('{[]}'));
+console.log(isBalanced('{[}}'));

letter-case-permutation.js

@@ -0,0 +1,39 @@
+/**
+ * Letter Case Permutation
+ * Given a string S, we can transform every letter individually to be lowercase or uppercase to create another string.  Return a list of all possible strings we could create.
+ * 
+ * Examples:
+ * Input: S = "a1b2"
+ * Output: ["a1b2", "a1B2", "A1b2", "A1B2"]
+ * 
+ * Input: S = "3z4"
+ * Output: ["3z4", "3Z4"]
+ * 
+ * Input: S = "12345"
+ * Output: ["12345"]
+ * Note:
+ * 
+ * S will be a string with length between 1 and 12.
+ * S will consist only of letters or digits.
+ * 
+ */
+
+ const letterCasePermutation = (str, index = 0, newStr = '', ans = []) => {
+    if (index === str.length) {
+      return ans.push(newStr);
+    }
+
+    const char = str.charAt(index);
+    index++;
+
+    if (/[a-z]/i.test(char)) {
+      letterCasePermutation(str, index, newStr + char.toLowerCase(), ans);
+      letterCasePermutation(str, index, newStr + char.toUpperCase(), ans);
+    } else {
+      letterCasePermutation(str, index, newStr + char, ans);
+    }
+
+    return ans;
+ };
+
+ export default letterCasePermutation;

rat-in-maze-backtracking.js

@@ -0,0 +1,77 @@
+const maze = [
+  [ 1, 0, 0, 0 ],
+  [ 1, 1, 0, 1 ],
+  [ 1, 0, 0, 0 ],
+  [ 1, 1, 1, 1 ],
+];
+
+class MazeBacktrack {
+  constructor(maze) {
+    if (!Array.isArray(maze) || maze.length === 0) {
+      throw new Error('Maze should be an array with more than one row');
+    }
+
+    this.maze = maze;
+    this.numberOfRows = maze.length;
+    this.numberOfColumns = maze[0].length;
+    this.exitRow = this.numberOfRows - 1;
+    this.exitColumn = this.numberOfColumns - 1;
+    this.directions = [
+      [ 0, 1 ], // FORWARD
+      [ 1, 0 ], // DOWN
+    ];
+    this.clearSolution();
+  }
+
+  clearSolution() {
+    this.solution = new Array(this.numberOfRows)
+      .fill(null)
+      .map(() => new Array(this.numberOfColumns).fill(0));
+  }
+
+  isValid(i, j) {
+    return (
+      i >= 0 && 
+      i < this.numberOfRows &&
+      j >= 0 &&
+      j < this.numberOfColumns &&
+      this.maze[i][j] === 1
+    );
+  }
+
+  /**
+   * 
+   * @param {number} i 
+   * @param {number} j 
+   * @time complexity: O(2^(N^2))
+   * @space complexity: O(N^2)
+   */
+  dfs(i = 0, j = 0) {
+    if (!this.isValid(i, j)) {
+      return false;
+    }
+
+    // MARK CURRENT BLOCK AS PART OF THE SOLUTION
+    this.solution[i][j] = 1;
+
+    // READ THE DESINTATION
+    if (i === this.exitRow && j === this.exitColumn) {
+      return this.solution;
+    }
+
+    for (const [x, y] of this.directions) {
+      if (this.dfs(i + x, j + y)) {
+        return this.solution;
+      }
+    }
+
+    // UNMARK CURRENT BLOCK
+    this.solution[i][j] = 0;
+
+    return false;
+  }
+}
+
+const solve = new MazeBacktrack(maze);
+
+console.log(solve.dfs());

word-search.js

@@ -0,0 +1,69 @@
+/**
+ * Word Search
+ * Given a 2D board and a word, find if the word exists in the grid.
+ * 
+ * The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
+ * 
+ * Example:
+ * 
+ * board =
+ * [
+ *   ['A','B','C','E'],
+ *   ['S','F','C','S'],
+ *   ['A','D','E','E']
+ * ]
+ * 
+ * Given word = "ABCCED", return true.
+ * Given word = "SEE", return true.
+ * Given word = "ABCB", return false.
+ */
+
+const wordSearch = (board, word) => {
+  const rows = board.length,
+        cols = board[0].length,
+        directions = [
+          [ -1,  0 ], // Up
+          [  0,  1 ], // Right
+          [  1,  0 ], // Down
+          [  0, -1 ], // Left
+        ];
+
+  const bfs = (i, j, index) => {
+    if (i < 0 || i >= rows || j < 0 || j >= cols || // OUT OF RANGE
+       board[i][j] !== word.charAt(index)) { // NOT SAME CHARACTER
+      return false;
+    }
+
+    index++;
+
+    // END OF WORD
+    // MATCH IS FOUND
+    if (index === word.length) {
+      return true;
+    }
+
+    const temp = board[i][j];
+    board[i][j] = null;
+
+    for (const [x, y] of directions) {
+      if (bfs(i + x, j + y, index)) {
+        return true;
+      }
+    }
+
+    board[i][j] = temp;
+    return false;
+  };
+
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (bfs(i, j, 0)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+export default wordSearch;