30-days-of-javascript 2.3.4

package/30-days-of-javaScript.txt

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

package/AffineCipher.js

@@ -0,0 +1,105 @@
+/**
+ * @description - The affine cipher is a type of monoalphabetic substitution cipher, where each letter in an alphabet is mapped to its numeric equivalent, encrypted using a simple mathematical function, and converted back to a letter
+ * @see - [wiki](https://en.wikipedia.org/wiki/Affine_cipher)
+ */
+
+import { CoPrimeCheck } from '../Maths/CoPrimeCheck'
+// Default key for Affine Cipher
+const key = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+/**
+ * Fix result for negative value in modulas equation
+ * @param {Number} n - Constant number
+ * @param {Number} m - Modulos value
+ * @return {Number} Return n mod m
+ */
+function mod(n, m) {
+  return ((n % m) + m) % m
+}
+
+/**
+ * Modular multiplicative inverse
+ * @param {Number} a - A coefficient
+ * @param {Number} m - Modulos value
+ * @return {Number} Return modular multiplicative inverse of coefficient a and modulos m
+ */
+function inverseMod(a, m) {
+  for (let x = 1; x < m; x++) {
+    if (mod(a * x, m) === 1) return x
+  }
+}
+
+/**
+ * Argument validation
+ * @param {String} str - String to be checked
+ * @param {Number} a - A coefficient to be checked
+ * @param {Number} b - B coefficient to be checked
+ * @return {Boolean} Result of the checking
+ */
+function isCorrectFormat(str, a, b) {
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new TypeError('Coefficient a, b should be number')
+  }
+
+  if (typeof str !== 'string') {
+    throw new TypeError('Argument str should be String')
+  }
+
+  if (!CoPrimeCheck(a, 26)) {
+    throw new Error(a + ' is not coprime of 26')
+  }
+
+  return true
+}
+
+/**
+ * Find character index based on ASCII order
+ * @param {String} char - Character index to be found
+ * @return {Boolean} Character index
+ */
+function findCharIndex(char) {
+  return char.toUpperCase().charCodeAt(0) - 'A'.charCodeAt(0)
+}
+
+/**
+ * Encrypt a Affine Cipher
+ * @param {String} str - String to be encrypted
+ * @param {Number} a - A coefficient
+ * @param {Number} b - B coefficient
+ * @return {String} result - Encrypted string
+ */
+
+function encrypt(str, a, b) {
+  let result = ''
+  if (isCorrectFormat(str, a, b)) {
+    for (let x = 0; x < str.length; x++) {
+      const charIndex = findCharIndex(str[x])
+      if (charIndex < 0) result += '-1' + ' '
+      else result += key.charAt(mod(a * charIndex + b, 26)) + ' '
+    }
+  }
+  return result.trim()
+}
+
+/**
+ * Decrypt a Affine Cipher
+ * @param {String} str - String to be decrypted
+ * @param {Number} a - A coefficient
+ * @param {Number} b - B coefficient
+ * @return {String} result - Decrypted string
+ */
+function decrypt(str, a, b) {
+  let result = ''
+  if (isCorrectFormat(str, a, b)) {
+    str = str.split(' ')
+    for (let x = 0; x < str.length; x++) {
+      if (str[x] === '-1') result += ' '
+      else {
+        const charIndex = findCharIndex(str[x])
+        result += key[mod(inverseMod(a, 26) * (charIndex - b), 26)]
+      }
+    }
+    return result
+  }
+}
+export { encrypt, decrypt }

package/AverageMedian.js

@@ -0,0 +1,22 @@
+/*
+ * Median: https://en.wikipedia.org/wiki/Median
+ *
+ * function averageMedian
+ * to find the median value of an array of numbers
+ * the numbers in an array will be sorted in ascending order by the function sortNumbers
+ * if the length of the array is even number, the median value will be the average of the two middle numbers
+ * else if the length of the array is odd number, the median value will be the middle number in the array
+ */
+
+const averageMedian = (sourceArrayOfNumbers) => {
+  const numbers = [...sourceArrayOfNumbers].sort(sortNumbers)
+  const numLength = numbers.length
+
+  return numLength % 2 === 0
+    ? (numbers[numLength / 2 - 1] + numbers[numLength / 2]) / 2
+    : numbers[Math.floor(numLength / 2)]
+}
+
+const sortNumbers = (num1, num2) => num1 - num2
+
+export { averageMedian }

package/Base64ToArrayBuffer.js

@@ -0,0 +1,48 @@
+// About base64: https://en.wikipedia.org/wiki/Base64
+
+/**
+ * Converts a base64 string to an array of bytes
+ * @param {string} b64 A base64 string
+ * @returns {ArrayBuffer} An ArrayBuffer representing the bytes encoded by the base64 string
+ */
+function base64ToBuffer(b64) {
+  // The base64 encoding uses the following set of characters to encode any binary data as text
+  const base64Table =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+  // Find the index of char '=' first occurrence
+  const paddingIdx = b64.indexOf('=')
+  // Remove padding chars from base64 string, if there are any
+  const b64NoPadding = paddingIdx !== -1 ? b64.slice(0, paddingIdx) : b64
+  // Calculate the length of the result buffer
+  const bufferLength = Math.floor((b64NoPadding.length * 6) / 8)
+  // Create the result buffer
+  const result = new ArrayBuffer(bufferLength)
+  // Create an instance of Uint8Array, to write to the `result` buffer
+  const byteView = new Uint8Array(result)
+
+  // Loop through all chars in the base64 string, in increments of 4 chars, and in increments of 3 bytes
+  for (let i = 0, j = 0; i < b64NoPadding.length; i += 4, j += 3) {
+    // Get the index of the next 4 base64 chars
+    const b64Char1 = base64Table.indexOf(b64NoPadding[i])
+    const b64Char2 = base64Table.indexOf(b64NoPadding[i + 1])
+    let b64Char3 = base64Table.indexOf(b64NoPadding[i + 2])
+    let b64Char4 = base64Table.indexOf(b64NoPadding[i + 3])
+
+    // If base64 chars 3 and 4 don't exit, then set them to 0
+    if (b64Char3 === -1) b64Char3 = 0
+    if (b64Char4 === -1) b64Char4 = 0
+
+    // Calculate the next 3 bytes
+    const byte1 = (b64Char1 << 2) + ((b64Char2 & 48) >> 4)
+    const byte2 = ((b64Char2 & 15) << 4) + ((b64Char3 & 60) >> 2)
+    const byte3 = ((b64Char3 & 3) << 6) + b64Char4
+
+    byteView[j] = byte1
+    byteView[j + 1] = byte2
+    byteView[j + 2] = byte3
+  }
+
+  return result
+}
+
+export { base64ToBuffer }

package/BinaryExponentiationRecursive.js

@@ -0,0 +1,20 @@
+/*
+  Modified from:
+    https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py
+
+  Explanation:
+    https://en.wikipedia.org/wiki/Exponentiation_by_squaring
+*/
+
+export const binaryExponentiation = (a, n) => {
+  // input: a: int, n: int
+  // returns: a^n: int
+  if (n === 0) {
+    return 1
+  } else if (n % 2 === 1) {
+    return binaryExponentiation(a, n - 1) * a
+  } else {
+    const b = binaryExponentiation(a, n / 2)
+    return b * b
+  }
+}

package/BinarySearch.js

@@ -0,0 +1,33 @@
+/**
+ * @function BinarySearch
+ * @description Search the integer inside the sorted integers array using Binary Search Algorithm.
+ * @param {Integer[]} arr - sorted array of integers
+ * @param {Integer} low - The input integer
+ * @param {Integer} high - The input integer
+ * @param {Integer} searchValue - The input integer
+ * @return {Integer} - return index of searchValue if found else return -1.
+ * @see [BinarySearch](https://en.wikipedia.org/wiki/Binary_search_algorithm)
+ */
+
+const binarySearch = (arr, searchValue, low = 0, high = arr.length - 1) => {
+  // base case
+  if (high < low || arr.length === 0) return -1
+
+  const mid = low + Math.floor((high - low) / 2)
+
+  // If the element is present at the middle
+  if (arr[mid] === searchValue) {
+    return mid
+  }
+
+  // If element is smaller than mid, then
+  // it can only be present in left subarray
+  if (arr[mid] > searchValue) {
+    return binarySearch(arr, searchValue, low, mid - 1)
+  }
+
+  // Else the element can only be present in right subarray
+  return binarySearch(arr, searchValue, mid + 1, high)
+}
+
+export { binarySearch }

package/BreadthFirstSearch.js

@@ -0,0 +1,37 @@
+import Queue from '../Data-Structures/Queue/Queue'
+
+/**
+ * Breadth-first search is an algorithm for traversing a graph.
+ *
+ * It discovers all nodes reachable from the starting position by exploring all of the neighbor nodes at the present
+ * depth prior to moving on to the nodes at the next depth level.
+ *
+ * (description adapted from https://en.wikipedia.org/wiki/Breadth-first_search)
+ * @see https://www.koderdojo.com/blog/breadth-first-search-and-shortest-path-in-csharp-and-net-core
+ */
+export function breadthFirstSearch(graph, startingNode) {
+  // visited keeps track of all nodes visited
+  const visited = new Set()
+
+  // queue contains the nodes to be explored in the future
+  const queue = new Queue()
+  queue.enqueue(startingNode)
+
+  while (!queue.isEmpty()) {
+    // start with the queue's first node
+    const node = queue.dequeue()
+
+    if (!visited.has(node)) {
+      // mark the node as visited
+      visited.add(node)
+      const neighbors = graph[node]
+
+      // put all its neighbors into the queue
+      for (let i = 0; i < neighbors.length; i++) {
+        queue.enqueue(neighbors[i])
+      }
+    }
+  }
+
+  return visited
+}

package/Circle.js

@@ -0,0 +1,19 @@
+/**
+ * This class represents a circle and can calculate it's perimeter and area
+ * https://en.wikipedia.org/wiki/Circle
+ * @constructor
+ * @param {number} radius - The radius of the circle.
+ */
+export default class Circle {
+  constructor(radius) {
+    this.radius = radius
+  }
+
+  perimeter = () => {
+    return this.radius * 2 * Math.PI
+  }
+
+  area = () => {
+    return Math.pow(this.radius, 2) * Math.PI
+  }
+}

package/Cone.js

@@ -0,0 +1,30 @@
+/**
+ * This class represents a circular cone and can calculate its volume and surface area
+ * https://en.wikipedia.org/wiki/Cone
+ * @constructor
+ * @param {number} baseRadius - The radius of the base of the cone.
+ * @param {number} height - The height of the cone
+ */
+export default class Cone {
+  constructor(baseRadius, height) {
+    this.baseRadius = baseRadius
+    this.height = height
+  }
+
+  baseArea = () => {
+    return Math.pow(this.baseRadius, 2) * Math.PI
+  }
+
+  volume = () => {
+    return (this.baseArea() * this.height * 1) / 3
+  }
+
+  surfaceArea = () => {
+    return (
+      this.baseArea() +
+      Math.PI *
+        this.baseRadius *
+        Math.sqrt(Math.pow(this.baseRadius, 2) + Math.pow(this.height, 2))
+    )
+  }
+}

package/CreatePermutations.js

@@ -0,0 +1,38 @@
+/*
+a permutation of a set is, loosely speaking, an arrangement of its members into a sequence or linear order, or if the set is already ordered, a rearrangement of its elements.
+The word "permutation" also refers to the act or process of changing the linear order of an ordered set
+More at : https://en.wikipedia.org/wiki/Permutation
+*/
+
+const createPermutations = (str) => {
+  // convert string to array
+  const arr = str.split('')
+
+  // get array length
+  const strLen = arr.length
+  // this will hold all the permutations
+  const perms = []
+  let rest
+  let picked
+  let restPerms
+  let next
+
+  // if strLen is zero, return the same string
+  if (strLen === 0) {
+    return [str]
+  }
+  // loop to the length to get all permutations
+  for (let i = 0; i < strLen; i++) {
+    rest = Object.create(arr)
+    picked = rest.splice(i, 1)
+
+    restPerms = createPermutations(rest.join(''))
+
+    for (let j = 0, jLen = restPerms.length; j < jLen; j++) {
+      next = picked.concat(restPerms[j])
+      perms.push(next.join(''))
+    }
+  }
+  return perms
+}
+export { createPermutations }

package/DecimalToHex.js

@@ -0,0 +1,28 @@
+function intToHex(num) {
+  switch (num) {
+    case 10:
+      return 'A'
+    case 11:
+      return 'B'
+    case 12:
+      return 'C'
+    case 13:
+      return 'D'
+    case 14:
+      return 'E'
+    case 15:
+      return 'F'
+  }
+  return num
+}
+
+function decimalToHex(num) {
+  const hexOut = []
+  while (num > 15) {
+    hexOut.unshift(intToHex(num % 16))
+    num = Math.floor(num / 16)
+  }
+  return intToHex(num) + hexOut.join('')
+}
+
+export { decimalToHex }

package/DecimalToRoman.js

@@ -0,0 +1,52 @@
+/*
+    Decimal To Roman
+
+    This algorithm take decimal number and convert to roman numeral according to standard form (https://en.wikipedia.org/wiki/Roman_numerals#Description)
+
+    Algorithm & Explanation : https://www.rapidtables.com/convert/number/how-number-to-roman-numerals.html
+*/
+
+const values = {
+  M: 1000,
+  CM: 900,
+  D: 500,
+  CD: 400,
+  C: 100,
+  XC: 90,
+  L: 50,
+  XL: 40,
+  X: 10,
+  IX: 9,
+  V: 5,
+  IV: 4,
+  I: 1
+}
+
+const orders = [
+  'M',
+  'CM',
+  'D',
+  'CD',
+  'C',
+  'XC',
+  'L',
+  'XL',
+  'X',
+  'IX',
+  'V',
+  'IV',
+  'I'
+]
+
+function decimalToRoman(num) {
+  let roman = ''
+  for (const symbol of orders) {
+    while (num >= values[symbol]) {
+      roman += symbol
+      num -= values[symbol]
+    }
+  }
+  return roman
+}
+
+export { decimalToRoman }

package/Density.js

@@ -0,0 +1,11 @@
+/*
+The density of a network is a measure of how many edges exist proportional to
+how many edges would exist in a complete network (where all possible edges).
+https://networkx.org/documentation/networkx-1.9/reference/generated/networkx.classes.function.density.html
+*/
+function density(numberOfNodes, numberOfEdges, isDirected = false) {
+  const multi = isDirected ? 1 : 2
+  return (multi * numberOfEdges) / (numberOfNodes * (numberOfNodes - 1))
+}
+
+export { density }

package/DutchNationalFlagSort.js

@@ -0,0 +1,33 @@
+/**
+ * @function dutchNationalFlagSort
+ * @description Dutch National Flag Sort is an algorithm to sort an array containing 0s, 1s, and 2s in linear time.
+    Time complexity of Dutch National Flag Sort Algorithm is O(n).
+    Auxiliary Space required for Dutch National Flag Sort Algorithm is O(1).
+ * @param {Integer[]} nums - Array of integers containing 0s, 1s, and 2s.
+ * @return {Integer[]} - Array of integers sorted in non-decreasing order.
+ * @see [Dutch National Flag Sort](https://en.wikipedia.org/wiki/Dutch_national_flag_problem)
+ */
+export function dutchNationalFlagSort(nums) {
+  let low = 0
+  let mid = 0
+  let high = nums.length - 1
+
+  while (mid <= high) {
+    switch (nums[mid]) {
+      case 0:
+        ;[nums[low], nums[mid]] = [nums[mid], nums[low]]
+        low++
+        mid++
+        break
+      case 1:
+        mid++
+        break
+      case 2:
+        ;[nums[mid], nums[high]] = [nums[high], nums[mid]]
+        high--
+        break
+    }
+  }
+
+  return nums
+}

package/ExponentialFunction.js

@@ -0,0 +1,25 @@
+/**
+ * @function exponentialFunction
+ * @description Calculates the n+1 th order Taylor series approximation of exponential function e^x given n
+ * @param {Integer} power
+ * @param {Integer} order - 1
+ * @returns exponentialFunction(2,20) = 7.3890560989301735
+ * @url https://en.wikipedia.org/wiki/Exponential_function
+ */
+function exponentialFunction(power, n) {
+  let output = 0
+  let fac = 1
+  if (isNaN(power) || isNaN(n) || n < 0) {
+    throw new TypeError('Invalid Input')
+  }
+  if (n === 0) {
+    return 1
+  }
+  for (let i = 0; i < n; i++) {
+    output += power ** i / fac
+    fac *= i + 1
+  }
+  return output
+}
+
+export { exponentialFunction }

package/FibonacciNumberRecursive.js

@@ -0,0 +1,16 @@
+/**
+ * @function Fibonacci
+ * @description Function to return the N-th Fibonacci number.
+ * @param {Integer} n - The input integer
+ * @return {Integer} - Return the N-th Fibonacci number
+ * @see [Fibonacci](https://en.wikipedia.org/wiki/Fibonacci_number)
+ */
+
+const fibonacci = (n) => {
+  if (n < 2) {
+    return n
+  }
+  return fibonacci(n - 2) + fibonacci(n - 1)
+}
+
+export { fibonacci }

package/FisherYatesShuffle.js

@@ -0,0 +1,18 @@
+export const shuffle = (array) => {
+  let maxLength = array.length
+  let temp
+  let idx
+
+  // While there remain elements to shuffle...
+  while (maxLength) {
+    // Pick a remaining element...
+    idx = Math.floor(Math.random() * maxLength--)
+
+    // And swap it with the current element
+    temp = array[maxLength]
+    array[maxLength] = array[idx]
+    array[idx] = temp
+  }
+
+  return array
+}

package/FloydWarshall.js

@@ -0,0 +1,47 @@
+/*
+  Source:
+    https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm
+
+  Complexity:
+    O(|V|^3) where V is the set of vertices
+*/
+
+const FloydWarshall = (dist) => {
+  // Input:- dist: 2D Array where dist[i][j] = edge weight b/w i and j
+  // Output:- dist: 2D Array where dist[i][j] = shortest dist b/w i and j
+  const n = dist.length
+  for (let k = 0; k < n; k++) {
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        if (dist[i][j] > dist[i][k] + dist[k][j]) {
+          // dist from i to j via k is lesser than the current distance
+          dist[i][j] = dist[i][k] + dist[k][j]
+        }
+      }
+    }
+  }
+  return dist
+}
+
+export { FloydWarshall }
+
+// For the following graph (edge weights are shown in brackets)
+//  4       1       dist[1][2] = dist[2][1] = 1
+//   \  (2)/ \      dist[1][3] = dist[3][1] = 2
+//    \   /   \(1)  dist[1][4] = dist[4][1] = Infinity
+//  (1)\ /     \    dist[3][4] = dist[4][3] = 1
+//      3       2   dist[2][4] = dist[4][2] = Infinity
+//                  dist[2][3] = dist[3][2] = Infinity
+// Output should be:
+// [ [0, 1, 2, 3],
+//   [1, 0, 3, 4],
+//   [2, 3, 0, 1],
+//   [3, 4, 1, 0] ]
+
+// FloydWarshall(
+//     [[0, 1, 2, Infinity],
+//       [1, 0, Infinity, Infinity],
+//       [2, Infinity, 0, 1],
+//       [Infinity, Infinity, 1, 0]
+//     ]
+//   )

package/Haversine.js

@@ -0,0 +1,44 @@
+/**
+ * @function HaversineDistance
+ * @description Calculate the distance between two coordinates using the haversine formula
+ * @param {Integer} latitude1 - The input integer
+ * @param {Integer} latitude2 - The input integer
+ * @param {Integer} longitude1 - The input integer
+ * @param {Integer} longitude2 - The input integer
+ * @return {Integer} Haversine Distance.
+ * @see [Haversine_Distance](https://pt.wikipedia.org/wiki/F%C3%B3rmula_de_Haversine)
+ */
+const haversineDistance = (
+  latitude1 = 0,
+  longitude1 = 0,
+  latitude2 = 0,
+  longitude2 = 0
+) => {
+  validateLatOrLong(latitude1)
+  validateLatOrLong(latitude2)
+  validateLatOrLong(longitude1)
+  validateLatOrLong(longitude2)
+  const earthRadius = 6371e3 // 6,371km
+  const pi = Math.PI
+  const cos1 = (latitude1 * pi) / 180.0
+  const cos2 = (latitude2 * pi) / 180.0
+  const deltaLatitude = ((latitude2 - latitude1) * pi) / 180.0
+  const deltaLongitude = ((longitude2 - longitude1) * pi) / 180.0
+
+  const alpha =
+    Math.sin(deltaLatitude / 2) * Math.sin(deltaLatitude / 2) +
+    Math.cos(cos1) *
+      Math.cos(cos2) *
+      Math.sin(deltaLongitude / 2) *
+      Math.sin(deltaLongitude / 2)
+  const constant = 2 * Math.atan2(Math.sqrt(alpha), Math.sqrt(1 - alpha))
+  return earthRadius * constant
+}
+
+const validateLatOrLong = (value) => {
+  if (typeof value !== 'number') {
+    throw new TypeError('The value of latitude or longitude should be a number')
+  }
+}
+
+export { haversineDistance }

package/HexToRGB.js

@@ -0,0 +1,17 @@
+function hexStringToRGB(hexString) {
+  let r = hexString.substring(0, 2)
+  let g = hexString.substring(2, 4)
+  let b = hexString.substring(4, 6)
+
+  r = parseInt(r, 16)
+  g = parseInt(g, 16)
+  b = parseInt(b, 16)
+  const obj = { r, g, b }
+
+  return obj
+}
+
+export { hexStringToRGB }
+
+// > hexStringToRGB('ffffff')
+// { r: 255, g: 255, b: 255 }