added more

Author: MaiDeveloper

__test__/combinations-sum-iii.test.js

@@ -0,0 +1,25 @@
+import combinationSum3 from '../combinations-sum-iii';
+
+describe('Combinations Sum 3', () => {
+
+  test('count = 3, sum = 7', () => {
+    const result = combinationSum3(3, 7);
+    const expected = [
+      [1, 2, 4]
+    ];
+
+    expect(result).toEqual(expected);
+  });
+
+  test('count = 3, sum = 9', () => {
+    const result = combinationSum3(3, 9);
+    const expected = [
+      [1, 2, 6],
+      [1, 3, 5],
+      [2, 3, 4]
+    ];
+
+    expect(result).toEqual(expected);
+  });
+
+});

__test__/generate-parentheses.test.js

@@ -0,0 +1,18 @@
+import generateParentheses from '../generate-parentheses';
+
+describe('Generate Parentheses', () => {
+
+  test('n = 3', () => {
+    const result = generateParentheses(3);
+    const expected = [
+      "((()))",
+      "(()())",
+      "(())()",
+      "()(())",
+      "()()()"
+    ];
+console.log(result);
+    expect(result).toEqual(expected);
+  });
+
+});

__test__/letter-combinations-of-a-phone-number.test.js

@@ -0,0 +1,21 @@
+import letterCombinationsOfAPhoneNumber from '../letter-combinations-of-a-phone-number';
+
+describe('Letter Combinations of a Phone Number', () => {
+
+  test('23', () => {
+    const result = letterCombinationsOfAPhoneNumber('23');
+    const expected = [
+      'ad',
+      'ae',
+      'af',
+      'bd',
+      'be',
+      'bf',
+      'cd',
+      'ce',
+      'cf',
+    ];
+    expect(result).toEqual(expected);
+  });
+
+});

__test__/palindrome-partitioning.test.js

@@ -0,0 +1,12 @@
+import palindromePartitioning from '../palindrome-partitioning';
+
+describe('Palindrome Partitioning', () => {
+  test('aab', () => {
+    const restult = palindromePartitioning('aab');
+    const expected = [
+      ["a","a","b"],
+      ["aa","b"],
+    ];
+    expect(restult).toEqual(expected);
+  });
+});

__test__/permutations-ii.test.js

@@ -0,0 +1,31 @@
+import permutationsII from '../permutations-ii';
+
+describe('Permutations II', () => {
+  test('[1, 1, 2]', () => {
+    const result = permutationsII([1, 1, 2]);
+    const expected = [
+      [1, 1, 2],
+      [1, 2, 1],
+      [2, 1, 1],
+    ];
+    expect(result).toEqual(expected);
+  });
+
+  test('[1]', () => {
+    const result = permutationsII([1]);
+    const expected = [
+      [1],
+    ];
+    expect(result).toEqual(expected);
+  });
+
+  test('[1, 2]', () => {
+    const result = permutationsII([1, 2]);
+    const expected = [
+      [1, 2],
+      [2, 1],
+    ];
+    expect(result).toEqual(expected);
+  });
+
+});

__test__/restore-ip-addresses.test.js

@@ -0,0 +1,14 @@
+import restoreIpAddresses from '../restore-ip-addresses';
+
+describe('Restore IP Addresses', () => {
+
+  test('25525511135', () => {
+    const result = restoreIpAddresses('25525511135');
+    const expected = [
+      '255.255.11.135',
+      '255.255.111.35',
+    ];
+    expect(result).toEqual(expected);
+  });
+
+});

__test__/subsets.test.js

@@ -0,0 +1,18 @@
+import subsets from '../subsets';
+
+describe('Subsets', () => {
+  test('[1, 2, 3]', () => {
+    const result = subsets([1, 2, 3]);
+    const expected = [
+      [],
+      [1],
+      [1, 2],
+      [1, 2, 3],
+      [1, 3],
+      [2],
+      [2, 3],
+      [3]
+    ];
+    expect(result).toEqual(expected);
+  });
+});

combination.js

@@ -0,0 +1,53 @@
+/**
+ * Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.
+ * 
+ * Note:
+ * 
+ * All numbers will be positive integers.
+ * The solution set must not contain duplicate combinations.
+ * Example 1:
+ * 
+ * Input: k = 3, n = 7
+ * Output: [[1,2,4]]
+ * Example 2:
+ * 
+ * Input: k = 3, n = 9
+ * Output: [[1,2,6], [1,3,5], [2,3,4]]
+ */
+
+/**
+ * @param {number} count 
+ * @param {number} sum 
+ * @return {number[][]}
+ */
+const combinationSum3 = (count, sum) => {
+  return getCombinations(count, sum);
+};
+
+/**
+ * 
+ * @param {number} count 
+ * @param {number} sum 
+ * @param {number} num 
+ * @param {number[]} temp 
+ * @param {number[][]} combinations 
+ */
+const getCombinations = (count, sum, num = 1, temp = [], combinations = []) => {
+  if (temp.length > count) {
+    return;
+  }
+
+  if (temp.length === count && sum === 0) {
+    return combinations.push(temp.slice());
+  }
+
+  for (let i = num; i <= 9; i++) {
+    temp.push(i);
+    getCombinations(count, sum - i, i + 1, temp, combinations);
+    temp.pop();
+  }
+
+  return combinations;
+};
+
+export default combinationSum3;

combinations-sum-iii.js

@@ -0,0 +1,67 @@
+/**
+ * Combinations
+ * 
+ * Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.
+ * 
+ * Example:
+ * 
+ * Input: n = 4, k = 2
+ * Output:
+ * [
+ *   [2,4],
+ *   [3,4],
+ *   [2,3],
+ *   [1,2],
+ *   [1,3],
+ *   [1,4],
+ * ]
+ */
+
+const combinations = (n, k) => {
+  return backtracking(n, k);
+};
+
+const backtracking = (num, count, start = 1, list = [], result = []) => {
+  
+  if (list.length > count) {
+    return result;
+  }
+  
+  if (list.length === count) {
+    return result.push(list.slice());
+  }
+
+  for (let i = start; i <= num; i++) {
+    list.push(i);
+    backtracking(num, count, i + 1, list, result);
+    list.pop();
+  }
+
+  return result;
+};
+
+// function combinations (m, n) {
+//   const nums = [0, 1, 2, 3, 4];
+//   const result = [];
+
+//   backtracking(nums, '', 0, 4);
+
+//   function backtracking(nums, str, start, len) {
+//     if (str.length === 3) {
+//       const t = str.split('').sort().join('');
+//       if (result.indexOf(t) === -1) {
+//         result.push(t);
+//       }
+//     }
+
+//     for (let i = start; i <= len; i++) {
+//       backtracking(nums, str + nums[i], start + 1, len);
+//     }
+
+//   }
+
+
+//   return result;
+// }
+
+console.log(combinations(4, 2));

combinations.js

@@ -0,0 +1,36 @@
+/**
+ * Generate Parentheses
+ * Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
+ * 
+ * For example, given n = 3, a solution set is:
+ * 
+ * [
+ *   "((()))",
+ *   "(()())",
+ *   "(())()",
+ *   "()(())",
+ *   "()()()"
+ * ]
+ */
+
+const generateParentheses = n => {
+  return generate(n, n);
+};
+
+const generate = (left, right, parentheses = [], current = '') => {
+  if (left === 0 && right === 0) {
+    return parentheses.push(current);
+  }
+
+  if (left > 0) {
+    generate(left - 1, right, parentheses, current + '(');
+  }
+
+  if (left < right) {
+    generate(left, right - 1, parentheses, current + ')');
+  }
+
+  return parentheses;
+};
+
+export default generateParentheses;