initial commit

Author: As'ad Saleh Umar

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.DS_store

anagram.ts

@@ -0,0 +1,27 @@
+function anagramChecker(inputA: string, inputB: string): boolean {
+  const sortedA = inputA
+    .toLowerCase()
+    .split("")
+    .filter((e) => e != " ")
+    .sort()
+    .join("");
+  const sortedB = inputB
+    .toLowerCase()
+    .split("")
+    .filter((e) => e != " ")
+    .sort()
+    .join("");
+  return sortedA === sortedB;
+}
+
+// What is anagram ?
+// Anagram is when 2 words/phrases consist of exactly simmilar characters.
+// So we can say: "monkeys write" is an anagram for "New York Times".
+
+// Test case:
+console.log(anagramChecker("New York Times", "monkeys write") === true);
+console.log(anagramChecker("restful", "fluster") === true);
+console.log(anagramChecker("Dormitory", "dirty room") === true);
+console.log(
+  anagramChecker("some random words", "totally not it's anagrams ") === false
+);

coding-test/index.html

@@ -0,0 +1,14 @@
+// A function for reversing word order in a paragraph, but only
+// taking words which length are greater than 5.
+function doStuff(text) {
+  if (typeof text !== "string") {
+    console.error("This function expect a string");
+    return "";
+  }
+  return text
+    .toLocaleLowerCase()
+    .split(" ")
+    .reverse()
+    .filter((text) => text.length > 5)
+    .join(", ");
+}

coding-test/iterative.js

@@ -0,0 +1,52 @@
+type MyObject = { [key: string]: any };
+
+function deepEqual(obj1: MyObject, obj2: MyObject) {
+  if (obj1 === null && obj2 === null) {
+  }
+  if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+    return false;
+  }
+  for (const key in obj1) {
+    if (Array.isArray(obj1[key])) {
+      deepEqual(obj1[key], obj2[key]);
+    } else if (typeof obj1[key] === "object") {
+      deepEqual(obj1[key], obj2[key]);
+    } else if (obj1[key] !== obj2[key]) {
+      console.log(
+        `Not equal!\nThe diff is in key "${key}" inside the object "${JSON.stringify(
+          obj1,
+          null,
+          2
+        )}"`
+      );
+      return false;
+    }
+  }
+  return true;
+}
+
+const one = {
+  name: "asad",
+  age: 23,
+  pets: ["cat", "mouse", "bird"],
+  address: {
+    street: "siaga raya 42B",
+    country: "indonesia",
+  },
+  foo: null,
+};
+
+const two = {
+  name: "asad",
+  age: 23,
+  pets: ["cat", "mouse", "bird"],
+  address: {
+    street: "siaga raya 42B",
+    country: "indonesia",
+  },
+  foo: "bar",
+};
+
+// TEST
+console.log(deepEqual(one, two));
+// console.log(deepEqual(["cat", "mouse", "bird"], ["cat", "mouse", "bird"]));

deep_equal.ts

@@ -0,0 +1,50 @@
+// What is a fibonacci?
+// f(0) = 0
+// f(1) = 1
+// f(n) = f(n-1) + f(n-2)
+
+// Solution one. Simple.
+let i = 0;
+
+function fibonacci(index: number): number {
+  if (index === 0) {
+    return 0;
+  }
+  if (index === 1) {
+    return 1;
+  }
+  i++;
+  // console.log(index);
+  return fibonacci(index - 1) + fibonacci(index - 2);
+}
+
+// console.log(fibonacci(9));
+// console.log({ i });
+
+// Solution two. Memoized.
+type MapNumberNumber = { [a: number]: number };
+let memo: MapNumberNumber = {};
+let j = 0;
+function optimizedFib(index: number): number {
+  if (index === 0) {
+    memo[0] = 0;
+    return 0;
+  }
+  if (index === 1) {
+    memo[1] = 1;
+    return 1;
+  }
+
+  // console.log(index);
+  if (memo[index] != null) {
+    return memo[index];
+  } else {
+    j++;
+    const result = optimizedFib(index - 1) + optimizedFib(index - 2);
+    memo[index] = result;
+    return result;
+  }
+}
+
+console.log(optimizedFib(9));
+console.log({ j, memo });

fibonacci.ts

@@ -0,0 +1,29 @@
+function findMissingConsecutiveInteger(array: Array<number>): number {
+  let isMissing = false;
+  let i = 1;
+  let result = 0;
+  while (!isMissing) {
+    if (!isIncluded(array, i)) {
+      isMissing = true;
+      result = i;
+      break;
+    }
+    i++;
+  }
+  return result;
+}
+
+function isIncluded<T>(array: Array<T>, target: T): boolean {
+  let result = false;
+  for (let i = 0; i < array.length; i++) {
+    if (array[i] === target) {
+      result = true;
+      break;
+    }
+  }
+  return result;
+}
+
+console.log(findMissingConsecutiveInteger([4, 3, 2, 1, 8, 9, 10]));
+console.log(findMissingConsecutiveInteger([5, 4, 3, 6, 2, 1, 8, 9, 10]));
+console.log(findMissingConsecutiveInteger([-3, -2, -1]));

find-missing-integer.ts

@@ -0,0 +1,18 @@
+function fizbaz(n: number = 50) {
+  Array.from({ length: n }, (v, i) => i + 1)
+    .map((e) => {
+      if (e % 3 === 0 && e % 5 === 0) {
+        return "FizBaz";
+      }
+      if (e % 3 === 0) {
+        return "Fiz";
+      }
+      if (e % 5 === 0) {
+        return "Baz";
+      }
+      return e;
+    })
+    .forEach((e) => console.log(e));
+}
+
+fizbaz();

fizbaz.ts

@@ -0,0 +1,83 @@
+// Javascript program to count islands in boolean 2D matrix
+
+// No of rows and columns
+let ROW = 5,
+  COL = 5;
+
+// A function to check if a given cell (row, col) can
+// be included in DFS
+function isSafe(M, row, col, visited) {
+  // row number is in range, column number is in range
+  // and value is 1 and not yet visited
+  return (
+    row >= 0 &&
+    row < ROW &&
+    col >= 0 &&
+    col < COL &&
+    M[row][col] == 1 &&
+    !visited[row][col]
+  );
+}
+
+// A utility function to do DFS for a 2D boolean matrix.
+// It only considers the 8 neighbors as adjacent vertices
+function DFS(M, row, col, visited) {
+  // These arrays are used to get row and column numbers
+  // of 8 neighbors of a given cell
+  let rowNbr = [-1, -1, -1, 0, 0, 1, 1, 1];
+  let colNbr = [-1, 0, 1, -1, 1, -1, 0, 1];
+
+  // Mark this cell as visited
+  visited[row][col] = true;
+
+  // Recur for all connected neighbours
+  for (let k = 0; k < 8; ++k) {
+    if (isSafe(M, row + rowNbr[k], col + colNbr[k], visited)) {
+      DFS(M, row + rowNbr[k], col + colNbr[k], visited);
+    }
+  }
+}
+
+// The main function that returns count of islands in a given
+// boolean 2D matrix
+function countIslands(M) {
+  // Make a bool array to mark visited cells.
+  // Initially all cells are unvisited
+  let visited = new Array(ROW);
+  for (let i = 0; i < ROW; i++) {
+    visited[i] = new Array(COL);
+  }
+  for (let i = 0; i < ROW; i++) {
+    for (let j = 0; j < COL; j++) {
+      visited[i][j] = false;
+    }
+  }
+  // Initialize count as 0 and traverse through the all cells
+  // of given matrix
+  let count = 0;
+  for (let i = 0; i < ROW; ++i) {
+    for (let j = 0; j < COL; ++j) {
+      if (M[i][j] == 1 && !visited[i][j]) {
+        // value 1 is not
+        // visited yet, then new island found, Visit all
+        // cells in this island and increment island count
+        DFS(M, i, j, visited);
+        count++;
+      }
+    }
+  }
+  return count;
+}
+
+// Driver method
+let M = [
+  [1, 1, 0, 0, 0],
+  [0, 1, 0, 0, 1],
+  [1, 0, 0, 1, 1],
+  [0, 0, 0, 0, 0],
+  [1, 0, 1, 0, 1],
+];
+
+console.log(countIslands(M));
+
+// This code is contributed by avanitrachhadiya2155

lake-cheat.js

@@ -0,0 +1,101 @@
+// Ada matriks 2 dimensi n*n yang elemennya terdiri dari . dan +
+// Titik, itu kita anggap sebagai danau. + kita anggap sebagai daratan.
+// sample input:
+var lakes = [
+    [".", ".", ".", ".", "."],
+    ["+", "+", "+", "+", "+"],
+    [".", ".", ".", ".", "."],
+    [".", ".", ".", ".", "."],
+    ["+", "+", "+", "+", "+"],
+];
+var adjacentElementDict = [
+    [-1, -1],
+    [-1, 0],
+    [-1, 1],
+    [0, -1],
+    // [0, 0],
+    [0, 1],
+    [1, -1],
+    [1, 0],
+    [1, 1],
+];
+function solve() {
+    var richLake = lakes.map(function (arrayEl) {
+        return arrayEl.map(function (el) { return ({ val: el, label: "" }); });
+    });
+    function getElement(x, y) {
+        var res = null;
+        if (x >= 0 || y >= 0) {
+            res = richLake[x][y];
+        }
+        console.log({ getElement: res });
+        return res;
+    }
+    function getAdjacentElements(x, y) {
+        var res = adjacentElementDict.map(function (_a) {
+            var adjX = _a[0], adjY = _a[1];
+            return getElement(x + adjX, y + adjY);
+        });
+        console.log({ getAdjacentElements: res });
+        return res;
+    }
+    function isAdjacentElementAlreadyALake(x, y) {
+        var adjacentElements = getAdjacentElements(x, y);
+        var isAlreadyLake = false;
+        var element = null;
+        adjacentElements.forEach(function (el) {
+            if ((el === null || el === void 0 ? void 0 : el.val) === ".") {
+                isAlreadyLake = true;
+                element = el;
+            }
+        });
+        return {
+            isAlreadyLake: isAlreadyLake,
+            element: element
+        };
+    }
+    var lakeCount = 0;
+    richLake.forEach(function (arrLake, i) {
+        arrLake.forEach(function (el, j) {
+            var currentEl = getElement(i, j);
+            // If it's a lake
+            // If sebelahnya udah lake => kasih label yang sama dengan sebelahnya,
+            // else sebelahnya belum lake => buat label baru.
+            if ((currentEl === null || currentEl === void 0 ? void 0 : currentEl.val) === ".") {
+                var element = isAdjacentElementAlreadyALake(i, j).element;
+                if (element) {
+                    currentEl.label = element.label;
+                }
+                else {
+                    // Buat label baru
+                    currentEl.label = "lake-".concat(lakeCount);
+                    lakeCount += 1;
+                }
+            }
+            // If it's not a lake
+            // do nothing.
+        });
+    });
+    console.log({ richLake: richLake });
+    // Setelah gue punya rich lake beserta labelnya.
+    // grouping berdasarkan label:
+    var obj = richLake
+        .map(function (_a) {
+        var x = _a[0];
+        return x;
+    })
+        .reduce(function (acc, cur) {
+        var label = cur.label;
+        if (acc[label]) {
+            acc[label] = acc[label].push(cur);
+        }
+        else {
+            acc[label] = [cur];
+        }
+        return acc;
+    }, {});
+    console.log({ obj: obj });
+    var result = Object.keys(obj).length;
+    console.log({ result: result });
+    return result;
+}