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);