diff --git a/ArrayAlgorithms.ts b/ArrayAlgorithms.ts new file mode 100644 index 0000000..f4089ad --- /dev/null +++ b/ArrayAlgorithms.ts @@ -0,0 +1,79 @@ +//typescriptClasses/ArrayAlgorithms.ts +//Matthew Ellison +// Created: 07-13-21 +//Modified: 07-13-21 +//Algorithms for arrays +/* +Copyright (C) 2021 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + + +//Returns true if array 1 and array 2 elements are the same +export function arrayEquals(array1: any[], array2: any[]): boolean{ + //If they aren't the same type they aren't equal + if((typeof array1) != (typeof array2)){ + return false; + } + //If they aren't the same length they aren't equal + else if(array1.length != array2.length){ + return false; + } + else{ + //Loop through every element to see if each one is equal + for(let cnt = 0;cnt < array1.length;++cnt){ + //If any element in the same location is different return false + if(array1[cnt] != array2[cnt]){ + return false; + } + } + //If every element was the same they are equal + return true; + } +} + +//Returns the sum of all elements in the array +export function getSum(ary: number[]): number{ + let sum: number = 0; + ary.forEach(a => sum += a); + return sum; +} +export function getSumBig(ary: bigint[]): bigint{ + let sum: bigint = 0n; + ary.forEach(a => sum += a); + return sum; +} + +//Returns the product of all elements in the array +export function getProd(ary: number[]): number{ + //Return 0 if the array is empty + if(ary.length == 0){ + return 0; + } + + let prod: number = 1; + ary.forEach(a => prod *= a); + return prod; +} +export function getProdBig(ary: bigint[]): bigint{ + //Return 0 if the array is empty + if(ary.length == 0){ + return 0n; + } + + let prod: bigint = 1n; + ary.forEach(a => prod *= a); + return prod; +} diff --git a/Algorithms.ts b/NumberAlgorithms.ts similarity index 82% rename from Algorithms.ts rename to NumberAlgorithms.ts index 9d68f85..1814300 100644 --- a/Algorithms.ts +++ b/NumberAlgorithms.ts @@ -1,8 +1,8 @@ -//typescriptClasses/Algorithms.ts +//typescriptClasses/NumberAlgorithms.ts //Matthew Ellison -// Created: 10-19-20 -//Modified: 03-10-21 -//This class holds many algorithms that I have found it useful to keep around +// Created: 07-13-21 +//Modified: 07-13-21 +//Algorithms for numbers /* Copyright (C) 2021 Matthew Ellison @@ -21,50 +21,9 @@ Copyright (C) 2021 Matthew Ellison */ -import { SSL_OP_SSLEAY_080_CLIENT_DH_BUG } from "constants"; import { InvalidResult } from "./InvalidResult"; -export function arrayEquals(array1: any[], array2: any[]): boolean{ - //If they aren't the same type they aren't equal - if((typeof array1) != (typeof array2)){ - return false; - } - //If they aren't the same length they aren't equal - else if(array1.length != array2.length){ - return false; - } - else{ - //Loop through every element to see if each one is equal - for(let cnt = 0;cnt < array1.length;++cnt){ - //If any element in the same location is different return false - if(array1[cnt] != array2[cnt]){ - return false; - } - } - //If every element was the same they are equal - return true; - } -} - -export function sqrtBig(value: bigint): bigint{ - if(value < 0n){ - throw "Negative numbers are not supported"; - } - - let k = 2n; - let o = 0n; - let x = value; - let limit = 100; - - while(x ** k !== k && x !== o && --limit){ - o = x; - x = ((k - 1n) * x + value / x ** (k - 1n)) / k; - } - - return x; -} - //Generate an infinite sequence of prime numbers using the Sieve of Eratosthenes export function* sieveOfEratosthenes(){ //Return 2 the first time, this lets us skip all even numbers later @@ -98,7 +57,6 @@ export function* sieveOfEratosthenes(){ } } } - export function* sieveOfEratosthenesBig(){ //Return 2 the first time, this lets us skip all even numbers later yield 2n; @@ -132,6 +90,26 @@ export function* sieveOfEratosthenesBig(){ } } +//This returns the sqrt of the bigint passed in +export function sqrtBig(value: bigint): bigint{ + if(value < 0n){ + throw "Negative numbers are not supported"; + } + + let k = 2n; + let o = 0n; + let x = value; + let limit = 100; + + while(x ** k !== k && x !== o && --limit){ + o = x; + x = ((k - 1n) * x + value / x ** (k - 1n)) / k; + } + + return x; +} + +//Returns an array with all Fibonacci numbers up to goalNumber export function getAllFib(goalNumber: number): number[]{ //Setup the variables let fibNums: number[] = []; @@ -185,6 +163,7 @@ export function getAllFibBig(goalNumber: bigint): bigint[]{ return fibNums; } +//Returns an array with all primes up to goalNumber export function getPrimes(goalNumber: number): number[]{ let primes: number[] = []; //Holds the prime numbers let foundFactor: boolean = false; //A flag for whether a factor of the current number has been found @@ -286,6 +265,7 @@ export function getPrimesBig(goalNumber: bigint): bigint[]{ return primes; } +//Returns an array with numberOfPrimes prime elements export function getNumPrimes(numberOfPrimes: number): number[]{ let primes: number[] = []; //Holds the prime numbers let foundFactor: boolean = false; //A flag for whether a factor of the current number has been found @@ -387,6 +367,7 @@ export function getNumPrimesBig(numberOfPrimes: bigint): bigint[]{ return primes; } +//Returns true if possiblePrime is prime export function isPrime(possiblePrime: number): boolean{ if(possiblePrime <= 3){ return possiblePrime > 1; @@ -416,6 +397,7 @@ export function isPrimeBig(possiblePrime: bigint): boolean{ return true; } +//Returns an array with all the factors of goalNumber export function getFactors(goalNumber: number): number[]{ //You need to get all the primes that could be factors of this number so you can test them let topPossiblePrime: number = Math.ceil(Math.sqrt(goalNumber)); @@ -485,6 +467,7 @@ export function getFactorsBig(goalNumber: bigint): bigint[]{ return factors; } +//Returns an array with the prime divisors of goalNumber export function getDivisors(goalNumber: number): number[]{ let divisors: number[] = []; @@ -564,37 +547,7 @@ export function getDivisorsBig(goalNumber: bigint): bigint[]{ return divisors; } -export function getSum(ary: number[]): number{ - let sum: number = 0; - ary.forEach(a => sum += a); - return sum; -} -export function getSumBig(ary: bigint[]): bigint{ - let sum: bigint = 0n; - ary.forEach(a => sum += a); - return sum; -} -export function getProd(ary: number[]): number{ - //Return 0 if the array is empty - if(ary.length == 0){ - return 0; - } - - let prod: number = 1; - ary.forEach(a => prod *= a); - return prod; -} -export function getProdBig(ary: bigint[]): bigint{ - //Return 0 if the array is empty - if(ary.length == 0){ - return 0n; - } - - let prod: bigint = 1n; - ary.forEach(a => prod *= a); - return prod; -} - +//Returns F[goalSubscript] export function getFib(goalSubscript: number): number{ //Setup the variables let fibNums: number[] = [1, 1, 0]; //A list to keep track of the Fibonacci numbers. It need only be 3 long because we only need the one we are working on and the last 2 @@ -632,61 +585,6 @@ export function getFibBig(goalSubscript: bigint): bigint{ return fibNums[Number((fibLoc - 1n) % 3n)]; } -//This is a function that creates all permutations of a string and returns a vector of those permutations -export function getPermutations(master: string): string[]{ - return getPermutationsHelper(master, 0); -} -function getPermutationsHelper(master: string, num: number): string[]{ - let perms: string[] = []; - //Check if the number is out of bounds - if((num >= master.length) || (num < 0)){ - //Do nothing and return an empty array - } - //If this is the last possible recurse just return the current string - else if(num == (master.length - 1)){ - perms.push(master); - } - //If there are more possible recurses, recurse with the current permutation - else{ - let temp: string[] = getPermutationsHelper(master, num + 1); - temp.forEach(str => perms.push(str)); - //You need to swap the current letter with every possible letter after it - //The ones needed to swap before will happen automatically when the function recurses - for(let cnt = 1;(num + cnt) < master.length;++cnt){ - master = swapString(master, num, (num + cnt)); - temp = getPermutationsHelper(master, num + 1); - temp.forEach(str => perms.push(str)); - master = swapString(master, num, (num + cnt)); - } - - //The array is not necessarily in alph-numeric order. So if this is the full array sort it before returning - if(num == 0){ - perms.sort(); - } - } - - //Return the array that was build - return perms; -} -function swapString(str: string, first: number, second: number): string{ - let tempStr: string = str.substr(0, first) + str[second] + str.substr(first + 1, second - first - 1) + str[first] + str.substr(second + 1); - - return tempStr; -} - -//This function returns the number of times the character occurs in the string -export function findNumOccurrence(str: string, ch: string){ - let num: number = 0; //Set the number of occurrences to 0 to start - //Loop through every character in the string and compare it to the character passed in - for(let strCh of str){ - //If the character is the same as the one passed in increment the counter - if(strCh == ch){ - ++num; - } - } - //Return the number of times the character appeared in the string - return num; -} //This function returns the GCD of the two numbers sent to it export function gcd(num1: number, num2: number){ while((num1 != 0) && (num2 != 0)){ @@ -727,17 +625,6 @@ export function factorialBig(num: bigint): bigint{ return fact; } -//Returns true if the string passed in is a palindrome -export function isPalindrome(str: string): boolean{ - let rev = str.split("").reverse().join(""); - if(str == rev){ - return true; - } - else{ - return false; - } -} - //Converts a number to its binary equivalent export function toBin(num: number): string{ return (num >>> 0).toString(2); diff --git a/StringAlgorithms.ts b/StringAlgorithms.ts new file mode 100644 index 0000000..38e6578 --- /dev/null +++ b/StringAlgorithms.ts @@ -0,0 +1,89 @@ +//typescriptClasses/StringAlgorithms.ts +//Matthew Ellison +// Created: 07-13-21 +//Modified: 07-13-21 +//Algorithms for strings +/* +Copyright (C) 2021 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + + +//This is a function that creates all permutations of a string and returns a vector of those permutations +export function getPermutations(master: string): string[]{ + return getPermutationsHelper(master, 0); +} +function getPermutationsHelper(master: string, num: number): string[]{ + let perms: string[] = []; + //Check if the number is out of bounds + if((num >= master.length) || (num < 0)){ + //Do nothing and return an empty array + } + //If this is the last possible recurse just return the current string + else if(num == (master.length - 1)){ + perms.push(master); + } + //If there are more possible recurses, recurse with the current permutation + else{ + let temp: string[] = getPermutationsHelper(master, num + 1); + temp.forEach(str => perms.push(str)); + //You need to swap the current letter with every possible letter after it + //The ones needed to swap before will happen automatically when the function recurses + for(let cnt = 1;(num + cnt) < master.length;++cnt){ + master = swapString(master, num, (num + cnt)); + temp = getPermutationsHelper(master, num + 1); + temp.forEach(str => perms.push(str)); + master = swapString(master, num, (num + cnt)); + } + + //The array is not necessarily in alph-numeric order. So if this is the full array sort it before returning + if(num == 0){ + perms.sort(); + } + } + + //Return the array that was build + return perms; +} +function swapString(str: string, first: number, second: number): string{ + let tempStr: string = str.substr(0, first) + str[second] + str.substr(first + 1, second - first - 1) + str[first] + str.substr(second + 1); + + return tempStr; +} + +//Returns true if the string passed in is a palindrome +export function isPalindrome(str: string): boolean{ + let rev = str.split("").reverse().join(""); + if(str == rev){ + return true; + } + else{ + return false; + } +} + +//This function returns the number of times the character occurs in the string +export function findNumOccurrence(str: string, ch: string){ + let num: number = 0; //Set the number of occurrences to 0 to start + //Loop through every character in the string and compare it to the character passed in + for(let strCh of str){ + //If the character is the same as the one passed in increment the counter + if(strCh == ch){ + ++num; + } + } + //Return the number of times the character appeared in the string + return num; +} \ No newline at end of file diff --git a/TestAlgorithms.ts b/TestAlgorithms.ts index 8c96401..59a0a48 100644 --- a/TestAlgorithms.ts +++ b/TestAlgorithms.ts @@ -1,7 +1,7 @@ //typescriptClasses/TestAlgorithms.ts //Matthew Ellison // Created: 10-19-20 -//Modified: 03-12-21 +//Modified: 07-13-21 //This class holds many algorithms that I have found it useful to keep around /* Copyright (C) 2021 Matthew Ellison @@ -21,381 +21,33 @@ Copyright (C) 2021 Matthew Ellison */ -import assert = require("assert"); -import { arrayEquals, getAllFib, getAllFibBig, getFactors, getFactorsBig, getPrimes, getPrimesBig, getNumPrimes, getNumPrimesBig, - sqrtBig, getSum, getSumBig, getProd, getProdBig, getDivisors, getDivisorsBig, factorial, factorialBig, isPalindrome, toBin, toBinBig, isPrime, isPrimeBig, sieveOfEratosthenes, sieveOfEratosthenesBig } from "./Algorithms"; +import { testArrayEquals, testGetSum, testGetProd } from "./TestArrayAlgorithms"; +import { testFactorial, testGCD, testGetAllFib, testGetDivisors, testGetFactors, testGetFib, testGetNumPrimes, testGetPrimes, testIsPrime, testSieveOfEratosthenes, testSqrtBig, testToBin } from "./TestNumberAlgorithms"; +import { testFindNumOccurrences, testGetPermutations, testIsPalindrome } from "./TestStringAlgorithms"; -function testArrayEquals(){ - //Test 1 - let ary1: number[] = []; - let ary2: number[] = []; - let correctAnswer = true; - let answer = arrayEquals(ary1, ary2); - assert.ok((answer == correctAnswer), "arrayEquals test 1 failed"); - - //Test 2 - ary1 = [1, 2, 3, 4, 5]; - ary2 = [1, 2, 3, 4, 5]; - correctAnswer = true; - answer = arrayEquals(ary1, ary2); - assert.ok((answer == correctAnswer), "arrayEquals test 2 failed"); - - //Test 3 - ary1 = [1, 2, 3, 4, 5]; - ary2 = [1]; - correctAnswer = false; - answer = arrayEquals(ary1, ary2); - assert.ok((answer == correctAnswer), "arrayEquals test 3 failed"); - - //Test 4 - ary1 = [1, 2, 3, 4, 5]; - ary2 = [6, 2, 3, 4, 5]; - correctAnswer = false; - answer = arrayEquals(ary1, ary2); - assert.ok((answer == correctAnswer), "arrayEquals test 4 failed"); - - //Test 5 - ary1 = [1, 2, 3, 4, 5]; - ary2 = [1, 2, 3, 4, 6]; - correctAnswer = false; - answer = arrayEquals(ary1, ary2); - assert.ok((answer == correctAnswer), "arrayEquals test 5 failed"); - - //Test 6 - let ary3: string[] = ["test1", "test2"]; - let ary4: string[] = ["test1", "test2"]; - correctAnswer = true; - answer = arrayEquals(ary3, ary4); - assert.ok((answer == correctAnswer), "arrayEquals test 6 failed"); - - //Test 7 - ary3 = ["test1", "Test2"]; - ary4 = ["test1", "test2"]; - correctAnswer = false; - answer = arrayEquals(ary3, ary4); - assert.ok((answer == correctAnswer), "arrayEquals test 7 failed"); - - console.log("testArrayEquals passed"); -} - -function testSqrtBig(){ - //Test 1 - let square: bigint = 25n; - let correctAnswer: bigint = 5n; - let answer = sqrtBig(square); - assert.ok((answer == correctAnswer), "sqrtBig test 1 failed"); - - //Test 2 - square = 0n; - correctAnswer = 0n; - answer = sqrtBig(square); - assert.ok((answer == correctAnswer), "sqrtBig test 2 failed"); - - console.log("testSqrtBig passed"); -} - -function testSieveOfEratosthenes(){ - //Test 1 - let sieve = sieveOfEratosthenes(); - let correctAnswer: number[] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]; - let answer: number[] = []; - for(let cnt = 0;cnt < 25;++cnt){ - let prime = sieve.next().value; - if(typeof prime == "number"){ - answer.push(prime); - } - } - assert.ok(arrayEquals(answer, correctAnswer), "sieveOfEratosthenes failed"); - - //Test 2 - let bigSieve = sieveOfEratosthenesBig(); - let bigCorrectAnswer: bigint[] = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n]; - let bigAnswer: bigint[] = []; - for(let cnt = 0;cnt < 25;++cnt){ - let prime = bigSieve.next().value; - if(typeof prime == "bigint"){ - bigAnswer.push(prime); - } - } - assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "sieveOfEratosthenes big failed"); - - console.log("sieveOfEratosthenes passed"); -} - -function testGetAllFib(){ - //Test 1 - let correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]; - let highestNumber = 100; - let answer = getAllFib(highestNumber); - assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 1 failed"); - - //Test 2 - correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987] - highestNumber = 1000; - answer = getAllFib(highestNumber); - assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 2 failed"); - - //Test 3 - let bigCorrectAnswer = [1n, 1n, 2n, 3n, 5n, 8n, 13n, 21n, 34n, 55n, 89n]; - let bigHighestNumber = 100n; - let bigAnswer = getAllFibBig(bigHighestNumber); - assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getAllFibBig failed"); - console.log("testGetAllFib passed"); -} - -function testGetPrimes(){ - //Test1 - let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]; - let topNum = 100; - let answer = getPrimes(topNum); - assert.ok(arrayEquals(answer, correctAnswer), "getPrimes number failed"); - - //Test 2 - let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n]; - let bigTopNum = 100n; - let bigAnswer = getPrimesBig(bigTopNum); - assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getPrimesBig failed"); - - console.log("getPrimes passed"); -} - -function testGetNumPrimes(){ - //Test1 - let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]; - let numPrimes = 25; - let answer = getNumPrimes(numPrimes); - assert.ok(arrayEquals(answer, correctAnswer), "getNumPrimes number failed"); - - //Test2 - let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n]; - let bigNumPrimes = 25n; - let bigAnswer = getNumPrimesBig(bigNumPrimes); - assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getNumPrimesBig failed"); - - console.log("getNumPrimes passed"); -} - -function testIsPrime(){ - //Test 1 - let num: number = 2; - let correctAnswer: boolean = true; - let answer: boolean = isPrime(num); - assert.ok((answer == correctAnswer), "isPrime number 1 failed"); - //Test 2 - num = 97; - correctAnswer = true; - answer = isPrime(num); - assert.ok((answer == correctAnswer), "isPrime number 2 failed"); - //Test 3 - num = 1000; - correctAnswer = false; - answer = isPrime(num); - assert.ok((answer == correctAnswer), "isPrime number 3 failed"); - //Test 4 - num = 1; - correctAnswer = false; - answer = isPrime(num); - assert.ok((answer == correctAnswer), "isPrime number 4 failed"); - - //Test 5 - let bigNum: bigint = 2n; - correctAnswer = true; - answer = isPrimeBig(bigNum); - assert.ok((answer == correctAnswer), "isPrime big 1 failed"); - //Test 6 - bigNum = 97n; - correctAnswer = true; - answer = isPrimeBig(bigNum); - assert.ok((answer == correctAnswer), "isPrime big 2 failed"); - //Test 7 - bigNum = 1000n; - correctAnswer = false; - answer = isPrimeBig(bigNum); - assert.ok((answer == correctAnswer), "isPrime big 3 failed"); - //Test 8 - bigNum = 1n; - correctAnswer = false; - answer = isPrimeBig(bigNum); - assert.ok((answer == correctAnswer), "isPrime big 4 failed"); - - console.log("isPrime passed"); -} - -function testGetFactors(){ - //Test 1 - let correctAnswer = [2, 2, 5, 5]; - let number = 100; - let answer = getFactors(number); - assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 1 failed"); - //Test 2 - correctAnswer = [2, 7, 7]; - number = 98; - answer = getFactors(number); - assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 2 failed"); - - //Test 3 - let bigCorrectAnswer = [2n, 7n, 7n]; - let bigNumber = 98n; - let bigAnswer = getFactorsBig(bigNumber); - assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getFactors BigInt failed"); - - console.log("getFactors passed"); -} - -function testGetDivisors(){ - //Test 1 - let correctAnswer: number[] = [1, 2, 4, 5, 10, 20, 25, 50, 100]; - let topNum: number = 100; - let answer: number[] = getDivisors(topNum); - assert.ok(arrayEquals(answer, correctAnswer), "getDivisors number failed"); - - //Test 2 - let bigCorrectAnswer: bigint[] = [1n, 2n, 4n, 5n, 10n, 20n, 25n, 50n, 100n]; - let bigTopNum: bigint = 100n; - let bigAnswer: bigint[] = getDivisorsBig(bigTopNum); - assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getDivisors BigInt failed"); - - console.log("getDivisors passed"); -} - -function testGetSum(){ - //Test 1 - let correctAnswer: number = 0; - let numbers: number[] = []; - let answer: number = getSum(numbers); - assert.ok((correctAnswer == answer), "getSum number 1 failed"); - //Test 2 - correctAnswer = 118; - numbers = [2, 2, 3, 3, 4, 4, 100]; - answer = getSum(numbers); - assert.ok((correctAnswer == answer), "getSum number 2 failed"); - - //Test 3 - let bigCorrectAnswer: bigint = 118n; - let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n]; - let bigAnswer: bigint = getSumBig(bigNumbers); - assert.ok((bigCorrectAnswer == bigAnswer), "getSumBig failed"); - - console.log("getSum passed"); -} - -function testGetProd(){ - //Test 1 - let correctAnswer: number = 0; - let numbers: number[] = []; - let answer: number = getProd(numbers); - assert.ok((correctAnswer == answer), "getProd number 1 failed"); - //Test 2 - correctAnswer = 57600; - numbers = [2, 2, 3, 3, 4, 4, 100]; - answer = getProd(numbers); - assert.ok((correctAnswer == answer), "getProd number 2 failed"); - - //Test 3 - let bigCorrectAnswer: bigint = 57600n; - let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n]; - let bigAnswer: bigint = getProdBig(bigNumbers); - assert.ok((bigCorrectAnswer == bigAnswer), "getProdBig failed"); - - console.log("getProd passed"); -} - -function testFactorial(){ - //Test 1 - let num: number = 1; - let correctAnswer: number = 1; - let answer: number = factorial(num); - assert.ok((correctAnswer == answer), "factorial number 1 failed"); - //Test 2 - num = 10; - correctAnswer = 3628800; - answer = factorial(num); - assert.ok((correctAnswer == answer), "factorial number 2 failed"); - //Test 3 - num = -5; - correctAnswer = 1; - answer = factorial(num); - assert.ok((correctAnswer == answer), "factorial number 3 failed"); - - //Test 4 - let numBig: bigint = 1n; - let correctAnswerBig: bigint = 1n; - let answerBig = factorialBig(numBig); - assert.ok((correctAnswerBig == answerBig), "factorialBig number 1 failed"); - - console.log("factorial passed"); -} - -function testIsPalindrome(){ - //Test 1 - let str: string = "101"; - let correctAnswer: boolean = true; - let answer: boolean = isPalindrome(str); - assert.ok((correctAnswer == answer), "isPalindrome number 1 failed"); - //Test 2 - str = "100"; - correctAnswer = false; - answer = isPalindrome(str); - assert.ok((correctAnswer == answer), "isPalindrome number 2 failed"); - //Test 3 - str = ""; - correctAnswer = true; - answer = isPalindrome(str); - assert.ok((correctAnswer == answer), "isPalindrome number 3 failed"); - - console.log("isPalindrome passed"); -} - -function testToBin(){ - //Test 1 - let num: number = 7; - let correctAnswer: string = "111"; - let answer: string = toBin(num); - assert.ok((correctAnswer == answer), "toBin number 1 failed"); - //Test 2 - num = 0; - correctAnswer = "0"; - answer = toBin(num); - assert.ok((correctAnswer == answer), "toBin number 2 failed"); - //Test 3 - num = 1000000; - correctAnswer = "11110100001001000000"; - answer = toBin(num); - assert.ok((correctAnswer == answer), "toBin number 3 failed"); - - //Test 4 - let numBig: bigint = 7n; - correctAnswer = "111"; - answer = toBinBig(numBig); - assert.ok((correctAnswer == answer), "toBinBig number 1 failed"); - //Test 5 - numBig = 0n; - correctAnswer = "0"; - answer = toBinBig(numBig); - assert.ok((correctAnswer == answer), "toBinBig number 2 failed"); - //Test 6 - numBig = 1000000n; - correctAnswer = "11110100001001000000"; - answer = toBinBig(numBig); - assert.ok((correctAnswer == answer), "toBinBig number 3 failed"); - - console.log("toBin passed"); -} - - -//Run all of the tests +//Run the array tests testArrayEquals(); -testSqrtBig(); +testGetSum(); +testGetProd(); + +//Run the number tests testSieveOfEratosthenes(); +testSqrtBig(); testGetAllFib(); testGetPrimes(); testGetNumPrimes(); testIsPrime(); testGetFactors(); testGetDivisors(); -testGetSum(); -testGetProd(); +testGetFib(); +testGCD(); testFactorial(); -testIsPalindrome(); testToBin(); + +//Run the string tests +testGetPermutations(); +testIsPalindrome(); +testFindNumOccurrences(); + +console.log("All tests passed"); diff --git a/TestArrayAlgorithms.ts b/TestArrayAlgorithms.ts new file mode 100644 index 0000000..deac9a5 --- /dev/null +++ b/TestArrayAlgorithms.ts @@ -0,0 +1,121 @@ +//typescriptClasses/TestArrayAlgorithms.ts +//Matthew Ellison +// Created: 07-13-21 +//Modified: 07-13-21 +//Tests for the array algorithms +/* +Copyright (C) 2021 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + + +import assert = require("assert"); +import { arrayEquals, getProd, getProdBig, getSum, getSumBig } from "./ArrayAlgorithms"; + + +export function testArrayEquals(){ + //Test 1 + let ary1: number[] = []; + let ary2: number[] = []; + let correctAnswer = true; + let answer = arrayEquals(ary1, ary2); + assert.ok((answer == correctAnswer), "arrayEquals test 1 failed"); + + //Test 2 + ary1 = [1, 2, 3, 4, 5]; + ary2 = [1, 2, 3, 4, 5]; + correctAnswer = true; + answer = arrayEquals(ary1, ary2); + assert.ok((answer == correctAnswer), "arrayEquals test 2 failed"); + + //Test 3 + ary1 = [1, 2, 3, 4, 5]; + ary2 = [1]; + correctAnswer = false; + answer = arrayEquals(ary1, ary2); + assert.ok((answer == correctAnswer), "arrayEquals test 3 failed"); + + //Test 4 + ary1 = [1, 2, 3, 4, 5]; + ary2 = [6, 2, 3, 4, 5]; + correctAnswer = false; + answer = arrayEquals(ary1, ary2); + assert.ok((answer == correctAnswer), "arrayEquals test 4 failed"); + + //Test 5 + ary1 = [1, 2, 3, 4, 5]; + ary2 = [1, 2, 3, 4, 6]; + correctAnswer = false; + answer = arrayEquals(ary1, ary2); + assert.ok((answer == correctAnswer), "arrayEquals test 5 failed"); + + //Test 6 + let ary3: string[] = ["test1", "test2"]; + let ary4: string[] = ["test1", "test2"]; + correctAnswer = true; + answer = arrayEquals(ary3, ary4); + assert.ok((answer == correctAnswer), "arrayEquals test 6 failed"); + + //Test 7 + ary3 = ["test1", "Test2"]; + ary4 = ["test1", "test2"]; + correctAnswer = false; + answer = arrayEquals(ary3, ary4); + assert.ok((answer == correctAnswer), "arrayEquals test 7 failed"); + + console.log("testArrayEquals passed"); +} + +export function testGetSum(){ + //Test 1 + let correctAnswer: number = 0; + let numbers: number[] = []; + let answer: number = getSum(numbers); + assert.ok((correctAnswer == answer), "getSum number 1 failed"); + //Test 2 + correctAnswer = 118; + numbers = [2, 2, 3, 3, 4, 4, 100]; + answer = getSum(numbers); + assert.ok((correctAnswer == answer), "getSum number 2 failed"); + + //Test 3 + let bigCorrectAnswer: bigint = 118n; + let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n]; + let bigAnswer: bigint = getSumBig(bigNumbers); + assert.ok((bigCorrectAnswer == bigAnswer), "getSumBig failed"); + + console.log("getSum passed"); +} + +export function testGetProd(){ + //Test 1 + let correctAnswer: number = 0; + let numbers: number[] = []; + let answer: number = getProd(numbers); + assert.ok((correctAnswer == answer), "getProd number 1 failed"); + //Test 2 + correctAnswer = 57600; + numbers = [2, 2, 3, 3, 4, 4, 100]; + answer = getProd(numbers); + assert.ok((correctAnswer == answer), "getProd number 2 failed"); + + //Test 3 + let bigCorrectAnswer: bigint = 57600n; + let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n]; + let bigAnswer: bigint = getProdBig(bigNumbers); + assert.ok((bigCorrectAnswer == bigAnswer), "getProdBig failed"); + + console.log("getProd passed"); +} diff --git a/TestNumberAlgorithms.ts b/TestNumberAlgorithms.ts new file mode 100644 index 0000000..5ad3fcf --- /dev/null +++ b/TestNumberAlgorithms.ts @@ -0,0 +1,343 @@ +//typescriptClasses/TestNumberAlgorithms.ts +//Matthew Ellison +// Created: 07-13-21 +//Modified: 07-13-21 +//Tests for the number algorithms +/* +Copyright (C) 2021 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + + +import assert = require("assert"); +import { arrayEquals } from "./ArrayAlgorithms"; +import { factorial, factorialBig, gcd, gcdBig, getAllFib, getAllFibBig, getDivisors, getDivisorsBig, getFactors, getFactorsBig, getFib, getFibBig, getNumPrimes, getNumPrimesBig, getPrimes, getPrimesBig, isPrime, isPrimeBig, sieveOfEratosthenes, sieveOfEratosthenesBig, sqrtBig, toBin, toBinBig } from "./NumberAlgorithms"; + + +export function testSieveOfEratosthenes(){ + //Test 1 + let sieve = sieveOfEratosthenes(); + let correctAnswer: number[] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]; + let answer: number[] = []; + for(let cnt = 0;cnt < 25;++cnt){ + let prime = sieve.next().value; + if(typeof prime == "number"){ + answer.push(prime); + } + } + assert.ok(arrayEquals(answer, correctAnswer), "sieveOfEratosthenes failed"); + + //Test 2 + let bigSieve = sieveOfEratosthenesBig(); + let bigCorrectAnswer: bigint[] = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n]; + let bigAnswer: bigint[] = []; + for(let cnt = 0;cnt < 25;++cnt){ + let prime = bigSieve.next().value; + if(typeof prime == "bigint"){ + bigAnswer.push(prime); + } + } + assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "sieveOfEratosthenes big failed"); + + console.log("sieveOfEratosthenes passed"); +} + +export function testSqrtBig(){ + //Test 1 + let square: bigint = 25n; + let correctAnswer: bigint = 5n; + let answer = sqrtBig(square); + assert.ok((answer == correctAnswer), "sqrtBig test 1 failed"); + + //Test 2 + square = 0n; + correctAnswer = 0n; + answer = sqrtBig(square); + assert.ok((answer == correctAnswer), "sqrtBig test 2 failed"); + + console.log("testSqrtBig passed"); +} + +export function testGetAllFib(){ + //Test 1 + let correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]; + let highestNumber = 100; + let answer = getAllFib(highestNumber); + assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 1 failed"); + + //Test 2 + correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987] + highestNumber = 1000; + answer = getAllFib(highestNumber); + assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 2 failed"); + + //Test 3 + let bigCorrectAnswer = [1n, 1n, 2n, 3n, 5n, 8n, 13n, 21n, 34n, 55n, 89n]; + let bigHighestNumber = 100n; + let bigAnswer = getAllFibBig(bigHighestNumber); + assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getAllFibBig failed"); + + console.log("testGetAllFib passed"); +} + +export function testGetPrimes(){ + //Test1 + let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]; + let topNum = 100; + let answer = getPrimes(topNum); + assert.ok(arrayEquals(answer, correctAnswer), "getPrimes number failed"); + + //Test 2 + let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n]; + let bigTopNum = 100n; + let bigAnswer = getPrimesBig(bigTopNum); + assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getPrimesBig failed"); + + console.log("getPrimes passed"); +} + +export function testGetNumPrimes(){ + //Test1 + let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]; + let numPrimes = 25; + let answer = getNumPrimes(numPrimes); + assert.ok(arrayEquals(answer, correctAnswer), "getNumPrimes number failed"); + + //Test2 + let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n]; + let bigNumPrimes = 25n; + let bigAnswer = getNumPrimesBig(bigNumPrimes); + assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getNumPrimesBig failed"); + + console.log("getNumPrimes passed"); +} + +export function testIsPrime(){ + //Test 1 + let num: number = 2; + let correctAnswer: boolean = true; + let answer: boolean = isPrime(num); + assert.ok((answer == correctAnswer), "isPrime number 1 failed"); + //Test 2 + num = 97; + correctAnswer = true; + answer = isPrime(num); + assert.ok((answer == correctAnswer), "isPrime number 2 failed"); + //Test 3 + num = 1000; + correctAnswer = false; + answer = isPrime(num); + assert.ok((answer == correctAnswer), "isPrime number 3 failed"); + //Test 4 + num = 1; + correctAnswer = false; + answer = isPrime(num); + assert.ok((answer == correctAnswer), "isPrime number 4 failed"); + + //Test 5 + let bigNum: bigint = 2n; + correctAnswer = true; + answer = isPrimeBig(bigNum); + assert.ok((answer == correctAnswer), "isPrime big 1 failed"); + //Test 6 + bigNum = 97n; + correctAnswer = true; + answer = isPrimeBig(bigNum); + assert.ok((answer == correctAnswer), "isPrime big 2 failed"); + //Test 7 + bigNum = 1000n; + correctAnswer = false; + answer = isPrimeBig(bigNum); + assert.ok((answer == correctAnswer), "isPrime big 3 failed"); + //Test 8 + bigNum = 1n; + correctAnswer = false; + answer = isPrimeBig(bigNum); + assert.ok((answer == correctAnswer), "isPrime big 4 failed"); + + console.log("isPrime passed"); +} + +export function testGetFactors(){ + //Test 1 + let correctAnswer = [2, 2, 5, 5]; + let number = 100; + let answer = getFactors(number); + assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 1 failed"); + //Test 2 + correctAnswer = [2, 7, 7]; + number = 98; + answer = getFactors(number); + assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 2 failed"); + + //Test 3 + let bigCorrectAnswer = [2n, 7n, 7n]; + let bigNumber = 98n; + let bigAnswer = getFactorsBig(bigNumber); + assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getFactors BigInt failed"); + + console.log("getFactors passed"); +} + +export function testGetDivisors(){ + //Test 1 + let correctAnswer: number[] = [1, 2, 4, 5, 10, 20, 25, 50, 100]; + let topNum: number = 100; + let answer: number[] = getDivisors(topNum); + assert.ok(arrayEquals(answer, correctAnswer), "getDivisors number failed"); + + //Test 2 + let bigCorrectAnswer: bigint[] = [1n, 2n, 4n, 5n, 10n, 20n, 25n, 50n, 100n]; + let bigTopNum: bigint = 100n; + let bigAnswer: bigint[] = getDivisorsBig(bigTopNum); + assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getDivisors BigInt failed"); + + console.log("getDivisors passed"); +} + +export function testGetFib(){ + //Test 1 + let correctAnswer: number = 144; + let number: number = 12; + let answer: number = getFib(number); + assert.ok((answer == correctAnswer), "getFib number 1 failed"); + //Test 2 + correctAnswer = 6765; + number = 20; + answer = getFib(number); + assert.ok((answer == correctAnswer), "getFib number 2 failed"); + + //Test 3 + let bigCorrectAnswer: bigint = 144n; + let bigNumber: bigint = 12n; + let bigAnswer: bigint = getFibBig(bigNumber); + assert.ok((bigAnswer == bigCorrectAnswer), "getFib BigInt 1 failed"); + //Test 4 + bigCorrectAnswer = 6765n; + bigNumber = 20n; + bigAnswer = getFibBig(bigNumber); + assert.ok((bigAnswer == bigCorrectAnswer), "getFib BigInt 2 failed"); + //Test 5 + bigCorrectAnswer = 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816n; + bigNumber = 4782n; + bigAnswer = getFibBig(bigNumber); + assert.ok((bigAnswer == bigCorrectAnswer), "getFib BigInt 3 failed"); + + console.log("getFib passed"); +} + +export function testGCD(){ + //Test 1 + let num1: number = 2; + let num2: number = 3; + let correctAnswer: number = 1; + let answer: number = gcd(num1, num2); + assert.ok((answer == correctAnswer), "gcd number 1 failed"); + //Test 2 + num1 = 1000; + num2 = 575; + correctAnswer = 25; + answer = gcd(num1, num2); + assert.ok((answer == correctAnswer), "gcd number 2 failed"); + //Test 3 + num1 = 1000; + num2 = 1000; + correctAnswer = 1000; + answer = gcd(num1, num2); + assert.ok((answer == correctAnswer), "gcd number 3 failed"); + + //Test 4 + let bigNum1: bigint = 2n; + let bigNum2: bigint = 3n; + let bigCorrectAnswer: bigint = 1n; + let bigAnswer: bigint = gcdBig(bigNum1, bigNum2); + assert.ok((bigAnswer == bigCorrectAnswer), "gcd BigInt 1 failed"); + //Test 5 + bigNum1 = 1000n; + bigNum2 = 575n; + bigCorrectAnswer = 25n; + bigAnswer = gcdBig(bigNum1, bigNum2); + assert.ok((bigAnswer == bigCorrectAnswer), "gcd BigInt 2 failed"); + //Test 6 + bigNum1 = 1000n; + bigNum2 = 1000n; + bigCorrectAnswer = 1000n; + bigAnswer = gcdBig(bigNum1, bigNum2); + assert.ok((bigAnswer == bigCorrectAnswer), "gcd BigInt 3 failed"); + + console.log("getGCD passed"); +} + +export function testFactorial(){ + //Test 1 + let num: number = 1; + let correctAnswer: number = 1; + let answer: number = factorial(num); + assert.ok((correctAnswer == answer), "factorial number 1 failed"); + //Test 2 + num = 10; + correctAnswer = 3628800; + answer = factorial(num); + assert.ok((correctAnswer == answer), "factorial number 2 failed"); + //Test 3 + num = -5; + correctAnswer = 1; + answer = factorial(num); + assert.ok((correctAnswer == answer), "factorial number 3 failed"); + + //Test 4 + let numBig: bigint = 1n; + let correctAnswerBig: bigint = 1n; + let answerBig = factorialBig(numBig); + assert.ok((correctAnswerBig == answerBig), "factorialBig number 1 failed"); + + console.log("factorial passed"); +} + +export function testToBin(){ + //Test 1 + let num: number = 7; + let correctAnswer: string = "111"; + let answer: string = toBin(num); + assert.ok((correctAnswer == answer), "toBin number 1 failed"); + //Test 2 + num = 0; + correctAnswer = "0"; + answer = toBin(num); + assert.ok((correctAnswer == answer), "toBin number 2 failed"); + //Test 3 + num = 1000000; + correctAnswer = "11110100001001000000"; + answer = toBin(num); + assert.ok((correctAnswer == answer), "toBin number 3 failed"); + + //Test 4 + let numBig: bigint = 7n; + correctAnswer = "111"; + answer = toBinBig(numBig); + assert.ok((correctAnswer == answer), "toBinBig number 1 failed"); + //Test 5 + numBig = 0n; + correctAnswer = "0"; + answer = toBinBig(numBig); + assert.ok((correctAnswer == answer), "toBinBig number 2 failed"); + //Test 6 + numBig = 1000000n; + correctAnswer = "11110100001001000000"; + answer = toBinBig(numBig); + assert.ok((correctAnswer == answer), "toBinBig number 3 failed"); + + console.log("toBin passed"); +} diff --git a/TestStringAlgorithms.ts b/TestStringAlgorithms.ts new file mode 100644 index 0000000..f789323 --- /dev/null +++ b/TestStringAlgorithms.ts @@ -0,0 +1,77 @@ +//typescriptClasses/TestStringAlgorithms.ts +//Matthew Ellison +// Created: 07-13-21 +//Modified: 07-13-21 +//Tests for the string algorithms +/* +Copyright (C) 2021 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ + + +import assert = require("assert"); +import { arrayEquals } from "./ArrayAlgorithms"; +import { getPermutations, isPalindrome } from "./StringAlgorithms"; + + +export function testGetPermutations(){ + //Test 1 + let permString: string = "012"; + let correctAnswer: string[] = ["012", "021", "102", "120", "201", "210"]; + let answer: string[] = getPermutations(permString); + assert.ok(arrayEquals(answer, correctAnswer), "getPermutations failed"); + + console.log("getPermutations passed"); +} + +export function testIsPalindrome(){ + //Test 1 + let str: string = "101"; + let correctAnswer: boolean = true; + let answer: boolean = isPalindrome(str); + assert.ok((answer == correctAnswer), "isPalindrome number 1 failed"); + //Test 2 + str = "100"; + correctAnswer = false; + answer = isPalindrome(str); + assert.ok((answer == correctAnswer), "isPalindrome number 2 failed"); + //Test 3 + str = ""; + correctAnswer = true; + answer = isPalindrome(str); + assert.ok((answer == correctAnswer), "isPalindrome number 3 failed"); + + console.log("isPalindrome passed"); +} + +export function testFindNumOccurrences(){ + //Test 1 + let str: string = "101"; + let correctAnswer: boolean = true; + let answer = isPalindrome(str); + assert.ok((answer == correctAnswer), "findNumOccurrences 1 failed"); + //Test 2 + str = "100"; + correctAnswer = false; + answer = isPalindrome(str); + assert.ok((answer == correctAnswer), "findNumOccurrences 2 failed"); + //Test 3 + str = ""; + correctAnswer = true; + answer = isPalindrome(str); + assert.ok((answer == correctAnswer), "findNumOccurrences 3 failed"); + + console.log("findNumOccurrences passed"); +}