js-concepts: minDistance voz

Author: baochau.dinh

.DS_Store

@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "macFrameworkPath": [
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "macos-clang-arm64"
+        }
+    ],
+    "version": 4
+}

.vscode/c_cpp_properties.json

@@ -0,0 +1,50 @@
+// you can write to stdout for debugging purposes, e.g.
+// console.log('this is a debug message');
+
+function solution(X, Y, colors) {
+    // write your code in JavaScript (Node.js 8.9.4)
+    if (X.length === 0 || Y.length === 0 || colors.length === 0) return 0;
+    if (X.length !== Y.length || X.length !== colors.length) return 0;
+
+    const numberOfPoints = X.length;
+
+    // calculate distance from O to given points
+    const distances = new Array(numberOfPoints).map(x => 0);
+    for (let i = 0; i < numberOfPoints; i++) {
+      distances[i] = {
+        color: colors[i],
+        value: Math.pow(X[i], 2) + Math.pow(Y[i], 2),
+      };
+    }
+    
+    // Sort distances
+    distances.sort((a, b) => a.value - b.value);
+
+    // Calculate frequency
+    let freqDistance = {};
+    for (let i = 0; i < distances.length; i++) {
+      freqDistance[distances[i].value] = {
+        freq: freqDistance[distances[i].value] ? freqDistance[distances[i].value].freq + 1 : 1,
+        weight: freqDistance[distances[i].value] 
+        ? distances[i].color === 'G' 
+          ? freqDistance[distances[i].value].weight + 1 
+          : freqDistance[distances[i].value].weight - 1 
+        : distances[i].color === 'G' 
+          ? 1 
+          : -1
+      };
+    }
+    
+    let result = 0;
+    let count = 0;
+    let currFreq = 0;
+    for (const distance in freqDistance) {
+      count += freqDistance[distance].weight;
+      currFreq += freqDistance[distance].freq;
+      if (count === 0) result = currFreq;
+    }
+
+    return result;
+}
+
+console.log(solution([4, 0, 2, -2], [4, 1, 2, -3], 'RGRR'));

Algo101/.DS_Store

@@ -0,0 +1,27 @@
+/**
+ * Problem: https://app.codility.com/c/run/training92BUEY-XCH/
+ */
+
+function solution (A, B, K) {
+  if (A === B === 0) return 0;
+  if (K === 1) return B - A + 1;
+  
+  let result = 0;
+  for (let step = A; step <= B; step++) {
+    if (step % K === 0) {
+      result++;
+      step += K - 1;
+    }
+  }
+
+  return result;
+} 
+
+console.log(solution(6, 10, 2));
+
+function solutionV2 (A, B, K) {
+  if (A === B === 0) return 0;
+  return Math.floor(B/K) - Math.ceil(A/K) + 1;
+}
+
+console.log(solutionV2(6, 10, 2));

Algo101/CodilityTraining/codility-1.js

@@ -0,0 +1,33 @@
+function solution(A) {
+  if (A.length === 0) return 0;
+  const markedArray = new Array(1000000).fill(false);
+
+  for (let i = 0; i < A.length; i++) {
+    if (A[i] > 0) markedArray[A[i]] = true;
+  }
+
+  for (let i = 1; i < markedArray.length; i++) {
+    if (markedArray[i] === false) return i;
+  }
+
+  return null;
+}
+
+console.log(solution([-2, 2, 0, 4, 5]));
+
+function solutionV2(A) {
+  if (A.length === 0) return 0;
+  let currItem = 1;
+
+  A.sort((a, b) => a - b);
+
+  for (let i = 0; i < A.length; i++) {
+    if (A[i] > 0 && A[i] === currItem) {
+      currItem = A[i] + 1;
+    }
+  }
+
+  return currItem;
+}
+
+console.log(solutionV2([-2, 2, 0, 4, 5]))

Algo101/CodilityTraining/countDiv.js

@@ -0,0 +1,65 @@
+/**
+ * This problem was asked by Google
+ * 
+ * Given a sorted array of integers, square the elements of the array and
+ * give the output in sorted order
+ * 
+ * Ex: [-9, -2, 0, 2, 3]
+ * Output: [0, 4, 4, 9, 81]
+ */
+
+class Solution {
+  constructor(input) {
+    this.input = input || [];
+  }
+
+  answer() { // O(nlogn)
+    const shadowCopyInput = [...this.input];
+    let squareNumbers = shadowCopyInput.map((number) => number * number); // O(n);
+
+    return squareNumbers.sort((a, b) => a - b); // O(nlogn);
+  }
+
+  optimizedAnswer() {
+    const shadowCopyInput = [...this.input];
+    const result = [];
+    let first = 0, second = shadowCopyInput.length - 1;
+
+    /**
+     * [-9, -2, 0, 2, 3]
+     * first           second
+     * 
+     */
+    while (first <= second) {
+      const firstSquare = Math.pow(shadowCopyInput[first], 2);
+      const secondSquare = Math.pow(shadowCopyInput[second], 2);
+      if (firstSquare < secondSquare) {
+        result.unshift(firstSquare);
+        first++;
+      } else {
+        result.unshift(secondSquare);
+        second--;
+      }
+    }
+
+    return result;
+  }
+
+  logger() { // O(nlogn)
+    const result = this.answer();
+    console.log('result: ', result);
+    return;
+  }
+
+  optimizedLogger() {
+    const result = this.optimizedAnswer();
+    console.log('result: ', result);
+    return;
+  }
+}
+
+const solution = new Solution([-9, -2, 0, 2, 3]);
+solution.logger(); // O(nlogn)
+solution.optimizedLogger();
+
+

Algo101/CodilityTraining/smallestIntegerNotAppear.js

@@ -0,0 +1,18 @@
+/**
+ * Tìm số fibonacci thứ Nth
+ */
+
+function findFib (n) {
+  if (n === 0) return 0;
+  if (n === 1 || n === 2) return 1;
+
+  let first = 1, second = 1;
+  for (let i = 2; i <= n; i++) {
+    second = first + second;
+    first = second - first;
+  }
+
+  return first;
+}
+
+console.log(findFib(1000));

Algo101/Daily-Coding-Problems/sortedArrayOfSquare.js

@@ -0,0 +1,17 @@
+function isSubsequence(a, b) {
+  if (a.length === 0 || b.length === 0) return false
+  
+  let first = 0, second = 0;
+  while (first < a.length && second < b.length) {
+    if (a[first] === b[second]) {
+      first++;
+      second++;
+    } else {
+      first++;
+    }
+  }
+  if (second < b.length) return false;
+  return true;
+}
+
+console.log(isSubsequence('aabb', 'ba'));

Algo101/Day1/problem1.js

@@ -0,0 +1,21 @@
+function solveLCS (a, b) {
+  function LCS(n, m) {
+    if (n * m === 0) return 0;
+    
+    if (a[n-1] === b[m-1]) return LCS(n-1, m-1) + 1;
+    return Math.max(LCS(n-1, m), LCS(n, m-1));
+  }
+
+  return LCS(a.length, b.length);
+}
+
+function dpLCS (a, b) {
+  if (a.length * b.length === 0) return 0;
+
+  
+}
+
+// 2-Dimension array
+let newArr = new Array(3).fill(0).map(item => new Array(3))
+
+console.log('new array: ', newArr);

Algo101/Dynamic-Programming/isSubsequence.js

@@ -0,0 +1,87 @@
+function findMaxPalindrome (A) {
+  if (A.length === 0) return 0;
+
+  let p = new Array(A.length + 2).fill(1).map(x => new Array(A.length + 2).fill(1));
+
+  let first = 1, second = A.length;
+  while (first < A.length / 2 && second >= A.length / 2) {
+    if (A[first] === A[second]) {
+      p[first][second] = 2 + p[first + 1][second - 1];
+      first++;
+      second--;
+    } else {
+      p[first][second] = Math.max(p[first][second - 1], p[first + 1][second]);
+      first++;
+      second--;
+    }
+  }
+
+  return p
+}
+
+console.log(findMaxPalindrome('abba'));
+
+function isPalindrome(str) {
+  return str === str.split("").reverse().join("");
+}
+
+function solveLPS(seq, i, j) {
+
+  // case: only one character
+  if (i === j) return 1;
+
+  // case: only two same characters
+  if (seq[i] === seq[j] && i + 1 === j) {
+    return 2;
+  }
+
+  // case: first and last characters match
+  if (seq[i] === seq[j]) {
+    return solveLPS(seq, i + 1, j - 1) + 2;
+  }
+
+  return Math.max(solveLPS(seq, i, j - 1), solveLPS(seq, i + 1, j));
+}
+
+console.log(solveLPS('abba', 0, 3));
+
+/**
+ * 
+ *              L(0, 5)
+             /        \ 
+            /          \  
+        L(1,5)          L(0,4)
+       /    \            /    \
+      /      \          /      \
+  L(2,5)    L(1,4)  L(1,4)  L(0,3)
+
+ */
+
+function solveDpLPS(seq) {
+  let length = seq.length;
+  let i, j, col;
+
+  let dpTable = new Array(length).fill(0).map(x => new Array(length).fill(0));
+
+  for (let i = 0; i < length; i++) {
+    dpTable[i][i] = 1;
+  }
+
+  for (col = 2; col <= length; col++) {
+    for (i = 0; i < length - col + 1; i++) {
+      j = i + col - 1;
+
+      if (seq[i] === seq[j] && col === 2) {
+        dpTable[i][j] = 2;
+      } else if (seq[i] === seq[j]) {
+        dpTable[i][j] = dpTable[i + 1][j - 1] + 2;
+      } else {
+        dpTable[i][j] = Math.max(dpTable[i][j - 1], dpTable[i + 1][j]);
+      }
+    }
+  }
+  
+  return dpTable[0][length - 1];
+}
+
+console.log(solveDpLPS('ABBA'));

Algo101/Dynamic-Programming/lcs.js

@@ -0,0 +1,2 @@
+const worker = new Worker('./worker.js');
+worker.postMessage('Hello, world!');

Algo101/Dynamic-Programming/palindromeSubsequence.js

@@ -0,0 +1 @@
+self.onmessage = msg => console.log(msg.data);

Algo101/Multithreads/index.js

@@ -0,0 +1,7 @@
+## A general way to solve algorithm problems
+
+#### Step 1: Define problem
+
+#### Step 2: Representation
+
+#### Step 3: Approach/Strategy