Merge branch 'TheAlgorithms:master' into master

Author: pomkarnath98

DIRECTORY.md

@@ -268,6 +268,7 @@
 * **Sorts**
   * [AlphaNumericalSort](Sorts/AlphaNumericalSort.js)
   * [BeadSort](Sorts/BeadSort.js)
+  * [BinaryInsertionSort](Sorts/BinaryInsertionSort.js)
   * [BogoSort](Sorts/BogoSort.js)
   * [BubbleSort](Sorts/BubbleSort.js)
   * [BucketSort](Sorts/BucketSort.js)

Dynamic-Programming/FastFibonacciNumber.js

@@ -0,0 +1,25 @@
+/**
+ * @function fastFibonacci
+ * @description fastFibonacci is same as fibonacci algorithm by calculating the sum of previous two fibonacci numbers but in O(log(n)).
+ * @param {Integer} N - The input integer
+ * @return {Integer} fibonacci of N.
+ * @see [Fast_Fibonacci_Numbers](https://www.geeksforgeeks.org/fast-doubling-method-to-find-the-nth-fibonacci-number/)
+ */
+
+// recursive function that returns (F(n), F(n-1))
+const fib = (N) => {
+  if (N === 0) return [0, 1]
+  const [a, b] = fib(Math.trunc(N / 2))
+  const c = a * (b * 2 - a)
+  const d = a * a + b * b
+  return N % 2 ? [d, c + d] : [c, d]
+}
+
+const fastFibonacci = (N) => {
+  if (!Number.isInteger(N)) {
+    throw new TypeError('Input should be integer')
+  }
+  return fib(N)[0]
+}
+
+export { fastFibonacci }

Dynamic-Programming/tests/FastFibonacciNumber.test.js

@@ -0,0 +1,23 @@
+import { fastFibonacci } from '../FastFibonacciNumber'
+
+describe('Testing FibonacciNumber', () => {
+  const errorCases = ['0', '12', true]
+
+  test.each(errorCases)('throws an error if %p is invalid', (input) => {
+    expect(() => {
+      fastFibonacci(input)
+    }).toThrow()
+  })
+
+  const testCases = [
+    [0, 0],
+    [1, 1],
+    [10, 55],
+    [25, 75025],
+    [40, 102334155]
+  ]
+
+  test.each(testCases)('if input is %i it returns %i', (input, expected) => {
+    expect(fastFibonacci(input)).toBe(expected)
+  })
+})

Project-Euler/Problem002.js

@@ -5,8 +5,10 @@ const PHI = (1 + SQ5) / 2 // definition of PHI
 // theoretically it should take O(1) constant amount of time as long
 // arithmetic calculations are considered to be in constant amount of time
 export const EvenFibonacci = (limit) => {
+  if (limit < 1) throw new Error('Fibonacci sequence limit can\'t be less than 1')
+
   const highestIndex = Math.floor(Math.log(limit * SQ5) / Math.log(PHI))
   const n = Math.floor(highestIndex / 3)
-  return ((PHI ** (3 * n + 3) - 1) / (PHI ** 3 - 1) -
-    ((1 - PHI) ** (3 * n + 3) - 1) / ((1 - PHI) ** 3 - 1)) / SQ5
+  return Math.floor(((PHI ** (3 * n + 3) - 1) / (PHI ** 3 - 1) -
+    ((1 - PHI) ** (3 * n + 3) - 1) / ((1 - PHI) ** 3 - 1)) / SQ5)
 }

Project-Euler/Problem028.js

@@ -0,0 +1,53 @@
+/**
+ * Problem 28 - Number spiral diagonals
+ *
+ * @see {@link https://projecteuler.net/problem=28}
+ *
+ * Starting with the number 1 and moving to the right in a clockwise direction a 5 by 5 spiral is formed as follows:
+ *
+ * 21 22 23 24 25
+ * 20 07 08 09 10
+ * 19 06 01 02 11
+ * 18 05 04 03 12
+ * 17 16 15 14 13
+ *
+ * It can be verified that the sum of the numbers on the diagonals is 101.
+ * What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed in the same way?
+ *
+ * @author ddaniel27
+ */
+
+function problem28 (dim) {
+  if (dim % 2 === 0) {
+    throw new Error('Dimension must be odd')
+  }
+  if (dim < 1) {
+    throw new Error('Dimension must be positive')
+  }
+
+  let result = 1
+  for (let i = 3; i <= dim; i += 2) {
+    /**
+      * Adding more dimensions to the matrix, we will find at the top-right corner the follow sequence:
+      * 01, 09, 25, 49, 81, 121, 169, ...
+      * So this can be expressed as:
+      * i^2, where i is all odd numbers
+      *
+      * Also, we can know which numbers are in each corner dimension
+      * Just develop the sequence counter clockwise from top-right corner like this:
+      * First corner: i^2
+      * Second corner: i^2 - (i - 1) | The "i - 1" is the distance between corners in each dimension
+      * Third corner: i^2 - 2 * (i - 1)
+      * Fourth corner: i^2 - 3 * (i - 1)
+      *
+      * Doing the sum of each corner and simplifing, we found that the result for each dimension is:
+      * sumDim = 4 * i^2 + 6 * (1 - i)
+      *
+      * In this case I skip the 1x1 dim matrix because is trivial, that's why I start in a 3x3 matrix
+      */
+    result += (4 * i * i) + 6 * (1 - i) // Calculate sum of each dimension corner
+  }
+  return result
+}
+
+export { problem28 }

Project-Euler/test/Problem002.test.js

@@ -0,0 +1,14 @@
+import { EvenFibonacci } from '../Problem002'
+
+describe('Even Fibonacci numbers', () => {
+  it('should throw error when limit is less than 1', () => {
+    expect(() => EvenFibonacci(-1)).toThrowError('Fibonacci sequence limit can\'t be less than 1')
+  })
+  test('when limit is greater than 0', () => {
+    expect(EvenFibonacci(40)).toBe(44)
+  })
+  // Project Euler Condition Check
+  test('when limit is 4 million', () => {
+    expect(EvenFibonacci(4e6)).toBe(4613732)
+  })
+})

Project-Euler/test/Problem028.test.js

@@ -0,0 +1,17 @@
+import { problem28 } from '../Problem028.js'
+
+describe('checking number spiral diagonals', () => {
+  it('should be invalid input if number is negative', () => {
+    expect(() => problem28(-3)).toThrowError('Dimension must be positive')
+  })
+  it('should be invalid input if number is not odd', () => {
+    expect(() => problem28(4)).toThrowError('Dimension must be odd')
+  })
+  test('if the number is equal to 5 result should be 101', () => {
+    expect(problem28(5)).toBe(101)
+  })
+  // Project Euler Condition Check
+  test('if the number is equal to 1001 result should be 669171001', () => {
+    expect(problem28(1001)).toBe(669171001)
+  })
+})