Merge branch 'TheAlgorithms:master' into master

Author: developerr-ayush

Conversions/LengthConversion.js

@@ -0,0 +1,38 @@
+/**
+ * Converts a length from one unit to another.
+ *
+ * @param {number} length - The length to convert.
+ * @param {string} fromUnit - The unit to convert from (e.g., "km", "m", "cm").
+ * @param {string} toUnit - The unit to convert to (e.g., "km", "m", "cm").
+ * @returns {number} The converted length.
+ * @throws {Error} If the units are invalid or not found in the conversion dictionary.
+ */
+
+const lengthConversion = (length, fromUnit, toUnit) => {
+  // Define a dictionary to map units to meters
+  const meters = {
+    mm: 0.001,
+    cm: 0.01,
+    m: 1,
+    km: 1000,
+    inch: 0.0254,
+    ft: 0.3048,
+    yd: 0.9144,
+    mi: 1609.34
+  }
+
+  // Check if the units are in the dictionary, otherwise, throw an error
+  if (!(fromUnit in meters) || !(toUnit in meters)) {
+    throw new Error('Invalid units')
+  }
+
+  // Perform the conversion
+  const metersFrom = length * meters[fromUnit]
+  const convertedLength = metersFrom / meters[toUnit]
+
+  return convertedLength
+}
+
+export {
+  lengthConversion
+}

Conversions/test/LengthConversion.test.js

@@ -0,0 +1,53 @@
+import { lengthConversion } from '../LengthConversion.js'
+
+describe('LengthConversion', () => {
+  it.each`
+    length | fromUnit | toUnit   | expected
+    ${10}  | ${'km'}  | ${'m'}   | ${10000}
+    ${100} | ${'m'}   | ${'km'}  | ${0.1}
+    ${5}   | ${'cm'}  | ${'mm'}  | ${50}
+    ${12}  | ${'ft'}  | ${'inch'}| ${144.00000000000003}
+  `(
+    'converts $length $fromUnit to $toUnit',
+    ({ length, fromUnit, toUnit, expected }) => {
+      try {
+        const result = lengthConversion(length, fromUnit, toUnit)
+        expect(result).toBe(expected)
+      } catch (error) {
+        expect(error).toBeUndefined()
+      }
+    }
+  )
+
+  it.each`
+    length | fromUnit | toUnit   | expected
+    ${10}  | ${'m'}   | ${'km'}  | ${0.01}
+    ${1000}| ${'mm'}  | ${'cm'}  | ${100}
+    ${1}   | ${'inch'}| ${'ft'}  | ${0.08333333333}
+  `(
+    'converts $length $fromUnit to $toUnit (vice versa)',
+    ({ length, fromUnit, toUnit, expected }) => {
+      try {
+        const result = lengthConversion(length, fromUnit, toUnit)
+        expect(result).toBeCloseTo(expected, 10) // Close comparison due to floating-point precision
+      } catch (error) {
+        expect(error).toBeUndefined()
+      }
+    }
+  )
+
+  it.each`
+    length | fromUnit | toUnit     | expectedError
+    ${10}  | ${'km'}  | ${'invalid'} | ${'Invalid units'}
+    ${5}   | ${'invalid'} | ${'m'}    | ${'Invalid units'}
+  `(
+    'returns error message for invalid units: $fromUnit to $toUnit',
+    ({ length, fromUnit, toUnit, expectedError }) => {
+      try {
+        lengthConversion(length, fromUnit, toUnit)
+      } catch (error) {
+        expect(error.message).toBe(expectedError)
+      }
+    }
+  )
+})

DIRECTORY.md

@@ -9,10 +9,12 @@
   * [SumOfSubset](Backtracking/SumOfSubset.js)
 * **Bit-Manipulation**
   * [BinaryCountSetBits](Bit-Manipulation/BinaryCountSetBits.js)
+  * [IsPowerofFour](Bit-Manipulation/IsPowerofFour.js)
   * [IsPowerOfTwo](Bit-Manipulation/IsPowerOfTwo.js)
   * [LogTwo](Bit-Manipulation/LogTwo.js)
   * [NextPowerOfTwo](Bit-Manipulation/NextPowerOfTwo.js)
   * [SetBit](Bit-Manipulation/SetBit.js)
+  * [UniqueElementInAnArray](Bit-Manipulation/UniqueElementInAnArray.js)
 * **Cache**
   * [LFUCache](Cache/LFUCache.js)
   * [LRUCache](Cache/LRUCache.js)
@@ -270,6 +272,7 @@
   * [Problem017](Project-Euler/Problem017.js)
   * [Problem018](Project-Euler/Problem018.js)
   * [Problem020](Project-Euler/Problem020.js)
+  * [Problem021](Project-Euler/Problem021.js)
   * [Problem023](Project-Euler/Problem023.js)
   * [Problem025](Project-Euler/Problem025.js)
   * [Problem028](Project-Euler/Problem028.js)

Maths/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 }

Maths/test/ParityOutlier.test.js

@@ -9,11 +9,6 @@ describe('Testing parityOutlier function', () => {
     expect(parityOutlier([177, 5, 76, 1919])).toBe(76)
   })
 
-  it('should, if the given array has only one integer element, return the integer itself', () => {
-    expect(parityOutlier([83])).toBe(83)
-    expect(parityOutlier([54])).toBe(54)
-  })
-
   it('should, if the given array has only an odd and an even number, return the odd outlier', () => {
     expect(parityOutlier([1, 2])).toBe(1)
     expect(parityOutlier([4, 3])).toBe(3)

Maths/test/QuadraticRoots.test.js

@@ -0,0 +1,13 @@
+import { quadraticRoots } from '../QuadraticRoots.js'
+
+describe('quadratic roots', () => {
+  it('returns an array with two real roots when the discriminant is positive', () => {
+    expect(quadraticRoots(1, -3, 2)).toEqual([2, 1])
+  })
+  it('returns an array with one real root when the discriminant is zero', () => {
+    expect(quadraticRoots(1, -2, 1)).toEqual([1])
+  })
+  it('returns an empty array indicating no real roots when the discriminant is negative', () => {
+    expect(quadraticRoots(1, 2, 5)).toEqual([])
+  })
+})

Project-Euler/test/Problem044.test.js

@@ -12,8 +12,8 @@ describe('checking nth prime number', () => {
     expect(problem44(1)).toBe(5482660)
   })
   // Project Euler Second Value for Condition Check
-  // FIXME skip this test for now because it runs very long and clogs up the CI & pre-commit hook
-  test('if the number is greater or equal to 2167', () => {
+  // Skipping this by default as it makes CI runs take way too long
+  test.skip('if the number is greater or equal to 2167', () => {
     expect(problem44(2167)).toBe(8476206790)
   })
 })