^X

Merge branch 'cycle-detection-in-linkedlist' of https://github.com/pomkarnath98/Javascript into cycle-detection-in-linkedlist
Will add modified Cycle Detection problem

Author: pomkarnath98

back-tracking/KnightTour.js renamed to Backtracking/KnightTour.js

@@ -1,8 +1,10 @@
 
-## back-tracking
-  * [KnightTour](https://github.com/TheAlgorithms/Javascript/blob/master/back-tracking/KnightTour.js)
-  * [NQueen](https://github.com/TheAlgorithms/Javascript/blob/master/back-tracking/NQueen.js)
-  * [Sudoku](https://github.com/TheAlgorithms/Javascript/blob/master/back-tracking/Sudoku.js)
+## [babel](https://github.com/TheAlgorithms/Javascript/blob/master//babel.config.js)
+
+## Backtracking
+  * [KnightTour](https://github.com/TheAlgorithms/Javascript/blob/master/Backtracking/KnightTour.js)
+  * [NQueen](https://github.com/TheAlgorithms/Javascript/blob/master/Backtracking/NQueen.js)
+  * [Sudoku](https://github.com/TheAlgorithms/Javascript/blob/master/Backtracking/Sudoku.js)
 
 ## Cache
   * [LFUCache](https://github.com/TheAlgorithms/Javascript/blob/master/Cache/LFUCache.js)
@@ -45,12 +47,17 @@
     * [Trie](https://github.com/TheAlgorithms/Javascript/blob/master/Data-Structures/Tree/Trie.js)
 
 ## Dynamic-Programming
+  * [ClimbingStairs](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/ClimbingStairs.js)
   * [CoinChange](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/CoinChange.js)
+  * [EditDistance](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/EditDistance.js)
   * [KadaneAlgo](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/KadaneAlgo.js)
   * [LevenshteinDistance](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/LevenshteinDistance.js)
+  * [LongestCommonSubsequence](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/LongestCommonSubsequence.js)
+  * [LongestIncreasingSubsequence](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/LongestIncreasingSubsequence.js)
   * [MaxNonAdjacentSum](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/MaxNonAdjacentSum.js)
   * [NumberOfSubsetEqualToGivenSum](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js)
   * [SieveOfEratosthenes](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/SieveOfEratosthenes.js)
+  * [ZeroOneKnapsack](https://github.com/TheAlgorithms/Javascript/blob/master/Dynamic-Programming/ZeroOneKnapsack.js)
 
 ## Graphs
   * [ConnectedComponents](https://github.com/TheAlgorithms/Javascript/blob/master/Graphs/ConnectedComponents.js)
@@ -84,12 +91,13 @@
   * [Palindrome](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/Palindrome.js)
   * [PascalTriangle](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/PascalTriangle.js)
   * [PiApproximationMonteCarlo](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/PiApproximationMonteCarlo.js)
+  * [Polynomial](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/Polynomial.js)
   * [PrimeCheck](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/PrimeCheck.js)
   * [ReversePolishNotation](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/ReversePolishNotation.js)
   * [SieveOfEratosthenes](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/SieveOfEratosthenes.js)
 
-## Project Euler
-  * [Problem1](https://github.com/TheAlgorithms/Javascript/blob/master/Project%20Euler/Problem1.js)
+## Project-Euler
+  * [Problem1](https://github.com/TheAlgorithms/Javascript/blob/master/Project-Euler/Problem1.js)
 
 ## Recursive
   * [EucledianGCD](https://github.com/TheAlgorithms/Javascript/blob/master/Recursive/EucledianGCD.js)
@@ -98,6 +106,7 @@
 ## Search
   * [BinarySearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/BinarySearch.js)
   * [ExponentialSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/ExponentialSearch.js)
+  * [FibonacciSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/FibonacciSearch.js)
   * [InterpolationSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/InterpolationSearch.js)
   * [JumpSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/JumpSearch.js)
   * [LinearSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/LinearSearch.js)
@@ -127,13 +136,19 @@
 
 ## String
   * [CheckAnagram](https://github.com/TheAlgorithms/Javascript/blob/master/String/CheckAnagram.js)
+  * [CheckAnagram](https://github.com/TheAlgorithms/Javascript/blob/master/String/CheckAnagram.test.js)
   * [CheckPalindrome](https://github.com/TheAlgorithms/Javascript/blob/master/String/CheckPalindrome.js)
+  * [CheckPalindrome](https://github.com/TheAlgorithms/Javascript/blob/master/String/CheckPalindrome.test.js)
+  * [CheckRearrangePalindrome](https://github.com/TheAlgorithms/Javascript/blob/master/String/CheckRearrangePalindrome.js)
   * [PatternMatching](https://github.com/TheAlgorithms/Javascript/blob/master/String/PatternMatching.js)
+  * [PatternMatching](https://github.com/TheAlgorithms/Javascript/blob/master/String/PatternMatching.test.js)
   * [ReverseString](https://github.com/TheAlgorithms/Javascript/blob/master/String/ReverseString.js)
+  * [ReverseString](https://github.com/TheAlgorithms/Javascript/blob/master/String/ReverseString.test.js)
   * [ReverseWords](https://github.com/TheAlgorithms/Javascript/blob/master/String/ReverseWords.js)
+  * [ReverseWords](https://github.com/TheAlgorithms/Javascript/blob/master/String/ReverseWords.test.js)
 
-## TimingFunctions
-  * [IntervalTimer](https://github.com/TheAlgorithms/Javascript/blob/master/TimingFunctions/IntervalTimer.js)
+## Timing-Functions
+  * [IntervalTimer](https://github.com/TheAlgorithms/Javascript/blob/master/Timing-Functions/IntervalTimer.js)
 
 ## Trees
   * [DepthFirstSearch](https://github.com/TheAlgorithms/Javascript/blob/master/Trees/DepthFirstSearch.js)

back-tracking/NQueen.js renamed to Backtracking/NQueen.js

@@ -0,0 +1,26 @@
+/*
+ * You are climbing a stair case. It takes n steps to reach to the top.
+ * Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+*/
+
+const climbStairs = (n) => {
+  let prev = 0
+  let cur = 1
+  let temp
+
+  for (let i = 0; i < n; i++) {
+    temp = prev
+    prev = cur
+    cur += temp
+  }
+  return cur
+}
+
+const main = () => {
+  const number = 5
+
+  console.log('Number of ways to climb ' + number + ' stairs in ' + climbStairs(5))
+}
+
+// testing
+main()

back-tracking/Sudoku.js renamed to Backtracking/Sudoku.js

@@ -0,0 +1,61 @@
+/*
+Wikipedia -> https://en.wikipedia.org/wiki/Edit_distance
+
+Q. -> Given two strings `word1` and `word2`. You can perform these operations on any of the string to make both strings similar.
+    - Insert
+    - Remove
+    - Replace
+Find the minimum operation cost required to make both same. Each operation cost is 1.
+
+Algorithm details ->
+time complexity - O(n*m)
+space complexity - O(n*m)
+*/
+
+const minimumEditDistance = (word1, word2) => {
+  const n = word1.length
+  const m = word2.length
+  const dp = new Array(m + 1).fill(0).map(item => [])
+
+  /*
+    fill dp matrix with default values -
+        - first row is filled considering no elements in word2.
+        - first column filled considering no elements in word1.
+    */
+
+  for (let i = 0; i < n + 1; i++) {
+    dp[0][i] = i
+  }
+
+  for (let i = 0; i < m + 1; i++) {
+    dp[i][0] = i
+  }
+
+  /*
+        indexing is 1 based for dp matrix as we defined some known values at first row and first column/
+    */
+
+  for (let i = 1; i < m + 1; i++) {
+    for (let j = 1; j < n + 1; j++) {
+      const letter1 = word1[j - 1]
+      const letter2 = word2[i - 1]
+
+      if (letter1 === letter2) {
+        dp[i][j] = dp[i - 1][j - 1]
+      } else {
+        dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1]) + 1
+      }
+    }
+  }
+
+  return dp[m][n]
+}
+
+const main = () => {
+  console.log(minimumEditDistance('horse', 'ros'))
+  console.log(minimumEditDistance('cat', 'cut'))
+  console.log(minimumEditDistance('', 'abc'))
+  console.log(minimumEditDistance('google', 'glgool'))
+}
+
+main()

DIRECTORY.md

@@ -1,3 +1,4 @@
+'use strict'
 /*
     author: PatOnTheBack
     license: GPL-3.0 or later
@@ -11,12 +12,12 @@
         https://en.wikipedia.org/wiki/Mean
 */
 
-function mean (nums) {
-  'use strict'
+const mean = (nums) => {
+  // This is a function returns average/mean of array
   var sum = 0
   var avg
 
-  // This loop sums all values in the 'nums' array.
+  // This loop sums all values in the 'nums' array using forEach loop
   nums.forEach(function (current) {
     sum += current
   })

Dynamic-Programming/ClimbingStairs.js

@@ -0,0 +1,82 @@
+
+/**
+ * Polynomials are algebraic expressions consisting of two or more algebraic terms.
+ * Terms of a polynomial are:
+ * 1. Coefficients e.g. 5, 4 in 5x^0, 4x^3 respectively
+ * 2. Variables e.g. y in 3y^2
+ * 3. Exponents e.g. 5 in y^5
+ *
+ * Class Polynomial constructs the polynomial using Array as an argument.
+ * The members of array are coefficients and their indexes as exponents.
+ */
+class Polynomial {
+  constructor (array) {
+    this.coefficientArray = array // array of coefficients
+    this.polynomial = '' // in terms of x e.g. (2x) + (1)
+    this.construct()
+  }
+
+  /**
+   * Function to construct the polynomial in terms of x using the coefficientArray
+   */
+  construct () {
+    this.polynomial = this.coefficientArray.map((coefficient, exponent) => {
+      if (coefficient === 0) {
+        return '0'
+      }
+      if (exponent === 0) {
+        return `(${coefficient})`
+      } else if (exponent === 1) {
+        return `(${coefficient}x)`
+      } else {
+        return `(${coefficient}x^${exponent})`
+      }
+    })
+      .filter((x) => {
+        if (x !== '0') {
+          return x
+        }
+      })
+      .reverse()
+      .join(' + ')
+  }
+
+  /**
+   * Function to display polynomial in terms of x
+   * @returns {String} of polynomial representation in terms of x
+   */
+  display () {
+    return this.polynomial
+  }
+
+  /**
+   * Function to calculate the value of the polynomial by substituting variable x
+   * @param {Number} value
+   */
+  evaluate (value) {
+    return this.coefficientArray.reduce((result, coefficient, exponent) => {
+      return result + coefficient * (Math.pow(value, exponent))
+    }, 0)
+  }
+}
+
+/**
+ * Function to perform tests
+ */
+const tests = () => {
+  const polynomialOne = new Polynomial([1, 2, 3, 4])
+  console.log('Test 1: [1,2,3,4]')
+  console.log('Display Polynomial ', polynomialOne.display())
+  // (4x^3) + (3x^2) + (2x) + (1)
+  console.log('Evaluate Polynomial value=2 ', polynomialOne.evaluate(2))
+  // 49
+
+  const polynomialTwo = new Polynomial([5, 0, 0, -4, 3])
+  console.log('Test 2: [5,0,0,-4,3]')
+  console.log('Display Polynomial ', polynomialTwo.display())
+  // (3x^4) + (-4x^3) + (5)
+  console.log('Evaluate Polynomial value=1 ', polynomialTwo.evaluate(1))
+  // 4
+}
+
+tests()

Dynamic-Programming/EditDistance.js

@@ -0,0 +1,77 @@
+/****************************************************************************
+ * Fibonacci Search JavaScript Implementation
+ * Author   Alhassan Atama Isiaka
+ * Version v1.0.0
+ * Copyright 2020
+ * https://github.com/komputarist
+ *
+ * This implementation is based on Generalizing the Fibonacci search we
+ * define the Fibonacci search of degree K. Like the Fibonacci search,
+ * which it reduces to for K = 2, the Fibonacci search of degree K
+ * involves only addition and subtraction.
+ *  Capocelli R.M. (1991) A Generalization of the Fibonacci Search. In:
+ * Bergum G.E., Philippou A.N., Horadam A.F. (eds) Applications of Fibonacci
+ * Numbers. Springer, Dordrecht. https://doi.org/10.1007/978-94-011-3586-3_9
+ *
+ * This snippet is free. Feel free to improve on it
+ *
+ * We define a function fibonacciSearch() that takes an array of numbers,
+ * the item (number) to be searched for and the length of the items in the array
+ ****************************************************************************/
+
+const fibonacciSearch = (arr, x, n) => {
+  let fib2 = 0 // (K-2)'th Fibonacci Number
+  let fib1 = 1 // (K-1)'th Fibonacci Number.
+  let fibK = fib2 + fib1 // Kth Fibonacci
+
+  /* We want to store the smallest fibonacci number smaller such that
+    number is greater than or equal to n, we use fibK for this */
+  while (fibK < n) {
+    fib2 = fib1
+    fib1 = fibK
+    fibK = fib2 + fib1
+  }
+  //  This marks the eliminated range from front
+  let offset = -1
+
+  /* while there are elements to be checked. We compare arr[fib2] with x.
+    When fibM becomes 1, fib2 becomes 0 */
+
+  while (fibK > 1) {
+    // Check if fibK is a valid location
+    const i = Math.min(offset + fib2, n - 1)
+
+    /*  If x is greater than the value at
+      index fib2, Partition the subarray array
+      from offset to i */
+    if (arr[i] < x) {
+      fibK = fib1
+      fib1 = fib2
+      fib2 = fibK - fib1
+      offset = i
+      /* If x is greater than the value at
+            index fib2, cut the subarray array
+            from offset to i */
+    } else if (arr[i] > x) {
+      fibK = fib2
+      fib1 = fib1 - fib2
+      fib2 = fibK - fib1
+    } else {
+    //  return index for found element
+      return i
+    }
+  }
+
+  //    comparing the last element with x */
+  if (fib1 && arr[offset + 1] === x) {
+    return offset + 1
+  }
+  //    element not found. return -1
+  return -1
+}
+// Example
+const myArray = [10, 22, 35, 40, 45, 50, 80, 82, 85, 90, 100]
+const n = myArray.length
+const x = 90
+const fibFinder = fibonacciSearch(myArray, x, n)
+console.log('Element found at index:', fibFinder)

Maths/AverageMean.js

@@ -8,7 +8,7 @@ const checkAnagram = (str1, str2) => {
 
   // If both strings have not same lengths then they can not be anagram.
   if (str1.length !== str2.length) {
-    return 'Not Anagram'
+    return 'Not anagrams'
   }
 
   // Use hashmap to keep count of characters in str1
@@ -44,7 +44,4 @@ const checkAnagram = (str1, str2) => {
   return 'Anagrams'
 }
 
-console.log(checkAnagram('abcd', 'bcad')) // should print anagram
-console.log(checkAnagram('abcd', 'abef')) // should print not anagram
-console.log(checkAnagram(10, 'abcd'))// should print Not String(s).
-console.log(checkAnagram('abs', 'abds'))// should print not anagram
+export { checkAnagram }

Maths/Polynomial.js

@@ -0,0 +1,31 @@
+import { checkAnagram } from './CheckAnagram'
+
+describe('checkAnagram', () => {
+  it.each`
+    inputOne              | inputTwo
+    ${123456}             | ${'abcd'}
+    ${[1, 2, 3, 4, 5, 6]} | ${'abcd'}
+    ${{ test: 'test' }}   | ${'abcd'}
+    ${'abcd'}             | ${123456}
+    ${'abcd'}             | ${[1, 2, 3, 4, 5, 6]}
+    ${'abcd'}             | ${{ test: 'test' }}
+  `(
+    'expects to return "Not string(s)" given values $inputOne and $inputTwo',
+    ({ inputOne, inputTwo }) => {
+      const SUT = checkAnagram(inputOne, inputTwo)
+      expect(SUT).toBe('Not string(s)')
+    }
+  )
+  it('expects to return "Not anagram" if the arguments have different lengths', () => {
+    const SUT = checkAnagram('abs', 'abds')
+    expect(SUT).toBe('Not Anagram')
+  })
+  it('expects to return "Not anagram" if the arguments are not anagrams', () => {
+    const SUT = checkAnagram('abcs', 'abds')
+    expect(SUT).toBe('Not anagrams')
+  })
+  it('expects to return "Anagram" if the arguments are anagram', () => {
+    const SUT = checkAnagram('abcd', 'bcad')
+    expect(SUT).toBe('Anagrams')
+  })
+})