codility problems: practice

Author: ChauDinh

codility/abLetters.js

@@ -0,0 +1,31 @@
+function solution(S) {
+  let strArr = S.split("");
+  let first = 0;
+  let second = 1;
+
+  while (second > first && second < S.length) {
+    if (strArr[first] === "b") {
+      if (strArr[second] === "a") {
+        return false;
+      } else {
+        first = second;
+        second++;
+      }
+    } else {
+      first = second;
+      second++;
+    }
+  }
+
+  return true;
+}
+
+console.log(solution("aabbabb"));
+
+/**
+ * aabbb => true 11000
+ * ba => false 01
+ * aaa => true 111
+ * b => true 0
+ * abba => false 1001
+ */

codility/binaryGap.js

@@ -0,0 +1,37 @@
+/**
+ * Binary Gap
+ *
+ * 1 0 0 0 1 0 0 1 0 1 => 3
+ *
+ *
+ */
+
+function solution(N) {
+  const bin = N.toString(2).split("");
+  let max = 0; // the initial maximum gap
+  let currMax = 0; // the current maximum gap
+  let left = 0;
+  let right = 1;
+
+  while (left < right && right < bin.length) {
+    if (bin[left] === "0") {
+      left++;
+      right++;
+      currMax = 0;
+    } else {
+      if (bin[right] === "0") {
+        currMax++;
+        right++;
+      } else {
+        max = Math.max(currMax, max);
+        currMax = 0;
+        left = right;
+        right++;
+      }
+    }
+  }
+
+  return max;
+}
+
+console.log(solution(32));

codility/binaryTree.js

@@ -0,0 +1,31 @@
+function solution() {
+  // write your code in JavaScript (Node.js 8.9.4)
+  const longestUnivaluePath = (root) => {
+    const helper = (node) => {
+      if (!node) {
+        return 0;
+      }
+
+      let left = helper(node.left);
+      let right = helper(node.right);
+
+      if (node.left) {
+        left += node.left.val === node.val ? 1 : -left;
+      }
+
+      if (node.right) {
+        right += node.right.val === node.val ? 1 : -right;
+      }
+
+      max = Math.max(max, left + right);
+
+      return Math.max(left, right);
+    };
+
+    let max = 0;
+    helper(root);
+    return max;
+  };
+
+  return longestUnivaluePath(T);
+}

codility/frogJump.js

@@ -0,0 +1,9 @@
+/**
+ * Frog Jumping
+ */
+
+function solution(X, Y, D) {
+  return Math.ceil((Y - X) / D);
+}
+
+console.log(solution(1, 5, 3));

codility/frogJump2.js

@@ -0,0 +1,23 @@
+/**
+ * frog jump
+ */
+
+function solution(X, A) {
+  let set = new Set();
+  for (let i = 1; i <= X; i++) {
+    set.add(i);
+  }
+
+  for (let i = 0; i < A.length; i++) {
+    if (set.has(A[i])) {
+      set.delete(A[i]);
+    }
+    if (set.size === 0) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+console.log(solution(2, [2, 2, 2, 2, 2]));

codility/maxCounter.js

@@ -0,0 +1,31 @@
+/**
+ * Max Counter
+ */
+
+function solution(N, A) {
+  let counter = new Array(N).fill(0);
+  let max = 0;
+
+  for (let i = 0; i < A.length; i++) {
+    if (A[i] <= N) {
+      counter[A[i] - 1]++;
+      max = Math.max(max, counter[A[i] - 1]);
+    } else {
+      counter = new Array(N).fill(max);
+    }
+  }
+
+  return counter;
+}
+
+console.log(solution(5, [1, 2, 1, 4, 6, 3]));
+
+/**
+ * 0 0 0 0 0
+ * 1 0 0 0 0
+ * 1 1 0 0 0
+ * 2 1 0 0 0
+ * 2 1 0 1 0
+ * 2 2 2 2 2
+ * 2 2 3 2 2
+ */

codility/minLargestMissing.js

@@ -0,0 +1,28 @@
+/**
+ * Minimum largest missing integer
+ */
+
+function solution(A) {
+  let currMax = 0;
+  let currMin = Number.MAX_VALUE;
+  for (let i = 0; i < A.length; i++) {
+    currMax = Math.max(currMax, A[i]);
+    currMin = Math.min(currMin, A[i]);
+  }
+
+  if (currMax <= 0) return 1;
+
+  let max = currMax;
+  while (currMax >= currMin) {
+    currMax--;
+    if (!A.includes(currMax)) {
+      return currMax;
+    } else {
+      continue;
+    }
+  }
+
+  return currMin > 1 ? 1 : max + 1;
+}
+
+console.log(solution([90, 91, 92, 93]));

codility/missingInteger.js

@@ -0,0 +1,17 @@
+/**
+ * Missing integer
+ */
+
+function solution(A) {
+  let set = new Set();
+  for (let i = 0; i < A.length; i++) {
+    set.add(A[i]);
+  }
+  for (let i = 1; i <= A.length + 1; i++) {
+    if (!set.has(i)) {
+      return i;
+    }
+  }
+}
+
+console.log(solution([2, 3, 1, 5]));

codility/oddElement.js

@@ -0,0 +1,20 @@
+/**
+ * Odd element of array
+ */
+
+function solution(A) {
+  if (A.length === 1) return A[0];
+  let frequency = {};
+
+  for (let i = 0; i < A.length; i++) {
+    frequency[A[i]] = frequency[A[i]] + 1 || 1;
+  }
+
+  for (el in frequency) {
+    if (frequency[el] % 2 !== 0) {
+      return +el;
+    }
+  }
+}
+
+console.log(solution([9, 3, 9, 3, 9, 7, 9]));