Merge branch 'TheAlgorithms:master' into master

Author: ddaniel27

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()
+  })
+})

Dynamic-Programming/LongestIncreasingSubsequence.js

@@ -6,6 +6,9 @@
 // Return the length of the Longest Increasing Subsequence, given array x
 function longestIncreasingSubsequence(x) {
   const length = x.length
+  if (length == 0) {
+    return 0
+  }
   const dp = Array(length).fill(1)
 
   let res = 1

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/LongestIncreasingSubsequence.test.js

@@ -0,0 +1,24 @@
+import { longestIncreasingSubsequence } from '../LongestIncreasingSubsequence'
+
+describe('Testing longestIncreasingSubsequence', () => {
+  it.each([
+    [[], 0],
+    [[1], 1],
+    [[2, 2], 1],
+    [[3, 3, 3], 1],
+    [[4, 4, 4, 4], 1],
+    [[1, 2], 2],
+    [[1, 2, 2, 2, 2], 2],
+    [[1, 0, 2], 2],
+    [[1, 10, 2, 30], 3],
+    [[5, 8, 3, 7, 9, 1], 3],
+    [[10, 9, 2, 5, 3, 7, 101, 18], 4],
+    [[10, 10, 9, 9, 2, 2, 5, 5, 3, 3, 7, 7, 101, 101, 18, 18], 4],
+    [[0, 1, 0, 3, 2, 3], 4],
+    [[1, 1, 2, 2, 2], 2],
+    [[1, 1, 2, 2, 2, 3, 3, 3, 3], 3],
+    [[0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15], 6]
+  ])('check with %j', (input, expected) => {
+    expect(longestIncreasingSubsequence(input)).toBe(expected)
+  })
+})

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()
+  })
+})