feat(dsa): tow sum/three sum/dp/number/string

Author: caiyongmin

README.md

@@ -1,59 +1,57 @@
-# Codes
+# awesome-coding-javascript
 
-📌 some codes, verify code logic with unit tests.
+📌 coding about JavaScript basic principles and data structures and algorithms, verify logic with unit test.
 
-[![codecov](https://codecov.io/gh/caiyongmin/codes/branch/master/graph/badge.svg)](https://codecov.io/gh/caiyongmin/codes)
+[![codecov](https://codecov.io/gh/caiyongmin/codes/branch/master/graph/badge.svg)](https://codecov.io/gh/caiyongmin/codes) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](README.md)
 
 ## JavaScript
 
-- [x] [bind](./src/javascript/bind/bind.test.js)
-- [x] [call](./src/javascript/call/call.js)
-- [x] [apply](./src/javascript/apply/apply.js)
-- [x] [new](./src/javascript/new/new.test.js)
-- [x] [deepclone](./src/javascript/deepclone/deepclone.js)
-- [x] [throttle](./src/javascript/throttle/throttle.js)
-- [x] [debounce](./src/javascript/debounce/debounce.js)
-- [x] [event-emitter](./src/javascript/event-emitter/event-emitter.js)
-- [x] [Promise](./src/javascript/promise/promise.html)
+- [x] [bind](./src/javascript/bind)
+- [x] [call](./src/javascript/call)
+- [x] [apply](./src/javascript/apply)
+- [x] [new](./src/javascript/new)
+- [x] [deepclone](./src/javascript/deepclone)
+- [x] [throttle](./src/javascript/throttle)
+- [x] [debounce](./src/javascript/debounce)
+- [x] [EventEmitter](./src/javascript/event-emitter)
+- [x] [Promise](./src/javascript/promise)
 
 ## Framework & Library & Plugin
 
-- [x] [Babel](./src/bundler/babel/babel.js)
+- [x] [Babel](./src/bundler/babel)
   - input  => [tokenizer](./src/bundler/babel/lib/tokenizer.js)   => tokens
-  - tokens => [parser](./src/bundler/babel/lib/parser.js)      => ast
-  - ast    => [transformer](./src/bundler/babel/lib/transformer.js) => newAst
-  - newAst => [codeGenerator](./src/bundler/babel/lib/codeGenerator.js)   => output
-- [x] [Webpack](./src/bundler/webpack/minipack.js)
-- [x] [Webpack-Plugin](./src/bundler/webpack-plugin/OpenBrowserPlugin.js)
-- [x] [Babel-Plugin](./src/bundler/babel-plugin/babel-plugin-simple-import.js)
-- [x] [Redux](./src/bundler/redux/redux.js)
-- [x] [Router](./src/bundler/router/hashRouter.js)
+  - tokens => [parser](./src/bundler/babel/lib/parser.js)      => AST
+  - AST    => [transformer](./src/bundler/babel/lib/transformer.js) => newAST
+  - newAST => [codeGenerator](./src/bundler/babel/lib/codeGenerator.js)   => output
+- [x] [Webpack](./src/bundler/webpack)
+- [x] [Webpack-Plugin](./src/bundler/webpack-plugin)
+- [x] [Babel-Plugin](./src/bundler/babel-plugin)
+- [x] [Redux](./src/bundler/redux)
+- [x] [Router](./src/bundler/router)
   - [hashRouter](./src/bundler/router/hashRouter.js)
   - [historyRouter](./src/bundler/router/historyRouter.js)
 
 ## DSA
 
-- array
-  - [] two sum
-  - [] three sum
-  - [] [remove duplicate](./src/dsa/array/unique.js)
-- sort
-  - [] [bubble sort](./src/dsa/sort/bubbleSort.js)
-  - [] [selection sort](./src/dsa/sort/selectionSort.js)
-  - [] [insert sort](./src/dsa/sort/insertSort.js)
-  - [] [merge sort](./src/dsa/sort/mergeSort.js)
-  - [] [quick sort](./src/dsa/sort/quickSort.js)
-- dynamic programming
-  - [] min distance
-  - [] min path sum
-- tree
-  - [] binary tree
-  - [] binary search tree
-  - [] tree symmetry
-  - [] tree traversal
-  - [] tree balanced
-- number
-  - [] thousands format
-- string
-  - [] longest common subsquence
-  - [] KMP
+- [Array](./src/dsa/array)
+  - [x] [two sum](./src/dsa/array/twoSum.js)
+  - [x] [three sum](./src/dsa/array/threeSum.js)
+  - [x] [remove duplicate](./src/dsa/array/unique.js)
+- [Sort](./src/dsa/sort)
+  - [x] [bubble sort](./src/dsa/sort/bubbleSort.js)
+  - [x] [selection sort](./src/dsa/sort/selectionSort.js)
+  - [x] [insert sort](./src/dsa/sort/insertSort.js)
+  - [x] [merge sort](./src/dsa/sort/mergeSort.js)
+  - [x] [quick sort](./src/dsa/sort/quickSort.js)
+- [Tree](./src/dsa/tree)
+  - [x] [binary tree](./src/dsa/tree/binaryTree.js)
+  - [x] [binary search tree](./src/dsa/tree/binarySearchTree.js)
+  - [x] [tree symmetry](./src/dsa/tree/treeSymmetry.js)
+  - [x] [tree traversal](./src/dsa/tree/treeTraversal.js)
+- [Dynamic Programming](./src/dsa/dynamicProgramming)
+  - [x] [min edit distance](./src/dsa/dynamicProgramming/minEditDistance.js)
+- [Number](./src/dsa/number)
+  - [x] [thousands format](./src/dsa/number/thousands.js)
+- [String](./src/dsa/string)
+  - [x] [longest common subsquence](./src/dsa/string/longestCommonSub.js)
+  - [x] [KMP](./src/dsa/string/kmp.js)

src/dsa/array/test/threeSum.test.js

@@ -0,0 +1,23 @@
+import { threeSum } from '../threeSum';
+
+describe('three sum', () => {
+  it('no result', () => {
+    const nums = [1, 2, 3];
+    const result = [];
+    expect(threeSum(nums)).toEqual(result);
+  });
+
+  it('has result', () => {
+    const nums = [1, 2, 3, 0 , -1, -2];
+    const target = 1;
+    const result = [ [ -1, 3, -2 ], [ 0, 2, -2 ], [ 0, 1, -1 ] ];
+    expect(threeSum(nums, target)).toEqual(result);
+  });
+});
+
+describe('three sum, throw error', () => {
+  it('threeSum, throw error', () => {
+    const err1 = 'nums must be an array';
+    expect(() => threeSum()).toThrow(err1);
+  });
+});

src/dsa/array/test/twoSum.test.js

@@ -0,0 +1,34 @@
+import { twoSum1, twoSum2 } from './../twoSum';
+
+describe('two sum', () => {
+  it('has result', () => {
+    const arr = [1, 2, 3];
+    const target = 5;
+    const result = [1, 2];
+    expect(twoSum1(arr, target)).toEqual(result);
+    expect(twoSum2(arr, target)).toEqual(result);
+  });
+
+  it('no result', () => {
+    const arr = [1, 2, 3];
+    const target = 1;
+    const result = [];
+    expect(twoSum1(arr, target)).toEqual(result);
+    expect(twoSum2(arr, target)).toEqual(result);
+  });
+});
+
+describe('two sum, throw error', () => {
+  it('twoSum1 and twoSum2, throw error', () => {
+    const err1 = 'target must be a number';
+    const err2 = 'arr must be an array';
+    const err3 = 'arr length must max or equal two';
+    expect(() => twoSum1()).toThrow(err1);
+    expect(() => twoSum1(1, 1)).toThrow(err2);
+    expect(() => twoSum1([], 1)).toThrow(err3);
+
+    expect(() => twoSum2()).toThrow(err1);
+    expect(() => twoSum2(1, 1)).toThrow(err2);
+    expect(() => twoSum2([], 1)).toThrow(err3);
+  });
+});

src/dsa/array/threeSum.js

@@ -0,0 +1,53 @@
+function threeEqualZero(nums, third, results) {
+  if (nums.length < 2) {
+    return;
+  }
+
+  const record = new Set();
+  let i = 0;
+  let j = nums.length - 1;
+
+  while (i < j) {
+    const first = nums[i];
+    const second = nums[j];
+
+    if (first + second + third > 0) {
+      j = j - 1;
+    }
+    else if (first + second + third < 0) {
+      i = i + 1;
+    }
+    else {
+      if (!record.has(first)) {
+        record.add(first);
+        results.push([first, second, third]);
+      }
+      i = i + 1;
+    }
+  }
+}
+
+export function threeSum(nums) {
+  if (!Array.isArray(nums)) {
+    throw new Error('nums must be an array');
+  }
+
+  if (nums.length < 3) {
+    return [];
+  }
+
+  nums.sort((a, b) => a - b);
+  const results = [];
+  const record = new Set();
+
+  for (let i = 0; i < nums.length; i++) {
+    const third = nums[i];
+    if (record.has(third)) {
+      continue;
+    }
+    record.add(third);
+    threeEqualZero(nums.slice(i + 1), third, results);
+  }
+
+  return results;
+}

src/dsa/array/twoSum.js

@@ -0,0 +1,65 @@
+export function twoSum1(arr, target) {
+  if (typeof target !== 'number') {
+    throw new Error('target must be a number');
+  }
+
+  if (!Array.isArray(arr)) {
+    throw new Error('arr must be an array');
+  }
+
+  if (arr.length < 2) {
+    throw new Error('arr length must max or equal two');
+  }
+
+  const set = new Set(arr);
+  let index1;
+  let index2;
+
+  for (let i = 0; i < arr.length; i++) {
+    const number1 = arr[i];
+    const number2 = target - number1;
+
+    if (set.has(number2)) {
+      const index = arr.indexOf(number2);
+      if (i === index) {
+        continue;
+      }
+      index1 = i;
+      index2 = index;
+      break;
+    }
+  }
+
+  if (index1 === undefined) {
+    return [];
+  }
+
+  return [index1, index2];
+}
+
+export function twoSum2(arr, target) {
+  if (typeof target !== 'number') {
+    throw new Error('target must be a number');
+  }
+
+  if (!Array.isArray(arr)) {
+    throw new Error('arr must be an array');
+  }
+
+  if (arr.length < 2) {
+    throw new Error('arr length must max or equal two');
+  }
+
+  const data = {};
+  for (let i = 0; i < arr.length; i++) {
+    const num = arr[i];
+    if (data[target - num] !== undefined) {
+      return [data[target - num], i];
+    }
+    else {
+      data[num] = i;
+    }
+  }
+  return [];
+}
+

src/dsa/dynamicProgramming/minDistance.js

@@ -0,0 +1,31 @@
+export default function minEditDistance(str1, str2) {
+  if (!str1 || !str2) {
+    return Math.max(str1.length, str2.length);
+  }
+
+  const len1 = str1.length;
+  const len2 = str2.length;
+  const matrix = [];
+
+  for (let i = 0; i <= len1; i++) {
+    matrix[i] = [];
+
+    for (let j = 0; j <= len2; j++) {
+      if (i === 0) {
+        matrix[i][j] = j;
+      }
+      else if (j === 0) {
+        matrix[i][j] = i;
+      }
+      else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j - 1] + (str1[i - 1] === str2[j - 1] ? 0 : 1)
+        );
+      }
+    }
+  }
+
+  return matrix[len1][len2];
+}

src/dsa/dynamicProgramming/minEditDistance.js

@@ -0,0 +1,24 @@
+import minEditDistance from './../minEditDistance';
+
+describe('minEditDistance', () => {
+  it('min edit distance, str1 is empty', () => {
+    const str1 = '';
+    const str2 = 'abd';
+    const result = 3;
+    expect(minEditDistance(str1, str2)).toBe(result);
+  });
+
+  it('min edit distance, str2 is empty', () => {
+    const str1 = 'abc';
+    const str2 = '';
+    const result = 3;
+    expect(minEditDistance(str1, str2)).toBe(result);
+  });
+
+  it('min edit distance', () => {
+    const str1 = 'abc';
+    const str2 = 'cbd';
+    const result = 2;
+    expect(minEditDistance(str1, str2)).toBe(result);
+  });
+});

src/dsa/dynamicProgramming/test/minEditDistance.test.js

@@ -0,0 +1,17 @@
+import { thousands1, thousands2 } from '../thousands';
+
+describe('three sum', () => {
+  it('no result', () => {
+    const num = {};
+    const result = '';
+    expect(thousands1(num)).toEqual(result);
+    expect(thousands2(num)).toEqual(result);
+  });
+
+  it('has result', () => {
+    const num = 1234;
+    const result = '1,234';
+    expect(thousands1(num)).toEqual(result);
+    expect(thousands2(num)).toEqual(result);
+  });
+});

src/dsa/number/test/thousands.test.js

@@ -3,3 +3,24 @@
  * https://www.html.cn/archives/7324
  * https://www.cnblogs.com/wangmeijian/p/4163936.html
  */
+
+export function thousands1(num) {
+  num = Number(num);
+
+  if (!num) {
+    return '';
+  }
+
+  return num.toLocaleString('zh');
+}
+
+export function thousands2(num) {
+  num = Number(num);
+
+  if (!num) {
+    return '';
+  }
+
+  num = String(num);
+  return num.replace(/(\d+?)(?=(\d{3})+$)/g, '$1,');
+}