Test cases project euler

Bit-Manipulation/BinaryCountSetBits.js

@@ -16,7 +16,7 @@ function BinaryCountSetBits(a) {
 
   let count = 0
   while (a) {
-    a &= (a - 1)
+    a &= a - 1
     count++
   }
 

DIRECTORY.md

@@ -166,6 +166,7 @@
   * [Area](Maths/Area.js)
   * [ArithmeticGeometricMean](Maths/ArithmeticGeometricMean.js)
   * [ArmstrongNumber](Maths/ArmstrongNumber.js)
+  * [AutomorphicNumber](Maths/AutomorphicNumber.js)
   * [AverageMean](Maths/AverageMean.js)
   * [AverageMedian](Maths/AverageMedian.js)
   * [BinaryConvert](Maths/BinaryConvert.js)

Maths/AutomorphicNumber.js

@@ -35,6 +35,6 @@ export const isAutomorphic = (n) => {
     n = Math.floor(n / 10)
     n_sq = Math.floor(n_sq / 10)
   }
-  
+
   return true
 }

Maths/test/AutomorphicNumber.test.js

@@ -9,19 +9,19 @@ describe('AutomorphicNumber', () => {
   })
 
   test.each([
-    { n: -3 , expected: false },
-    { n: -25 , expected: false },
+    { n: -3, expected: false },
+    { n: -25, expected: false }
   ])('should return false when n is negetive', ({ n, expected }) => {
     expect(isAutomorphic(n)).toBe(false)
   })
 
   test.each([
-    { n: 7 , expected: false },
-    { n: 83 , expected: false },
-    { n: 0 , expected: true },
-    { n: 1 , expected: true },
-    { n: 376 , expected: true },
-    { n: 90625 , expected: true },
+    { n: 7, expected: false },
+    { n: 83, expected: false },
+    { n: 0, expected: true },
+    { n: 1, expected: true },
+    { n: 376, expected: true },
+    { n: 90625, expected: true }
   ])('should return $expected when n is $n', ({ n, expected }) => {
     expect(isAutomorphic(n)).toBe(expected)
   })

Project-Euler/Problem006.js

@@ -1,8 +1,8 @@
 // https://projecteuler.net/problem=6
 
 export const squareDifference = (num = 100) => {
-  let sumOfSquares = (num)*(num+1)*(2*num+1)/6
-  let sums = (num*(num+1))/2
-  
+  let sumOfSquares = (num * (num + 1) * (2 * num + 1)) / 6
+  let sums = (num * (num + 1)) / 2
+
   return sums ** 2 - sumOfSquares // difference of square of the total sum and sum of squares
 }

Project-Euler/Problem015.js

@@ -7,8 +7,8 @@ How many such routes are there through a 20×20 grid?
 // A lattice path is composed of horizontal and vertical lines that pass through lattice points.
 
 export const latticePath = (gridSize) => {
-  let paths
-  for (let i = 1, paths = 1; i <= gridSize; i++) {
+  let paths = 1
+  for (let i = 1; i <= gridSize; i++) {
     paths = (paths * (gridSize + i)) / i
   }
   // The total number of paths can be found using the binomial coefficient (b+a)/a.

Project-Euler/test/Problem004.test.js

@@ -0,0 +1,11 @@
+import { largestPalindromic } from '../Problem004.js'
+
+describe('Largest Palindromic Number', () => {
+  test('if digit is 2', () => {
+    expect(largestPalindromic(2)).toBe(9009)
+  })
+  // Project Euler Condition Check
+  test('if digit is 3', () => {
+    expect(largestPalindromic(3)).toBe(906609)
+  })
+})

Project-Euler/test/Problem014.test.js

@@ -0,0 +1,26 @@
+import { findLongestCollatzSequence } from '../Problem014.js'
+
+describe('Longest Collatz Sequence', () => {
+  test('sequence under 1', () => {
+    expect(findLongestCollatzSequence(1)).toBe(1)
+  })
+  test('sequence under 10', () => {
+    expect(findLongestCollatzSequence(10)).toBe(9)
+  })
+  test('sequence under 100', () => {
+    expect(findLongestCollatzSequence(100)).toBe(97)
+  })
+  test('sequence under 1000', () => {
+    expect(findLongestCollatzSequence(1000)).toBe(871)
+  })
+  test('sequence under 10000', () => {
+    expect(findLongestCollatzSequence(10000)).toBe(6171)
+  })
+  test('sequence under 100000', () => {
+    expect(findLongestCollatzSequence(100000)).toBe(77031)
+  })
+  // Project Euler Condition Check
+  test('sequence under 1000000', () => {
+    expect(findLongestCollatzSequence()).toBe(837799)
+  })
+})

Project-Euler/test/Problem015.test.js

@@ -0,0 +1,32 @@
+import { latticePath } from '../Problem015.js'
+
+describe('Lattice Paths', () => {
+  test('if grid size is 2', () => {
+    expect(latticePath(2)).toBe(6)
+  })
+  test('if grid size is 5', () => {
+    expect(latticePath(5)).toBe(252)
+  })
+  test('if grid size is 10', () => {
+    expect(latticePath(10)).toBe(184756)
+  })
+  test('if grid size is 15', () => {
+    expect(latticePath(15)).toBe(155117520)
+  })
+  test('if grid size is 16', () => {
+    expect(latticePath(16)).toBe(601080390)
+  })
+  test('if grid size is 17', () => {
+    expect(latticePath(17)).toBe(2333606220)
+  })
+  test('if grid size is 18', () => {
+    expect(latticePath(18)).toBe(9075135300)
+  })
+  test('if grid size is 19', () => {
+    expect(latticePath(19)).toBe(35345263800)
+  })
+  // Project Euler Condition Check
+  test('if grid size is 20', () => {
+    expect(latticePath(20)).toBe(137846528820)
+  })
+})

Recursive/test/BinaryEquivalent.test.js

@@ -1,29 +1,29 @@
-import { binaryEquivalent } from "../BinaryEquivalent";
+import { binaryEquivalent } from '../BinaryEquivalent'
 
 const tests = [
-    {
-        test: 2,
-        expectedValue: "10"
-    },
-    {       
-        test: 0,
-        expectedValue: "0"
-    },
-    {
-        test: 543,
-        expectedValue: "1000011111"
-    },
-    {
-        test: 4697621023,
-        expectedValue: "100011000000000000000001000011111"
-    }
+  {
+    test: 2,
+    expectedValue: '10'
+  },
+  {
+    test: 0,
+    expectedValue: '0'
+  },
+  {
+    test: 543,
+    expectedValue: '1000011111'
+  },
+  {
+    test: 4697621023,
+    expectedValue: '100011000000000000000001000011111'
+  }
 ]
 
-describe("Binary Equivalent", () => {
-    test.each(tests)(
-        "of $test should be $expectedValue",
-        ({test, expectedValue}) => {
-            expect(binaryEquivalent(test)).toBe(expectedValue);
-        }
-    )
+describe('Binary Equivalent', () => {
+  test.each(tests)(
+    'of $test should be $expectedValue',
+    ({ test, expectedValue }) => {
+      expect(binaryEquivalent(test)).toBe(expectedValue)
+    }
+  )
 })

Search/InterpolationSearch.js

@@ -36,4 +36,4 @@ export function interpolationSearch(arr, key) {
   }
 
   return -1
-}
+}