update

Author: MaiDeveloper

find-the-symmetric-difference.js

@@ -8,6 +8,7 @@
 
 /**
  * Find the Symmetric Difference
+ * @author Mike Mai
  * @param {number[]} - accept any number of array
  * @return {number[]}
  *

nth-fibonacci.js

@@ -0,0 +1,53 @@
+const assert = require('assert');
+
+/**
+ * Nth Fibonacci
+ * The Fibonacci sequence is defined as follows: the first number of the sequence is 0, the second number is 1, and the nth number is the sum of the (n - 1)th and (n - 2)th numbers. Write a function that takes in an integer n and returns the nth Fibonacci number.
+ */
+
+function getNthFibBasic(n) {
+  if (n === 1) {
+		return 0;
+	} else if (n === 2) {
+		return 1;
+	}
+	return getNthFib(n - 1) + getNthFib(n - 2);
+}
+
+function getNthFibMemorize(n, memorize = {1: 0, 2: 1}) {
+	if (memorize[n] !== undefined) {
+		return memorize[n];
+	}
+	memorize[n] = getNthFib(n - 1, memorize) + getNthFib(n - 2, memorize);
+	return memorize[n];
+}
+
+function getNthFib(n) {
+  if (n <= 1) {
+    return 0;
+  }
+
+  const nums = [0, 1];
+  let counter = 2;
+  let nextNum;
+
+  while (counter < n) {
+    nextNum = nums[0] + nums[1];
+    nums[0] = nums[1];
+    nums[1] = nextNum;
+    counter++;
+  }
+
+  return nums[1];
+}
+
+assert.strictEqual(getNthFib(1), 0);
+assert.strictEqual(getNthFib(2), 1);
+assert.strictEqual(getNthFib(3), 1);
+assert.strictEqual(getNthFib(4), 2);
+assert.strictEqual(getNthFib(14), 233);
+assert.strictEqual(getNthFib(15), 377);
+assert.strictEqual(getNthFib(16), 610);
+assert.strictEqual(getNthFib(17), 987);
+assert.strictEqual(getNthFib(18), 1597);
+

river-sizes.js

@@ -0,0 +1,93 @@
+/**
+ * River Sizes
+ * You are given a two-dimensional array (matrix) of potentially unequal height and width containing only 0s and 1s. Each 0 represents land, and each 1 represents part of a river. A river consists of any number of 1s that are either horizontally or vertically adjacent (but not diagonally adjacent). The number of adjacent 1s forming a river determine its size. Write a function that returns an array of the sizes of all rivers represented in the input matrix. Note that these sizes do not need to be in any particular order.
+ *
+ * Sample input:
+ * [
+ *  [1,0,0,1,0],
+ *  [1,0,1,0,0],
+ *  [0,0,1,0,1],
+ *  [1,0,1,0,1],
+ *  [1,0,1,1,0]
+ * ]
+ *
+ * Sample output:
+ * [2,1,5,2,2]
+ */
+
+
+function riverSizes(matrix) {
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+  const sizes = [];
+
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (matrix[i][j] === 1) {
+        visitRiver(i, j, matrix, sizes, rows, cols);
+      }
+    }
+  }
+
+  return sizes;
+}
+
+function visitRiver(i, j, matrix, sizes, rows, cols) {
+  let count = 0;
+  const stack = [[i, j]];
+
+  while (stack.length) {
+    const node = stack.shift();
+    const i = node[0];
+    const j = node[1];
+
+    if (matrix[i][j] === 1) {
+      matrix[i][j] = 3;
+
+      count++;
+
+      stack.push(...getNearbyRiver(i, j, rows, cols, matrix));
+    }
+  }
+
+  if (count > 0) {
+    sizes.push(count);
+  }
+}
+
+function getNearbyRiver(i, j, rows, cols, matrix) {
+  const available = [];
+
+  // Top
+  if (i > 0 && i < rows && matrix[i - 1][j] === 1) {
+    available.push([i - 1, j]);
+  }
+
+  // Bottom
+  if (i >= 0 && i < rows - 1 && matrix[i + 1][j] === 1) {
+    available.push([i + 1, j]);
+  }
+
+  // Left
+  if (j > 0 && j < cols && matrix[i][j - 1] === 1) {
+    available.push([i, j - 1]);
+  }
+
+  // Right
+  if (j >= 0 && j < cols - 1 && matrix[i][j + 1] === 1) {
+    available.push([i, j + 1]);
+  }
+
+  return available;
+}
+
+
+const input = [
+ [1,0,0,1,0],
+ [1,0,1,0,0],
+ [0,0,1,0,1],
+ [1,0,1,0,1],
+ [1,0,1,1,0]
+];
+
+console.log(riverSizes(input));