new problem: 1346

Author: ChauDinh

LeetCode/1346/index.js

@@ -0,0 +1,38 @@
+const checkIfExist = function (arr) {
+  if (arr.length === 0) return;
+  let map = new Map();
+
+  for (let i = 0; i < arr.length; i++) {
+    map.set(`${arr[i]}`, { value: arr[i], index: i });
+  }
+
+  for (let i = 0; i < arr.length; i++) {
+    const hasDoubleI = map.has(`${arr[i] * 2}`);
+    const hasDoubleII = map.has(`${arr[i] / 2}`);
+
+    if (hasDoubleI || hasDoubleII) {
+      const idxDoubleI = hasDoubleI ? map.get(`${arr[i] * 2}`).index : -1;
+      const idxDoubleII = hasDoubleII ? map.get(`${arr[i] / 2}`).index : -1;
+      if (i !== idxDoubleI || i !== idxDoubleII) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+console.log(checkIfExist([10, 2, 5, 3, 4]));
+
+// second solution with some()
+
+const checkIfExist2 = (arr) => {
+  if (arr.length === 0) return;
+
+  return (
+    ((x) => arr.some((n) => n === x * 2 || n === x / 2))(arr.pop()) ||
+    checkIfExist(arr)
+  );
+};
+
+console.log(checkIfExist2([10, 2, 5, 3, 4]));

LeetCode/Combination-Sum/index.js

@@ -0,0 +1,26 @@
+/**
+ * Given a set of candidate numbers without duplicates and a target number. Write a function
+ * returns all unique combinations in candidates summing to the target.
+ *
+ * Notes: The same repeated numbers maybe chosen from unlimited times.
+ *
+ * Exp: Input candidates = [2, 3, 5], target = 8;
+ * Output: [
+ *  [2, 2, 2, 2],
+ *  [2, 3, 3],
+ *  [3, 5]
+ * ]
+ */
+
+const combinationSum = (candidates, target) => {
+  let combinations = [];
+  let idx = 0;
+
+  // Sorting the candidates array
+  candidates.sort((a, b) => a - b);
+
+  // Check the special case, target = 0;
+  if (target === 0) return [];
+};
+
+combinationSum([1, 2, 2], 0);

LeetCode/Delete and Earn/deleteAndEarn.js

@@ -0,0 +1,54 @@
+/**
+ * Given two strings, write a function returns the longest common substring
+ *
+ * example: theFunctionName("ABAB", "BABA") would return "ABA" or "BAB"
+ */
+
+// The first thing we will try is using a bruteforce method
+/**
+ * "ABAB"
+ *  ^
+ *  ^
+ * "BABA"
+ *  ^
+ *  ^
+ */
+
+// Helper function
+
+const isSame = (x, y) => {
+  if (x === y) {
+    return true;
+  }
+  return false;
+};
+
+module.exports.longestCommonSubstring = (a, b) => {
+  // convert s1 and s2 to array by split function
+  s1 = a.split("");
+  s2 = b.split("");
+
+  // Initialize the result
+  let result = [];
+
+  // Initial checking
+  if (s1.length === 0 || s2.length === 0) return "";
+
+  // Initialize the 2-dimesional array
+  let cache = new Array(s1.length).map(x => new Array(s2.length));
+
+  for (let i = 0; i < s1.length; i++) {
+    for (let j = 0; j < s2.length; j++) {
+      if (isSame(s1[i], s2[j])) {
+        if (i === 0 || j === 0) {
+          cache[i][j] = 1;
+        } else {
+          cache[i][j] = cache[i - 1][j - 1] + 1;
+        }
+        if (cache[i][j] > result.length) {
+          result = this.longestCommonSubstring(i - length);
+        }
+      }
+    }
+  }
+};

LeetCode/Delete and Earn/deleteAndEarn.spec.js

@@ -0,0 +1,5 @@
+/**
+ * Problem: Given an integer N = 1000. Print all positive integer solutions to the equation a^3 + b^3 = c^3 + d^3 where a, b, c and d are integer between 1 and N
+ */
+
+

LeetCode/Longest Common Substring/longestCommonSubstring.js

@@ -0,0 +1,56 @@
+function ListNode(val) {
+	this.val = val;
+	this.next = null;
+}
+
+ListNode.prototype.addNode = function(node) {
+	if (this.next === null) {
+		this.next = node;
+	}
+};
+
+const addTwoNumbers = function(l1, l2) {
+	// Your code here
+	let result = new ListNode(-1);
+	let cur = result;
+	let carry = 0;
+
+	while (l1 || l2) {
+		let n1 = l1 ? l1.val : 0;
+		let n2 = l2 ? l2.val : 0;
+		let sum = n1 + n2 + carry;
+
+		carry = Math.floor(sum / 10);
+		cur.next = new ListNode(sum % 10);
+		cur = cur.next;
+		if (l1) {
+			l1 = l1.next;
+		}
+		if (l2) {
+			l2 = l2.next;
+		}
+	}
+	if (carry) {
+		cur.next = new ListNode(1);
+	}
+	return result.next;
+};
+
+let l1 = new ListNode(3),
+	val1 = new ListNode(4),
+	val2 = new ListNode(2);
+let l2 = new ListNode(4),
+	val3 = new ListNode(6),
+	val4 = new ListNode(5);
+l1.addNode(val1);
+val1.addNode(val2);
+l2.addNode(val3);
+val3.addNode(val4);
+
+let l3 = new ListNode(9),
+	vall3 = new ListNode(9),
+	vall32 = new ListNode(9);
+
+let l4 = new ListNode(8);
+
+console.log(addTwoNumbers(l1, l2));

LeetCode/Longest Common Substring/longestCommonSubstring.spec.js

@@ -0,0 +1,24 @@
+/**
+ * Min Stack (LeetCode 155)
+ *
+ * Disign a stack supporting push, pop, top, and retrieving the minimum element in a constant time.
+ *
+ * push(x) -- Push element x into stack
+ * pop() -- Removes the element on the top of stack
+ * top() -- Get the top element
+ * getMinValue() -- Retrieve the minimum element in the stack
+ *
+ */
+
+// Consider "Broken Solution" for getMinValue()
+/**
+ * Use a member variable to keep track of the minimum value
+ * It works if there is no pop() operation
+ * We have to use additional memory!
+ *
+ * So we can end up with a solution like below
+ */
+
+// First solution
+
+class MinStack_v1 {}

LeetCode/a-b-c-d-pairs/index.js

@@ -0,0 +1,59 @@
+/**
+ * First solution: Brute fore
+ */
+const twoSumI = function (nums, target) {
+  if (nums.length <= 1) {
+    return [];
+  }
+  for (let i = 0; i < nums.length - 1; i++) {
+    for (let j = i + 1; j < nums.length; j++) {
+      if (nums[i] + nums[j] === target) {
+        return [i, j];
+      }
+    }
+  }
+  return [];
+};
+
+/**
+ * Second solution: Using with binary search
+ */
+const binarySearch = function (arr, value, start, end) {
+  if (start > end) {
+    return null;
+  }
+  let mid = Math.floor((start + end) / 2);
+  if (arr[mid].value === value) return arr[mid].index;
+  if (arr[mid].value > value) {
+    return binarySearch(arr, value, start, mid - 1);
+  }
+  if (arr[mid].value < value) {
+    return binarySearch(arr, value, mid + 1, end);
+  }
+};
+const twoSumII = function (nums, target) {
+  // create object contains elements in nums array and its indexes
+  // exp: [{index: 0, value: 1}, {index: 1, value: 2}, ...]
+  let objNums = [];
+  for (let i = 0; i < nums.length; i++) {
+    objNums.push({
+      index: i,
+      value: nums[i],
+    });
+  }
+  // sort the objNums based e.value
+  objNums.sort((a, b) => a.value - b.value > 0);
+  // binary search the complement in objNums
+  for (let i = 0; i < objNums.length; i++) {
+    let complement = target - objNums[i].value;
+    let complementIdx = binarySearch(objNums, complement, 0, objNums.length);
+    if (complementIdx) {
+      return [i, complementIdx];
+    }
+  }
+};
+
+const twoSumIII = (arr, target) => {};
+
+console.log(twoSumIII([1, 5, 2, 4, 3], 6));
+console.log(twoSumII([1, 5, 2, 4, 3], 6));