30-days-of-javascript 2.3.4

package/MD5.js

@@ -0,0 +1,205 @@
+// Module that replicates the MD5 Cryptographic Hash
+// function in Javascript.
+
+// main variables
+const S = [
+  7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5,
+  9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11,
+  16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15,
+  21
+]
+
+const K = [
+  0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a,
+  0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+  0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340,
+  0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+  0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8,
+  0x676f02d9, 0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+  0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa,
+  0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+  0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92,
+  0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+  0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
+]
+
+/**
+ * Separates an array into equal sized chunks
+ *
+ * @param {Array|string} array - array or string to separate into chunks
+ * @param {number} size - number of elements wanted in each chunk
+ * @return {Array} - array of original array split into chunks
+ *
+ * @example
+ *      chunkify("this is a test", 2)
+ */
+function chunkify(array, size) {
+  const chunks = []
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size))
+  }
+  return chunks
+}
+
+/**
+ * Rotates the bits to the left
+ *
+ * @param {number} bits - 32 bit number
+ * @param {number} turns - number of rotations to make
+ * @return {number} - number after bits rotation
+ *
+ * @example
+ *      rotateLeft(0b1011, 3); // 0b1011000
+ */
+function rotateLeft(bits, turns) {
+  return (bits << turns) | (bits >>> (32 - turns))
+}
+
+/**
+ * Converts Uint8Array to Uint32Array
+ *
+ * @param {Uint8Array} u8Array Uint8Array to convert
+ * @returns {Uint32Array} - Required Uint32Array
+ */
+function u8ToU32(u8Array) {
+  const uint32Array = new Uint32Array(u8Array.length / 4)
+
+  for (let i = 0; i < u8Array.length; i += 4) {
+    uint32Array[i / 4] =
+      (u8Array[i] |
+        (u8Array[i + 1] << 8) |
+        (u8Array[i + 2] << 16) |
+        (u8Array[i + 3] << 24)) >>>
+      0
+  }
+
+  return uint32Array
+}
+
+/**
+ * Converts Uint32Array to Uint8Array
+ *
+ * @param {Uint32Array} u32Array Uint32Array to convert
+ * @returns {Uint8Array} - Required Uint8Array
+ */
+function u32ToU8(u32Array) {
+  const uint8Array = new Uint8Array(u32Array.length * 4)
+
+  for (let i = 0; i < u32Array.length; i++) {
+    uint8Array[i * 4] = u32Array[i] & 0xff
+    uint8Array[i * 4 + 1] = (u32Array[i] >> 8) & 0xff
+    uint8Array[i * 4 + 2] = (u32Array[i] >> 16) & 0xff
+    uint8Array[i * 4 + 3] = (u32Array[i] >> 24) & 0xff
+  }
+
+  return uint8Array
+}
+
+/**
+ * Adds padding to the end of the given array
+ *
+ * @param {Uint8Array} u8Array Array to pad
+ * @param {number} size Resulting size of the array
+ */
+function padEnd(u8Array, size) {
+  const result = new Uint8Array(size)
+  result.set(u8Array)
+  result.fill(0, u8Array.length)
+
+  return result
+}
+
+/**
+ * Pre-processes message to feed the algorithm loop
+ *
+ * @param {Uint8Array} message - message to pre-process
+ * @return {Uint32Array} - processed message
+ */
+function preProcess(message) {
+  // Extend message by adding '0'
+  //
+  // message.length + 1 is for adding '1' bit
+  // 56 - (length % 64) is for padding with '0's
+  // 8 is for appending 64 bit message length
+  let m = padEnd(
+    message,
+    message.length + 1 + (56 - ((message.length + 1) % 64)) + 8
+  )
+
+  // Add '1' bit at the end of the message
+  m[message.length] = 1 << 7
+
+  // convert message to 32 bit uint array
+  m = u8ToU32(m)
+
+  // Append the length of the message to the end
+  // (ml / 0x100000000) | 0 is equivalent to (ml >> 32) & 0xffffffff) in other languages
+  let ml = message.length * 8
+  m[m.length - 2] = ml & 0xffffffff
+  m[m.length - 1] = (ml / 0x100000000) | 0
+
+  return m
+}
+
+/**
+ * Hashes message using MD5 Cryptographic Hash Function
+ *
+ * @see
+ * For more info: https://en.wikipedia.org/wiki/MD5
+ *
+ * @param {Uint8Array} message - message to hash
+ * @return {Uint8Array} - message digest (hash value)
+ */
+function MD5(message) {
+  // Initialize variables:
+  let [a0, b0, c0, d0] = [
+    0x67452301 >>> 0,
+    0xefcdab89 >>> 0,
+    0x98badcfe >>> 0,
+    0x10325476 >>> 0
+  ]
+
+  // pre-process message and split into 512 bit chunks
+  const words = Array.from(preProcess(message))
+  const chunks = chunkify(words, 16)
+
+  chunks.forEach(function (chunk, _) {
+    // initialize variables for this chunk
+    let [A, B, C, D] = [a0, b0, c0, d0]
+
+    for (let i = 0; i < 64; i++) {
+      let [F, g] = [0, 0]
+
+      if (i <= 15) {
+        F = (B & C) | (~B & D)
+        g = i
+      } else if (i <= 31) {
+        F = (D & B) | (~D & C)
+        g = (5 * i + 1) % 16
+      } else if (i <= 47) {
+        F = B ^ C ^ D
+        g = (3 * i + 5) % 16
+      } else {
+        F = C ^ (B | ~D)
+        g = (7 * i) % 16
+      }
+
+      F = (F + A + K[i] + chunk[g]) >>> 0
+      A = D
+      D = C
+      C = B
+      B = ((B + rotateLeft(F, S[i])) & 0xffffffff) >>> 0
+    }
+
+    // add values for this chunk to main hash variables (unsigned)
+    a0 = (a0 + A) >>> 0
+    b0 = (b0 + B) >>> 0
+    c0 = (c0 + C) >>> 0
+    d0 = (d0 + D) >>> 0
+  })
+
+  return u32ToU8([a0, b0, c0, d0])
+}
+
+// export MD5 function
+export { MD5 }

package/Minesweeper.js

@@ -0,0 +1,38 @@
+/*
+ * Author: IcarusTheFly (https://github.com/IcarusTheFly)
+ * Minesweeper explanation can be found in: https://en.wikipedia.org/wiki/Minesweeper_(video_game)
+ * This function will take a rectangular matrix filled with boolean values - the value for a cell
+ * with a mine will be true, otherwise it will be false.
+ * As a result it will return a rectangular matrix where each cell will have an integer that
+ * counts all the mines in the adjacent cells
+ * Two cells should share at least one corner to be considered adjacent
+ */
+
+/**
+ * @function minesweeper
+ * @description It counts the amount of mines surrounding every cell and returns a formatted matrix
+ * @param {boolean[][]} matrix
+ * @returns {number[][]} Matrix of numbers with the amount of mines surrounding each cell
+ */
+
+export const minesweeper = (matrix) => {
+  const arrResult = []
+  for (let x = 0; x < matrix.length; x++) {
+    const arrLine = []
+    for (let y = 0; y < matrix[x].length; y++) {
+      let minesInCell = 0
+      for (let xi = x - 1; xi <= x + 1; xi++) {
+        if (matrix[xi] !== undefined) {
+          for (let yi = y - 1; yi <= y + 1; yi++) {
+            if ((xi !== x || yi !== y) && matrix[xi][yi] === true) {
+              minesInCell++
+            }
+          }
+        }
+      }
+      arrLine.push(minesInCell)
+    }
+    arrResult.push(arrLine)
+  }
+  return arrResult
+}

package/NumberOfIslands.js

@@ -0,0 +1,81 @@
+/* Number of Islands
+https://dev.to/rattanakchea/amazons-interview-question-count-island-21h6
+Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+
+a two dimensional grid map
+each element is going to represent a piece of land
+1 is land,
+0 is water
+output a number which is the number of islands
+
+Example 1:
+  Input:
+  11110
+  11010
+  11000
+  00000
+
+  Output: 1
+
+Example 2:
+  Input:
+  11000
+  11000
+  00100
+  00011
+
+  Output: 3
+
+I: two dimensional array
+O: a single integer; total number of islands
+
+Pseudocode:
+  OUTER FUNCTION
+    set count to 0
+
+    INNER FUNCTION - flood (col, row)
+      if the tile is water
+        return
+      make tile water(flood tile)
+      invoke flood on the neighbor coordinates
+
+    iterate over the matrix (col, row)
+      if the current element is a 1
+        increment count
+        invoke flood (coordinates for col and row)
+
+    Return the count
+*/
+
+const islands = (matrixGrid) => {
+  const matrix = matrixGrid
+  let counter = 0
+
+  const flood = (row, col) => {
+    if (row < 0 || col < 0) return // Off the map above or left
+    if (row >= matrix.length || col >= matrix[row].length) return // Off the map below or right
+
+    const tile = matrix[row][col]
+    if (tile !== '1') return
+
+    matrix[row][col] = '0'
+
+    flood(row + 1, col) // Down
+    flood(row - 1, col) // Up
+    flood(row, col + 1) // Right
+    flood(row, col - 1) // Left
+  }
+
+  for (let row = 0; row < matrix.length; row += 1) {
+    for (let col = 0; col < matrix[row].length; col += 1) {
+      const current = matrix[row][col]
+      if (current === '1') {
+        flood(row, col)
+        counter += 1
+      }
+    }
+  }
+  return counter
+}
+
+export { islands }

package/PatternMatching.js

@@ -0,0 +1,33 @@
+/*
+Pattern matching is case insensitive as
+the inputs are converted to lower case before the
+algorithm is run.
+
+The algorithm will run through the entire text and
+return the starting index if the given pattern is
+available in the text
+*/
+const checkIfPatternExists = (text, pattern) => {
+  if (typeof text !== 'string' || typeof pattern !== 'string') {
+    throw new TypeError('Given input is not a string')
+  }
+  const textLength = text.length // Store the length of the text in a variable
+  const patternLength = pattern.length // Store the length of the pattern in a variable
+
+  // Iterate through the text until the textlength - patternlength index
+  for (let i = 0; i <= textLength - patternLength; i++) {
+    // For each character in the text check if the subsequent character
+    // are matching the given pattern; if not break from the condition
+    for (let j = 0; j < textLength; j++) {
+      if (text[i + j] !== pattern[j]) break
+
+      // For each iteration of j check if the value of
+      // j + 1 is equal to the length of the pattern
+      if (j + 1 === patternLength) {
+        return `Given pattern is found at index ${i}`
+      }
+    }
+  }
+}
+
+export { checkIfPatternExists }

package/Problem012.js

@@ -0,0 +1,64 @@
+/**
+ * Problem 12 - Highly divisible triangular number
+ *
+ * https://projecteuler.net/problem=11
+ *
+ * The sequence of triangle numbers is generated by adding the natural numbers.
+ * So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.
+ *
+ * The first ten terms would be: 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+ * Let us list the factors of the first seven triangle numbers:
+ *
+ * 1: 1
+ * 3: 1,3
+ * 6: 1,2,3,6
+ * 10: 1,2,5,10
+ * 15: 1,3,5,15
+ * 21: 1,3,7,21
+ * 28: 1,2,4,7,14,28
+ *
+ * We can see that 28 is the first triangle number to have over five divisors.
+ *
+ * What is the value of the first triangle number to have over five hundred divisors?
+ */
+
+/**
+ * Gets number of divisors of a given number
+ * @params num The number whose divisors to find
+ */
+const getNumOfDivisors = (num) => {
+  // initialize numberOfDivisors
+  let numberOfDivisors = 0
+
+  // if one divisor less than sqrt(num) exists
+  // then another divisor greater than sqrt(n) exists and its value is num/i
+  const sqrtNum = Math.sqrt(num)
+  for (let i = 0; i <= sqrtNum; i++) {
+    // check if i divides num
+    if (num % i === 0) {
+      if (i === sqrtNum) {
+        // if both divisors are equal, i.e., num is perfect square, then only 1 divisor
+        numberOfDivisors++
+      } else {
+        // 2 divisors, one of them is less than sqrt(n), other greater than sqrt(n)
+        numberOfDivisors += 2
+      }
+    }
+  }
+  return numberOfDivisors
+}
+
+/**
+ * Loops till first triangular number with 500 divisors is found
+ */
+const firstTriangularWith500Divisors = () => {
+  let triangularNum
+  // loop forever until numOfDivisors becomes greater than or equal to 500
+  for (let n = 1; ; n++) {
+    // nth triangular number is (1/2)*n*(n+1) by Arithmetic Progression
+    triangularNum = (1 / 2) * n * (n + 1)
+    if (getNumOfDivisors(triangularNum) >= 500) return triangularNum
+  }
+}
+
+export { firstTriangularWith500Divisors }

package/QuadraticRoots.js

@@ -0,0 +1,37 @@
+/**
+ * @see https://www.cuemath.com/algebra/roots-of-quadratic-equation/
+ * @author Dibya Debayan Dash
+ * Calculates the roots of a quadratic equation of the form ax^2 + bx + c = 0.
+ *
+ * @param {number} a - Coefficient of x^2.
+ * @param {number} b - Coefficient of x.
+ * @param {number} c - Constant term.
+ * @returns {number[]} - An array containing the roots if they are real,
+ *                      or an empty array indicating no real roots.
+ *
+ * @example
+ * // Find the roots of the quadratic equation: 2x^2 - 4x + 2 = 0
+ * const roots = quadraticRoots(2, -4, 2);
+ * // Expected output: [1]
+ */
+const quadraticRoots = (a, b, c) => {
+  // Calculate the discriminant
+  const discriminant = b * b - 4 * a * c
+
+  // Check if roots are real
+  if (discriminant < 0) {
+    return []
+  } else if (discriminant === 0) {
+    // One real root
+    return [-b / (2 * a)]
+  } else {
+    // Two real roots
+    const sqrtDiscriminant = Math.sqrt(discriminant)
+    return [
+      (-b + sqrtDiscriminant) / (2 * a),
+      (-b - sqrtDiscriminant) / (2 * a)
+    ]
+  }
+}
+
+export { quadraticRoots }

package/QuickSelect.js

@@ -0,0 +1,65 @@
+/**
+ * [QuickSelect](https://www.geeksforgeeks.org/quickselect-algorithm/) is an algorithm to find the kth smallest number
+ *
+ * Notes:
+ * -QuickSelect is related to QuickSort, thus has optimal best and average
+ * -case (O(n)) but unlikely poor worst case (O(n^2))
+ * -This implementation uses randomly selected pivots for better performance
+ *
+ * @complexity: O(n) (on average )
+ * @complexity: O(n^2) (worst case)
+ * @flow
+ */
+
+function QuickSelect(items, kth) {
+  // eslint-disable-line no-unused-vars
+  if (kth < 1 || kth > items.length) {
+    throw new RangeError('Index Out of Bound')
+  }
+
+  return RandomizedSelect(items, 0, items.length - 1, kth)
+}
+
+function RandomizedSelect(items, left, right, i) {
+  if (left === right) return items[left]
+
+  const pivotIndex = RandomizedPartition(items, left, right)
+  const k = pivotIndex - left + 1
+
+  if (i === k) return items[pivotIndex]
+  if (i < k) return RandomizedSelect(items, left, pivotIndex - 1, i)
+
+  return RandomizedSelect(items, pivotIndex + 1, right, i - k)
+}
+
+function RandomizedPartition(items, left, right) {
+  const rand = getRandomInt(left, right)
+  Swap(items, rand, right)
+  return Partition(items, left, right)
+}
+
+function Partition(items, left, right) {
+  const x = items[right]
+  let pivotIndex = left - 1
+
+  for (let j = left; j < right; j++) {
+    if (items[j] <= x) {
+      pivotIndex++
+      Swap(items, pivotIndex, j)
+    }
+  }
+
+  Swap(items, pivotIndex + 1, right)
+
+  return pivotIndex + 1
+}
+
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+function Swap(arr, x, y) {
+  ;[arr[x], arr[y]] = [arr[y], arr[x]]
+}
+
+export { QuickSelect }

package/README.md

@@ -0,0 +1 @@
+A 30DaysOfJavaScript challenge is a guide for both beginners and advanced JavaScript developers

package/RadixSort.js

@@ -0,0 +1,43 @@
+/*
+ * Radix sorts an integer array without comparing the integers.
+ * It groups the integers by their digits which share the same
+ * significant position.
+ * For more information see: https://en.wikipedia.org/wiki/Radix_sort
+ */
+export function radixSort(items, RADIX) {
+  // default radix is then because we usually count to base 10
+  if (RADIX === undefined || RADIX < 1) {
+    RADIX = 10
+  }
+
+  let maxLength = false
+  let placement = 1
+
+  while (!maxLength) {
+    maxLength = true
+    const buckets = []
+
+    for (let i = 0; i < RADIX; i++) {
+      buckets.push([])
+    }
+
+    for (let j = 0; j < items.length; j++) {
+      const tmp = items[j] / placement
+      buckets[Math.floor(tmp % RADIX)].push(items[j])
+      if (maxLength && tmp > 0) {
+        maxLength = false
+      }
+    }
+
+    let a = 0
+    for (let b = 0; b < RADIX; b++) {
+      const buck = buckets[b]
+      for (let k = 0; k < buck.length; k++) {
+        items[a] = buck[k]
+        a++
+      }
+    }
+    placement *= RADIX
+  }
+  return items
+}

package/RomanToDecimal.js

@@ -0,0 +1,34 @@
+const values = {
+  I: 1,
+  V: 5,
+  X: 10,
+  L: 50,
+  C: 100,
+  D: 500,
+  M: 1000
+}
+
+export function romanToDecimal(romanNumber) {
+  let prev = ' '
+
+  let sum = 0
+
+  let newPrev = 0
+  for (let i = romanNumber.length - 1; i >= 0; i--) {
+    const c = romanNumber.charAt(i)
+
+    if (prev !== ' ') {
+      newPrev = values[prev] > newPrev ? values[prev] : newPrev
+    }
+
+    const currentNum = values[c]
+    if (currentNum >= newPrev) {
+      sum += currentNum
+    } else {
+      sum -= currentNum
+    }
+
+    prev = c
+  }
+  return sum
+}

package/SquareRootLogarithmic.js

@@ -0,0 +1,41 @@
+/**
+ * @function squareRootLogarithmic
+ * @description
+ * Return the square root of 'num' rounded down
+ * to the nearest integer.
+ * More info: https://leetcode.com/problems/sqrtx/
+ * @param {Number} num Number whose square of root is to be found
+ * @returns {Number} Square root
+ * @see [BinarySearch](https://en.wikipedia.org/wiki/Binary_search_algorithm)
+ * @example
+ * const num1 = 4
+ * logarithmicSquareRoot(num1) // ====> 2
+ * @example
+ * const num2 = 8
+ * logarithmicSquareRoot(num1) // ====> 2
+ *
+ */
+const squareRootLogarithmic = (num) => {
+  if (typeof num !== 'number') {
+    throw new Error('Input data must be numbers')
+  }
+  let answer = 0
+  let sqrt = 0
+  let edge = num
+
+  while (sqrt <= edge) {
+    const mid = Math.trunc((sqrt + edge) / 2)
+    if (mid * mid === num) {
+      return mid
+    } else if (mid * mid < num) {
+      sqrt = mid + 1
+      answer = mid
+    } else {
+      edge = mid - 1
+    }
+  }
+
+  return answer
+}
+
+export { squareRootLogarithmic }

package/SwapSort.js

@@ -0,0 +1,31 @@
+/**
+ * @function SwapSort
+ * @description Swap Sort is an algorithm to find the number of swaps required to sort an array.
+    Time complexity of Swap Sort Algorithm is O(nlogn).
+    Auxiliary Space required for Swap Sort Algorithm is O(n).
+ * @param {Integer[]} items - Array of integers
+ * @return {Integer} - Number of swaps required to sort the array.
+ * @see [SwapSort](https://www.geeksforgeeks.org/minimum-number-swaps-required-sort-array/)
+ */
+
+export function minSwapsToSort(items) {
+  const sortedArray = items.slice()
+  sortedArray.sort()
+  const indexMap = {}
+  for (let i = 0; i < items.length; i++) {
+    indexMap[items[i]] = i
+  }
+  let swaps = 0
+  for (let i = 0; i < items.length; i++) {
+    if (items[i] !== sortedArray[i]) {
+      const temp = items[i]
+      items[i] = items[indexMap[sortedArray[i]]]
+      items[indexMap[sortedArray[i]]] = temp
+
+      indexMap[temp] = indexMap[sortedArray[i]]
+      indexMap[sortedArray[i]] = i
+      swaps++
+    }
+  }
+  return swaps
+}

package/dist/index.d.mts

@@ -0,0 +1,9 @@
+type SayHelloProps = {
+    firstName: String;
+    lastName: String;
+    age: Number;
+};
+
+declare function sayHello({ firstName, lastName, age }: SayHelloProps): void;
+
+export { type SayHelloProps, sayHello };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+type SayHelloProps = {
+    firstName: String;
+    lastName: String;
+    age: Number;
+};
+
+declare function sayHello({ firstName, lastName, age }: SayHelloProps): void;
+
+export { type SayHelloProps, sayHello };