add

Author: ivan0525

package.json

@@ -28,5 +28,9 @@
     "babel-jest": "^24.9.0",
     "jest": "^24.9.0",
     "webpack": "^4.41.2"
+  },
+  "dependencies": {
+    "@types/jest": "^26.0.14",
+    "ramda": "^0.27.1"
   }
 }

src/basic/recursive/fibonacciMemoization.js

@@ -8,4 +8,58 @@ const fibonacciMemoization = function (n) {
   }
   return fibonacci(n);
 };
-console.log(fibonacciMemoization(100));
+console.log(fibonacciMemoization(3));
+
+const fibonacciMemoization1 = function (n) {
+  if (n <= 0) {
+    return 0
+  }
+  const memo = [1, 1]
+  if (n <= 2) {
+    return memo[n - 1]
+  }
+  // 只需存储f(n-1)和f(n-2)的值
+  for (let i = 3; i <= n; i++) {
+    [memo[0], memo[1]] = [memo[1], memo[0] + memo[1]]
+  }
+  return memo[1]
+}
+
+// [3,2,1,0,4]
+const jump = function (nums) {
+  const len = nums.length
+  let maxJumpLength = 0
+  for (let i = 0; i < len; ++i) {
+    if (i <= maxJumpLength) {
+      maxJumpLength = Math.max(maxJumpLength, nums[i] + i)
+      if (maxJumpLength >= len - 1) {
+        return true
+      }
+    }
+  }
+  return false
+}
+// console.log(jump([1, 1]))
+
+const canJump = function (nums) {
+  // The "good" cell is a cell from which we may jump to the last cell of the nums array.
+
+  // The last cell in nums array is for sure the "good" one since it is our goal to reach.
+  let leftGoodPosition = nums.length - 1;
+
+  // Go through all nums from right to left.
+  for (let numberIndex = nums.length - 2; numberIndex >= 0; numberIndex -= 1) {
+    // If we can reach the "good" cell from the current one then for sure the current
+    // one is also "good". Since after all we'll be able to reach the end of the array
+    // from it.
+    const maxCurrentJumpLength = numberIndex + nums[numberIndex];
+    if (maxCurrentJumpLength >= leftGoodPosition) {
+      leftGoodPosition = numberIndex;
+    }
+  }
+
+  // If the most left "good" position is the zero's one then we may say that it IS
+  // possible jump to the end of the array from the first cell;
+  return leftGoodPosition === 0;
+}
+console.log(canJump([1, 1]));

src/basic/recursive/test.js

@@ -0,0 +1,172 @@
+const coinList = [1,2,5];
+const count = 10;
+
+/**
+ * 
+ * 暴力
+ * 
+ * 
+  function coinCount(coinList, count) {
+    function dp(n) {
+      if (n === 0) {
+        return 0;
+      }
+      if (n < 0) {
+        return -1;
+      }
+      let res = Number.MAX_SAFE_INTEGER;
+      for (let i = 0; i < coinList.length; i++) {
+        const sub = dp(n - coinList[i]);
+        // 子问题无解
+        if (sub < 0) {
+          continue;
+        }
+        res = Math.min(res, 1 + sub);
+      }
+      return res;
+    }
+    return dp(count);
+  }
+
+console.log(coinCount(coinList, count));
+ */
+
+
+/*
+function coinCount(coinList, count) {
+  // 带备忘录的递归
+  const memo = {0:0};
+  function dp(n) {
+    if (memo.hasOwnProperty(n)) {
+      return memo[n];
+    }
+    if (n === 0) {
+      return 0;
+    }
+    if (n < 0) {
+      return -1;
+    }
+    let res = Number.MAX_SAFE_INTEGER;
+    for (let i = 0; i < coinList.length; i++) {
+      const sub = dp(n - coinList[i]);
+      // 子问题无解
+      if (sub < 0) {
+        continue;
+      }
+      res = Math.min(res, 1 + sub);
+    }
+    res !== Number.MAX_SAFE_INTEGER ? memo[n] = res : memo[n] = -1;
+    return memo[n];
+  }
+  return dp(count);
+}
+
+console.log(coinCount(coinList, count));
+ */
+
+function coinCount(coinList, count) {
+  // 初始化db数组
+  // 凑成count，最多需要count个硬币（全部为1元的）
+  const dp = Array(count+1).fill(count+1);
+  dp[0] = 0;
+  // i = 0,无效
+  for (let i = 1; i < dp.length; i++) {
+    for (let j = 0; j < coinList.length; j++) {
+      if (i - coinList[j] < 0) {
+        continue;
+      }
+      // Math.min当其中某个参数不能转换成number类型是，返回结果为NaN
+      if(isNaN(dp[i])) {
+        dp[i] = 1 + dp[i-coinList[j]];
+      } else {
+        dp[i] = Math.min(dp[i], 1 + dp[i-coinList[j]]);
+      }
+    }
+  }
+  return dp[count] === count + 1 ? -1 : dp[count];
+}
+
+console.log(coinCount(coinList, count));
+
+// 0 1 2 3 4
+// 1 4 3 4 2
+
+// dp[3] = 3; ==> 1,3,4
+// dp[4] = 2; ==> 1,2
+// dp = [1, 2, 2, 3, 2] // 最长子序的长度
+const arr = [10,9,2,5,3,7,101,18];
+function maxIncrease(list) {
+  // dp[i]代表以list[i]结尾的子序长度，而以list[i]结尾的字序必须包含list[i]这个元素，所以将db数组全部初始化为1，即：最小字序长度。
+  const dp = Array(list.length).fill(1);
+  for (let i = 0; i < list.length; i++) {
+    for (let j = 0; j < i; j++) {
+      // 以list[i]结尾的子序
+      if (list[i] > list[j]) {
+        dp[i] = Math.max(dp[i], dp[j] + 1);
+      }
+    }
+  }
+  let res = 0;
+  for (let i = 0; i < dp.length; i++) {
+    res = Math.max(res, dp[i]);
+  }
+  return res;
+}
+
+// console.log(maxIncrease(arr));
+
+// matrix[i][j]只能由matrix[i-1][j+1]、matrix[i-1][j]、matrix[i-1][j-1]
+const matrix = [[2, 1, 3], [6, 5, 4], [7, 8, 9]];
+/**
+ * 
+function dp(matrix, i, j) {
+  if (i<0||j<0||i>=matrix.length||j>=matrix[0].length) {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  // 到了最顶层直接返回
+  if (i === 0) {
+    return matrix[i][j];
+  }
+  return matrix[i][j] + Math.min(dp(matrix, i-1, j-1), dp(matrix, i-1, j), dp(matrix, i-1, j+1));
+}
+
+function minFallingPath(matrix) {
+  let res = Number.MAX_SAFE_INTEGER;
+  let len = matrix.length;
+  
+  for (let i = 0; i < len; i++) {
+    res = Math.min(res, dp(matrix, len-1, i));
+  }
+  return res;
+}
+
+console.log('minFallingPath==> ', minFallingPath(matrix));
+ */
+
+let memo;
+function dp(matrix, i, j) {
+  if (i<0||j<0||i>=matrix.length||j>=matrix[0].length) {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  // 到了最顶层直接返回
+  if (i === 0) {
+    return matrix[0][j];
+  }
+  if (memo[i][j] !== Number.MAX_SAFE_INTEGER) {
+    return memo[i][j];
+  }
+  memo[i][j] = matrix[i][j] + Math.min(dp(matrix, i-1, j-1), dp(matrix, i-1, j), dp(matrix, i-1, j+1));
+  return memo[i][j];
+}
+
+function minFallingPath(matrix) {
+  let res = Number.MAX_SAFE_INTEGER;
+  let len = matrix.length;
+  memo = Array(len).fill(Array(len).fill(Number.MAX_SAFE_INTEGER));
+  for (let i = 0; i < len; i++) {
+    res = Math.min(res, dp(matrix, len-1, i));
+  }
+  return res;
+}
+
+console.log('minFallingPath==> ', minFallingPath(matrix));

src/basic/regexp/index.js

@@ -0,0 +1,22 @@
+/**
+ * match position
+ */
+
+// var result = "I\nlove\njavascript".replace(/^|$/mg, '♥');
+// console.log(result);
+
+// 单词边界
+// const result = "[JS] Lesson_01.mp4".replace(/\b/g, '#');
+// console.log(result);
+
+
+/**
+ * (?=p)和(?!p) => "p"是一个子模式
+ * (?=p)：表示匹配"p"前面的位置
+ * (?!p)：表示与(?=p)的结果相反，不匹配"p"的前面位置(其他位置都匹配)
+ * 
+ */
+// const result = "hello".replace(/(?=l)/g, '♥');
+// console.log(result);
+const result = "hello".replace(/(?!o)/g, "♥");
+console.log(result);

src/basic/regexp/less-if.js

@@ -0,0 +1,9 @@
+const R = require('ramda')
+
+const fn = R.cond([
+  [R.equals(0), R.always('water freezes at 0°C')],
+  [R.equals(100), R.always('water boils at 100°C')],
+  [R.T, (temp) => `nothing special happends at ${temp}°C`]
+])
+
+console.log(fn(0), fn(20), fn(100))

src/basic/regexp/letterCasePermutation.js

@@ -0,0 +1,23 @@
+function letterCasePermutation(S) {
+  const res = []
+  const backtrack = (str, i) => {
+    if (i === S.length) {
+      return res.push(str)
+    }
+    const cur = S[i]
+    // 对于字母
+    if ((cur >= 'A' && cur <= 'Z') || (cur >= 'a' && cur <= 'z')) {
+      const low = str + cur.toLowerCase(),
+        upper = str + cur.toUpperCase()
+      backtrack(low, i + 1)
+      backtrack(upper, i + 1)
+    } else {
+      // 对于数字
+      backtrack(str + cur, i + 1)
+    }
+  }
+  backtrack('', 0)
+  return res
+}
+
+console.log(letterCasePermutation('a1b2'))

src/basic/regexp/lookAhead.js

@@ -0,0 +1,8 @@
+export function lookAhead (str) {
+  // const reg = /\d+(?=€)/
+  // const reg = /(?<![-\d])\d+/g
+  // const reg =  /(?!\b)(?=(\d{3})+\b)/g
+  const reg = /(?<quote>['"])(.*?)\k<quote>/g
+
+  return str.match(reg)
+}

src/basic/regexp/lookAhead.test.js

@@ -0,0 +1,13 @@
+import {lookAhead} from './lookAhead'
+
+describe('test lookAhead',() => {
+  it('search amount', ()=> {
+    // const str = '1 turkey costs 30€'
+    //  const str = '0 12 -5 123 -18'
+    // /(?=(\d{3})+\b)/g
+    // const str = '517654321'
+    const str = `He said: "She's the one!".`
+    const expectResult = "She's the one!"
+    expect(lookAhead(str)).toEqual(expectResult)
+  })
+})

src/basic/regexp/lookBehind.js

@@ -0,0 +1,4 @@
+export function lookBehind (str) {
+  const reg = /(?<=(\$|£))\d+/
+  return str.match(reg)
+}

src/basic/regexp/lookBehind.test.js

@@ -0,0 +1,9 @@
+import {lookBehind} from './lookBehind'
+
+describe('test lookBehind', () => {
+  it('search amount', () => {
+    const str = '衬衫的价格是：$300，所以你选择B答案！'
+    const expectResult = '$300'
+    expect(lookBehind(str)).toEqual(expectResult)
+  })
+})