Merge branch 'TheAlgorithms:master' into remove-Eratosthenes-intarray

Author: SpiderMath

.github/workflows/UploadCoverageReport.yml

@@ -8,6 +8,9 @@ name: UploadCoverageReport
       - master
   pull_request:
 
+env:
+  REPORT_PATH: "coverage/coverage-final.json"
+
 jobs:
   UploadCoverageReport:
     runs-on: ubuntu-latest
@@ -25,9 +28,18 @@ jobs:
       - name: Generate coverage report
         run: npm test -- --coverage
 
-      - name: Upload coverage to codecov
-        uses: codecov/codecov-action@v3
+      - name: Upload coverage to codecov (tokenless)
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository
+        uses: codecov/codecov-action@v4
+        with:
+          files: "${{ env.REPORT_PATH }}"
+          fail_ci_if_error: true
+
+      - name: Upload coverage to codecov (with token)
+        if: "! github.event.pull_request.head.repo.fork "
+        uses: codecov/codecov-action@v4
         with:
-          files: "coverage/coverage-final.json"
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: "${{ env.REPORT_PATH }}"
           fail_ci_if_error: true
 ...

Backtracking/tests/RatInAMaze.test.js

@@ -6,7 +6,6 @@ describe('RatInAMaze', () => {
 
     for (const value of values) {
       // we deliberately want to check whether this constructor call fails or not
-      // eslint-disable-next-line no-new
       expect(() => {
         new RatInAMaze(value)
       }).toThrow()
@@ -15,7 +14,6 @@ describe('RatInAMaze', () => {
 
   it('should fail for an empty array', () => {
     // we deliberately want to check whether this constructor call fails or not
-    // eslint-disable-next-line no-new
     expect(() => {
       new RatInAMaze([])
     }).toThrow()
@@ -28,7 +26,6 @@ describe('RatInAMaze', () => {
     ]
 
     // we deliberately want to check whether this constructor call fails or not
-    // eslint-disable-next-line no-new
     expect(() => {
       new RatInAMaze(array)
     }).toThrow()
@@ -39,7 +36,6 @@ describe('RatInAMaze', () => {
 
     for (const value of values) {
       // we deliberately want to check whether this constructor call fails or not
-      // eslint-disable-next-line no-new
       expect(() => {
         new RatInAMaze(value)
       }).toThrow()

Backtracking/tests/Sudoku.test.js

@@ -27,7 +27,6 @@ const solved = [
 describe('Sudoku', () => {
   it('should create a valid board successfully', () => {
     // we deliberately want to check whether this constructor call fails or not
-    // eslint-disable-next-line no-new
     expect(() => {
       new Sudoku(data)
     }).not.toThrow()

Compression/RLE.js

@@ -0,0 +1,38 @@
+/*
+ * RLE (Run Length Encoding) is a simple form of data compression.
+ * The basic idea is to represent repeated successive characters as a single count and character.
+ * For example, the string "AAAABBBCCDAA" would be encoded as "4A3B2C1D2A".
+ *
+ * @author - [ddaniel27](https://github.com/ddaniel27)
+ */
+
+function Compress(str) {
+  let compressed = ''
+  let count = 1
+
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] !== str[i + 1]) {
+      compressed += count + str[i]
+      count = 1
+      continue
+    }
+
+    count++
+  }
+
+  return compressed
+}
+
+function Decompress(str) {
+  let decompressed = ''
+  let match = [...str.matchAll(/(\d+)(\D)/g)] // match all groups of digits followed by a non-digit character
+
+  match.forEach((item) => {
+    let [count, char] = [item[1], item[2]]
+    decompressed += char.repeat(count)
+  })
+
+  return decompressed
+}
+
+export { Compress, Decompress }

Compression/test/RLE.test.js

@@ -0,0 +1,13 @@
+import { Compress, Decompress } from '../RLE'
+
+describe('Test RLE Compressor/Decompressor', () => {
+  it('Test - 1, Pass long repetitive strings', () => {
+    expect(Compress('AAAAAAAAAAAAAA')).toBe('14A')
+    expect(Compress('AAABBQQQQQFG')).toBe('3A2B5Q1F1G')
+  })
+
+  it('Test - 2, Pass compressed strings', () => {
+    expect(Decompress('14A')).toBe('AAAAAAAAAAAAAA')
+    expect(Decompress('3A2B5Q1F1G')).toBe('AAABBQQQQQFG')
+  })
+})

Conversions/HexToDecimal.js

@@ -1,4 +1,7 @@
 function hexToInt(hexNum) {
+  if (!/^[0-9A-F]+$/.test(hexNum)) {
+    throw new Error('Invalid hex string.')
+  }
   const numArr = hexNum.split('') // converts number to array
   return numArr.map((item, index) => {
     switch (item) {
@@ -29,4 +32,4 @@ function hexToDecimal(hexNum) {
   }, 0)
 }
 
-export { hexToInt, hexToDecimal }
+export { hexToDecimal }

Conversions/test/HexToDecimal.test.js

@@ -0,0 +1,24 @@
+import { hexToDecimal } from '../HexToDecimal'
+
+describe('Testing HexToDecimal', () => {
+  it.each([
+    ['0', 0],
+    ['1', 1],
+    ['A', 10],
+    ['B', 11],
+    ['C', 12],
+    ['D', 13],
+    ['E', 14],
+    ['F', 15],
+    ['10', 16],
+    ['859', 2137],
+    ['4D2', 1234],
+    ['81323ABD92', 554893491602]
+  ])('check with %s', (hexStr, expected) => {
+    expect(hexToDecimal(hexStr)).toBe(expected)
+  })
+
+  it.each(['a', '-1', 'G', ''])('throws for %s', (hexStr) => {
+    expect(() => hexToDecimal(hexStr)).toThrowError()
+  })
+})

DIRECTORY.md

@@ -35,6 +35,8 @@
   * [ROT13](Ciphers/ROT13.js)
   * [VigenereCipher](Ciphers/VigenereCipher.js)
   * [XORCipher](Ciphers/XORCipher.js)
+* **Compression**
+  * [RLE](Compression/RLE.js)
 * **Conversions**
   * [ArbitraryBase](Conversions/ArbitraryBase.js)
   * [ArrayBufferToBase64](Conversions/ArrayBufferToBase64.js)
@@ -285,6 +287,7 @@
   * [Problem016](Project-Euler/Problem016.js)
   * [Problem017](Project-Euler/Problem017.js)
   * [Problem018](Project-Euler/Problem018.js)
+  * [Problem019](Project-Euler/Problem019.js)
   * [Problem020](Project-Euler/Problem020.js)
   * [Problem021](Project-Euler/Problem021.js)
   * [Problem023](Project-Euler/Problem023.js)

Data-Structures/Array/QuickSelect.js

@@ -12,7 +12,6 @@
  */
 
 function QuickSelect(items, kth) {
-  // eslint-disable-line no-unused-vars
   if (kth < 1 || kth > items.length) {
     throw new RangeError('Index Out of Bound')
   }

Data-Structures/Queue/QueueUsing2Stacks.js

@@ -29,24 +29,6 @@ class Queue {
       return top
     }
   }
-
-  // display elements of the inputstack
-  listIn(output = (value) => console.log(value)) {
-    let i = 0
-    while (i < this.inputStack.length) {
-      output(this.inputStack[i])
-      i++
-    }
-  }
-
-  // display element of the outputstack
-  listOut(output = (value) => console.log(value)) {
-    let i = 0
-    while (i < this.outputStack.length) {
-      output(this.outputStack[i])
-      i++
-    }
-  }
 }
 
 export { Queue }

Dynamic-Programming/NumberOfSubsetEqualToGivenSum.js

@@ -1,12 +1,19 @@
 /*
-Given an array of non-negative integers and a value sum,
+Given an array of positive integers and a value sum,
 determine the total number of the subset with sum
 equal to the given sum.
 */
 /*
   Given solution is O(n*sum) Time complexity and O(sum) Space complexity
 */
 function NumberOfSubsetSum(array, sum) {
+  if (sum < 0) {
+    throw new Error('The sum must be non-negative.')
+  }
+
+  if (!array.every((num) => num > 0)) {
+    throw new Error('All of the inputs of the array must be positive.')
+  }
   const dp = [] // create an dp array where dp[i] denote number of subset with sum equal to i
   for (let i = 1; i <= sum; i++) {
     dp[i] = 0
@@ -23,10 +30,4 @@ function NumberOfSubsetSum(array, sum) {
   return dp[sum]
 }
 
-// example
-
-// const array = [1, 1, 2, 2, 3, 1, 1]
-// const sum = 4
-// const result = NumberOfSubsetSum(array, sum)
-
 export { NumberOfSubsetSum }

Dynamic-Programming/tests/NumberOfSubsetEqualToGivenSum.test.js

@@ -0,0 +1,25 @@
+import { NumberOfSubsetSum } from '../NumberOfSubsetEqualToGivenSum'
+
+describe('Testing NumberOfSubsetSum', () => {
+  it.each([
+    [[], 0, 1],
+    [[], 1, 0],
+    [[1], 2, 0],
+    [[1, 2, 3, 4, 5], 0, 1],
+    [[1, 1, 1, 1, 1], 5, 1],
+    [[1, 1, 1, 1, 1], 4, 5],
+    [[1, 2, 3, 3], 6, 3],
+    [[10, 20, 30, 1], 31, 2],
+    [[1, 1, 2, 2, 3, 1, 1], 4, 18]
+  ])('check with %j and %i', (arr, sum, expected) => {
+    expect(NumberOfSubsetSum(arr, sum)).toBe(expected)
+  })
+
+  it.each([
+    [[1, 2], -1],
+    [[0, 2], 2],
+    [[1, -1], 0]
+  ])('throws for %j and %i', (arr, sum) => {
+    expect(() => NumberOfSubsetSum(arr, sum)).toThrowError()
+  })
+})

Maths/AverageMean.js

@@ -13,11 +13,7 @@ const mean = (nums) => {
     throw new TypeError('Invalid Input')
   }
 
-  // This loop sums all values in the 'nums' array using forEach loop
-  const sum = nums.reduce((sum, cur) => sum + cur, 0)
-
-  // Divide sum by the length of the 'nums' array.
-  return sum / nums.length
+  return nums.reduce((sum, cur) => sum + cur, 0) / nums.length
 }
 
 export { mean }

Maths/test/EulerMethod.manual-test.js

@@ -15,7 +15,6 @@ function plotLine(label, points, width, height) {
 
   // Chart-class from chartjs
   const chart = new Chart(canvas, {
-    // eslint-disable-line
     type: 'scatter',
     data: {
       datasets: [

Maths/test/FindMinIterator.test.js

@@ -22,13 +22,12 @@ describe('FindMinIterator', () => {
   })
 
   test('given empty generator then min is undefined', () => {
-    const src = function* () {} // eslint-disable-line
+    const src = function* () {}
     expect(FindMinIterator(src())).toBeUndefined()
   })
 
   test('given generator then min is found', () => {
     const src = function* () {
-      // eslint-disable-line
       yield 1
       yield -1
       yield 0
@@ -38,7 +37,6 @@ describe('FindMinIterator', () => {
 
   test('given string generator then min string length is found', () => {
     const src = function* () {
-      // eslint-disable-line
       yield 'abc'
       yield 'de'
       yield 'qwerty'

Project-Euler/Problem005.js

@@ -5,11 +5,9 @@ Smallest multiple
 What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
 */
 
-export const findSmallestMultiple = () => {
-  const divisors = [
-    20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2
-  ]
-  let num = 21
+export const findSmallestMultiple = (maxDivisor) => {
+  const divisors = Array.from({ length: maxDivisor }, (_, i) => i + 1)
+  let num = maxDivisor + 1
   let result
 
   while (!result) {

Project-Euler/Problem019.js

@@ -0,0 +1,48 @@
+/**
+ * Problem 19 - Counting Sundays
+ *
+ * @see {@link https://projecteuler.net/problem=19}
+ *
+ * You are given the following information, but you may prefer to do some research for yourself.
+ * 1 Jan 1900 was a Monday.
+ * Thirty days has September,
+ * April, June and November.
+ * All the rest have thirty-one,
+ * Saving February alone,
+ * Which has twenty-eight, rain or shine.
+ * And on leap years, twenty-nine.
+ * A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.
+ * How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?
+ *
+ * @author ddaniel27
+ */
+import { isLeapYear } from '../Maths/LeapYear'
+
+function problem19() {
+  let sundaysCount = 0 // Count of Sundays
+  let dayOfWeek = 2 // 1st Jan 1900 was a Monday, so 1st Jan 1901 was a Tuesday
+
+  for (let year = 1901; year <= 2000; year++) {
+    for (let month = 1; month <= 12; month++) {
+      if (dayOfWeek === 0) {
+        // If it's a Sunday (0 is Sunday, 1 is Monday, ..., 6 is Saturday)
+        sundaysCount++
+      }
+
+      let daysInMonth = 31
+      if (month === 4 || month === 6 || month === 9 || month === 11) {
+        // April, June, September, November
+        daysInMonth = 30
+      } else if (month === 2) {
+        // February
+        daysInMonth = isLeapYear(year) ? 29 : 28
+      }
+
+      dayOfWeek = (dayOfWeek + daysInMonth) % 7 // Calculate the day of the week
+    }
+  }
+
+  return sundaysCount
+}
+
+export { problem19 }

Project-Euler/test/Problem005.test.js

@@ -0,0 +1,12 @@
+import { expect } from 'vitest'
+import { findSmallestMultiple } from '../Problem005.js'
+
+describe.concurrent('Find smallest multiple', () => {
+  test.each([
+    [10, 2520],
+    [15, 360360],
+    [20, 232792560]
+  ])('max divisor -> %i, smallest multiple -> %i', (a, expected) => {
+    expect(findSmallestMultiple(a)).toBe(expected)
+  })
+})