feat(algorithms): update 27 and add 67 && 189 && 209 && 485

Author: guocaoyi

algorithms/0027.remove-element/index.jest.ts

@@ -3,29 +3,39 @@ import { removeElement } from '.';
 let a: number[] = [];
 let filter = 1;
 let len = removeElement(a, filter);
-console.info('-->', a, `filter ${filter}, ant len is ${len}\n`);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
 
 a = [0];
 filter = 1;
 len = removeElement(a, filter);
-console.info('-->', a, `filter ${filter}, ant len is ${len}\n`);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
 
 a = [1];
 filter = 1;
 len = removeElement(a, filter);
-console.info('-->', a, `filter ${filter}, ant len is ${len}\n`);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
+
+a = [3, 2, 2, 3];
+filter = 3;
+len = removeElement(a, filter);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
+
+a = [0, 1, 2, 2, 3, 0, 4, 2];
+filter = 2;
+len = removeElement(a, filter);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
 
 a = [1, 1, 1, 1, 1, 1];
 filter = 1;
 len = removeElement(a, filter);
-console.info('-->', a, `filter ${filter}, ant len is ${len}\n`);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
 
 a = [1, 1, 1, 1, 1, 1, 1];
 filter = 2;
 len = removeElement(a, filter);
-console.info('-->', a, `filter ${filter}, ant len is ${len}\n`);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');
 
 a = [1, 2, 32, 4, 5, 6, 7, 8, 9];
 filter = 32;
 len = removeElement(a, filter);
-console.info('-->', a, `filter ${filter}, ant len is ${len}\n`);
+console.info('-->', a, `filter ${filter}, ant len is`, len, '\n');

algorithms/0027.remove-element/index.ts

@@ -1,5 +1,3 @@
-import { S_IFBLK } from 'constants';
-
 /**
  * 逻辑没有考虑完备，导致很多测试用力无法通过
  * @state Error
@@ -22,30 +20,18 @@ export const removeElement1 = (nums: number[], val: number): number => {
 };
 
 /**
+ * 尾部判定
  * @state Accepted
- * @runtime
- * @memory
+ * @runtime 112ms > 28.81%
+ * @memory 33.8MB < 30.90%
  */
 export const removeElement = (nums: number[], val: number): number => {
- // 伪代码
- // head === val && tail === val; while(p >= 0 && p !== val) replace;i++;p--;
- // head === val && tail !== val; replace;i++;p--;
- // head !== val && tail === val; i++;p--;
- // head !== val && tail !== val; i++;
-
- let p: number = nums.length - 1;
- for (let i: number = 0; i < nums.length && p >= 0; i++, i = nums.length) {
- console.info(`::for::---> i:${i}, p:${p}`);
- if (nums[i] === val) {
- while (p >= 0 && nums[p--] === val) console.info(`::while::--->${p}`);
- if (p < 0) break;
- nums[i] = nums[i] ^ nums[p];
- nums[p] = nums[i] ^ nums[p];
- nums[i] = nums[i] ^ nums[p];
- nums.length = p; // remove the filter element;change numbers[] length
- } else if (nums[p] !== val) continue;
- p--;
+ for (let p: number = 0; p < nums.length; p++) {
+ while (nums[nums.length - 1] === val) nums.length--;
+ if (p >= nums.length - 1) break;
+ nums[p] = nums[p] ^ nums[nums.length - 1];
+ nums[nums.length - 1] = nums[nums.length - 1] ^ nums[p];
+ nums[p] = nums[p] ^ nums[nums.length - 1];
  }
- console.info(`::$::---->p:${p},nums:`, nums);
  return nums.length;
 };

algorithms/0067.add-binary/README.md

@@ -0,0 +1,24 @@
+# 67. Add Binary
+
+Given two binary strings, return their sum (also a binary string).
+
+The input strings are both **non-empty** and contains only characters 1 or 0.
+
+## Example
+
+```bash
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+```bash
+Input: a = "1010", b = "1011"
+Output: "10101"
+```
+
+## Related Tips
+
+- Math
+- String
+
+## Submissions

algorithms/0067.add-binary/index.jest.ts

@@ -0,0 +1,36 @@
+import { addBinary2 } from '.';
+
+let result: string;
+let answer: string;
+
+// result = addBinary2('11', '1');
+// answer = '100';
+// console.info('--->', result, '100', result === answer, '\n');
+
+// result = addBinary2('1010', '1011');
+// answer = '10101';
+// console.info('--->', result, '10101', result === answer, '\n');
+
+// result = addBinary2('11111', '11111');
+// answer = '100000';
+// console.info('--->', result, '100000', result === answer, '\n');
+
+// result = addBinary2('11111', '0');
+// answer = '11111';
+// console.info('--->', result, '11111', result === answer, '\n');
+
+// result = addBinary2('0', '11111');
+// answer = '11111';
+// console.info('--->', result, '11111', result === answer, '\n');
+
+// result = addBinary2('11110', '1');
+// answer = '11111';
+// console.info('--->', result, '11111', result === answer, '\n');
+
+result = addBinary2(
+ '10100000100100110110010000010101111011011001101110111111111101000000101111001110001111100001101',
+ '110101001011101110001111100110001010100001101011101010000011011011001011101111001100000011011110011'
+);
+answer =
+ '110111101100010011000101110110100000011101000101011001000011011000001100011110011010010011000000000';
+console.info('--->', result, result === answer, '\n');

algorithms/0067.add-binary/index.ts

@@ -0,0 +1,41 @@
+/**
+ * 原生方法
+ * 无脑转换类型，忽略了 Number.MAX_SAFE_INTEGER 的损失精度的情况
+ * @param {string} a
+ * @param {string} b
+ * @return {string}
+ * @state Error
+ * @case '10100000100100110110010000010101111011011001101110111111111101000000101111001110001111100001101'
+ * "110101001011101110001111100110001010100001101011101010000011011011001011101111001100000011011110011"
+ */
+export const addBinary = (a: string, b: string): string => {
+ return Number(parseInt(a, 2) + parseInt(b, 2)).toString(2);
+};
+
+/**
+ * 逐位计算
+ * @param {string} a
+ * @param {string} b
+ * @return {string}
+ * @state Accepted
+ */
+export const addBinary2 = (a: string, b: string): string => {
+ const result: number[] = [];
+ let fix: number = 0;
+ for (let p = a.split(''), n = b.split(''); p.length > 0 || n.length > 0; ) {
+ let sum = Number(p.pop() || '0') + Number(n.pop() || '0') + fix;
+ if (sum <= 1) {
+ fix = 0;
+ }
+ if (sum === 2) {
+ fix = 1;
+ sum = 0;
+ } else if (sum === 3) {
+ fix = 1;
+ sum = 1;
+ }
+ result.unshift(sum);
+ }
+
+ return (fix === 1 ? '1' : '') + result.join('');
+};

algorithms/0189.retate-array/README.md

@@ -0,0 +1,33 @@
+# 189 Retate Array
+
+Given an array, rotate the array to the right by k steps, where k is non-negative.
+
+## Example
+
+```bash
+Input: [1,2,3,4,5,6,7] and k = 3
+Output: [5,6,7,1,2,3,4]
+Explanation:
+rotate 1 steps to the right: [7,1,2,3,4,5,6]
+rotate 2 steps to the right: [6,7,1,2,3,4,5]
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+```
+
+```bash
+Input: [-1,-100,3,99] and k = 2
+Output: [3,99,-1,-100]
+Explanation:
+rotate 1 steps to the right: [99,-1,-100,3]
+rotate 2 steps to the right: [3,99,-1,-100]
+```
+
+## Follow up
+
+If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).
+
+## Note
+
+Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
+Could you do it in-place with O(1) extra space?
+
+## Submissions

algorithms/0189.retate-array/index.jest.ts

@@ -0,0 +1,41 @@
+import { rotate } from '.';
+
+let nums: number[] = [1];
+let k: number = 5;
+console.info('-->', [1]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 0;
+console.info('-->', [1, 2, 3, 4, 5]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 2;
+console.info('-->', [4, 5, 1, 2, 3]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 4;
+console.info('-->', [2, 3, 4, 5, 1]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 5;
+console.info('-->', [1, 2, 3, 4, 5]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 7;
+console.info('-->', [4, 5, 1, 2, 3]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 10;
+console.info('-->', [1, 2, 3, 4, 5]);
+console.info('-->', rotate(nums, k), '\n');
+
+nums = [1, 2, 3, 4, 5];
+k = 18;
+console.info('-->', [3, 4, 5, 1, 2]);
+console.info('-->', rotate(nums, k), '\n');

algorithms/0189.retate-array/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+export const rotate = (nums: number[], k: number): void => {
+ if (k === 0 || nums.length === 0) return;
+ let ret: number = k % nums.length;
+ if (ret === 0) return;
+ for (let i = 0; i < ret; i++) {}
+};

algorithms/0209.minimum-size-subarray-sum/README.md

@@ -0,0 +1,23 @@
+# 209. Minimum Size Subarray Sum
+
+Given an array of n positive integers and a positive integer s, find the minimal length of a **contiguous** subarray of which the sum ≥ s. If there isn't one, return 0 instead.
+
+## Example
+
+```bash
+Input: s = 7, nums = [2,3,1,2,4,3]
+Output: 2
+Explanation: the subarray [4,3] has the minimal length under the problem constraint.
+```
+
+## Follow up
+
+If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).
+
+## Related Tips
+
+- Array
+- Two Pointer
+- Binary Search
+
+## Submissions

algorithms/0209.minimum-size-subarray-sum/index.jest.ts

@@ -0,0 +1,25 @@
+import { minSubArrayLen } from '.';
+
+console.info(1, [1]);
+console.info('-->>', minSubArrayLen(1, [1]), '\n');
+
+console.info(2, [1]);
+console.info('-->>', minSubArrayLen(2, [1]), '\n');
+
+console.info(4, [1, 1, 1, 1, 2, 2]);
+console.info('-->>', minSubArrayLen(4, [1, 1, 1, 1]), '\n');
+
+console.info(7, [1, 1, 1, 1]);
+console.info('-->>', minSubArrayLen(7, [1, 1, 1, 1]), '\n');
+
+console.info(7, [2, 3, 1, 2, 5, 3]);
+console.info('-->>', minSubArrayLen(7, [2, 3, 1, 2, 5, 3]), '\n');
+
+console.info(9, [9, 3, 1, 2, 8, 3]);
+console.info('-->>', minSubArrayLen(9, [9, 3, 1, 2, 8, 3]), '\n');
+
+console.info(9, [1, 3, 1, 2, 8, 3, 9]);
+console.info('-->>', minSubArrayLen(9, [1, 3, 1, 2, 8, 3, 9]), '\n');
+
+console.info(2, [1, 4, 5, 6, 7, 8, 9]);
+console.info('-->>', minSubArrayLen(2, [1, 4, 5, 6, 7, 8, 9]), '\n');