@@ -1,9 +1,6 @@
 # Algorithms ToDo
 
 + Valid Sudoku [LeetCode #36](https://leetcode.com/problems/valid-sudoku/)
-+ Regular Expression Matching [LeetCode #10](https://leetcode.com/problems/regular-expression-matching/)
 + Letter Combination of a Phone Number [LeetCode #17](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)
-+ Combination Sum [LeetCode #39](https://leetcode.com/problems/combination-sum/)
 + Wildcard Matching [LeetCode #44](https://leetcode.com/problems/wildcard-matching/)
-+ N-Queens [LeetCode #51](https://leetcode.com/problems/n-queens/)
-+ Restore IP Addresses [LeetCode #93](https://leetcode.com/problems/restore-ip-addresses/)
++ N-Queens [LeetCode #51](https://leetcode.com/problems/n-queens/)
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function(candidates, target) {
+    var result = [];
+
+    if (candidates == null || candidates.length === 0) { 
+        return result;
+    };
+ 
+    var current = [];
+    candidates.sort();
+ 
+    combinationSumHelper(candidates, target, 0, current, result);
+ 
+    return result;
+};
+
+function combinationSumHelper(candidates, target, j, curr, result){
+    if(target === 0){
+        var temp = curr.slice();
+        result.push(temp);
+        return;
+    }
+  
+    for(var i=j; i<candidates.length; i++){
+        if(target < candidates[i]) {
+            return;
+        }
+        curr.push(candidates[i]);
+        combinationSumHelper(candidates, target - candidates[i], i, curr, result);
+        curr.pop(); 
+    }
+ }
+
+const candidates = [2,3,6,7];
+const target = 7;
+console.log(combinationSum(candidates, target));
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @param {string} p
+ * @return {boolean}
+ */
+
+var isMatch = function(s, p) {
+    if (p === "") return s === "";
+    var first_match = (s!="" && (p[0] == s[0] || p[0] == '.'));
+
+    if (p.length >= 2 && p[1] == '*'){
+        return (isMatch(s, p.substring(2)) ||
+                (first_match && isMatch(s.substring(1), p)));
+    } else {
+        return first_match && isMatch(s.substring(1), p.substring(1));
+    }
+};
@@ -0,0 +1,52 @@
+var solveNQueens = function(n) {
+    const result = [];
+    solveNQueen(result, n);
+    return result;
+};
+
+function solveNQueen(result, size, board = [], row = 0) {
+  if (row === size) {
+    buildResult(result, board, size);
+    return;
+  }
+    
+    for(let col = 0; col < size; col++) {
+      if (safeToPlaceQuen(board, row, col, size)) {
+        board.push(col);
+        solveNQueen(result, size, board, row + 1);
+        board.pop();
+      }
+    }
+}
+
+function safeToPlaceQuen(board, row1, col1, size) {
+  for( let row2 = 0; row2 < row1; row2++) {
+    const col2 = board[row2];
+    
+    if (col1 === col2) {
+      return false;
+    }
+    
+    const colDist = Math.abs(col1 - col2);
+    const rowDist = row1 - row2;
+    
+    if  (colDist === rowDist) {
+      return false;
+    }
+  }
+  
+  return true;
+}
+
+function buildResult(result, board, size) {
+      const boardWithQueens = board.map(col => 
+                          '.'.repeat(col) + 'Q' + '.'.repeat(size - col - 1)
+                         )
+      
+      result.push(boardWithQueens);
+}
+
+
+
+//sample
+console.log(solveNQueens(4));
@@ -0,0 +1,33 @@
+var restoreIpAddresses = function(ques) {
+    
+    if (ques.length > 12 || ques.length < 4) return [];
+    const result = [];
+    restoreIpAddresses_(ques, [], result);
+    return result;
+
+};
+
+const restoreIpAddresses_ = (ques, recAns, result) => {
+    
+    if (recAns.length === 4 && !ques.length) {
+        result.push(Array.from(recAns).join('.'));
+        return;
+    }
+
+    for (let i = 1; i < 4; i++) {
+        
+        if(ques.length < i) continue; 
+
+        const str = ques.slice(0,i);
+        if ((str.length > 1 && str[0] === '0') || Number(str) > 255) continue;
+        
+        recAns.push(str);
+        restoreIpAddresses_(ques.slice(i), recAns, result);
+        recAns.pop();
+
+    }
+}
+
+//test Input.
+var ans=restoreIpAddresses("25525511135");
+console.log(ans);
@@ -0,0 +1,37 @@
+/**
+ * Yields all elements of a matrix in a row-traversing order.
+ * @param {number[][]} matrix
+ * @yield {number} the next element in the matrix
+ */
+function* traverse(matrix) {
+  for (const row of matrix) {
+    for (const cell of row) {
+      yield cell;
+    }
+  }
+}
+
+/**
+ * Reshapes a matrix into a new one with different size but keep its original data.
+ *
+ * Takes a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and column number of the wanted reshaped matrix, respectively.
+ * The reshaped matrix is filled with all the elements of the original matrix in the same row-traversing order as they were.
+ *
+ * If the 'reshape' operation with given parameters isn't possible and legal, outputs the original matrix.
+ *
+ * @param {number[][]} nums
+ * @param {number} r
+ * @param {number} c
+ * @return {number[][]}
+ */
+var matrixReshape = function (nums, r, c) {
+  if (nums.length * nums[0].length !== r * c) {
+    // Both matrices don't hold the same number of elements.
+    return nums;
+  }
+
+  const traversal = traverse(nums);
+  return Array.from({ length: r }, () =>
+    Array.from({ length: c }, () => traversal.next().value)
+  );
+};
@@ -0,0 +1,29 @@
+//Language: Javascript
+//Author: Sarah Sakhri
+//Github: https://github.com/sarahsakhri
+
+let x = [22, 35, 40, 5, 777, 8, 9, 9, 223, 46, 34];
+
+console.log("---- Original array -----");
+console.log(x);
+
+function bubbleSort(array) {
+
+    for (let i = 0; i < array.length; i++) {
+
+        for (let j = 0; j < (array.length - i - 1); j++) {
+
+            if (array[j] > array[j + 1]) {
+
+                let temp = array[j];
+                array[j] = array[j + 1];
+                array[j + 1] = temp;
+            }
+        }
+    }
+}
+
+bubbleSort(x);
+
+console.log("---- Bubble sorted array -----");
+console.log(x);
@@ -0,0 +1,33 @@
+//Language: Javascript
+//Author: Sarah Sakhri
+//Github: https://github.com/sarahsakhri
+
+let x = [66, 0, 19, -45, 26, 56, 15, 21, -98];
+console.log("---- Original array -----");
+console.log(x);
+
+
+function selectionSort(arr) {
+    for (i = 0; i < arr.length; i++) {
+        let min = i;
+        for (let j = i + 1; j < arr.length; j++) {
+            if (arr[j] < arr[min]) {
+                min = j;
+            }
+        }
+
+        if (i !== min) {
+            let temp = arr[i];
+            arr[i] = arr[min];
+            arr[min] = temp;
+        }
+    }
+
+    return arr;
+}
+
+selectionSort(x);
+
+console.log("---- Selection sorted array -----");
+console.log(x);
+
@@ -0,0 +1,48 @@
+/**
+ * @param {string} digits
+ * @return {string[]}
+ */
+var letterCombinations = function(digits) {
+  let sanitizeInput = function(unsanitizedDigits) {
+    let regex = /(\W|_|[0-1a-zA-Z])/g;
+    let sanitized = unsanitizedDigits.replace(regex, "");
+    return sanitized;
+  };
+  const mapping = {
+    2: ["a", "b", "c"],
+    3: ["d", "e", "f"],
+    4: ["g", "h", "i"],
+    5: ["j", "k", "l"],
+    6: ["m", "k", "o"],
+    7: ["p", "q", "r", "s"],
+    8: ["t", "u", "v"],
+    9: ["w", "x", "y", "z"],
+  };
+  let sanitizedDigits = sanitizeInput(digits);
+  if (sanitizedDigits.length > 12) {
+    return "1,388,674 combinations should be more than enough for you. Provide 12 or fewer digits.";
+  }
+  if (sanitizedDigits.length < 1) {
+    return "Nothing to return.";
+  }
+  let finalArray = [];
+
+  const backtrackRecursive = function(combination, nextDigits) {
+    if (nextDigits.length === 0) {
+      finalArray.push(combination);
+    } else {
+      for (let i = 0; i < mapping[nextDigits[0]].length; i += 1) {
+        backtrackRecursive(
+          combination + mapping[nextDigits[0]][i],
+          nextDigits.slice(1)
+        );
+      }
+    }
+  };
+
+  if (sanitizedDigits) {
+    backtrackRecursive("", sanitizedDigits);
+  }
+
+  return finalArray;
+};