docs: fix typos (TheAlgorithms#1283)

Lioness100 · web-flow · commit 002b10a5aa0b · 2023-02-07T22:20:28.000+05:30
* docs: fix typos

* fix
diff --git a/Cache/Memoize.js b/Cache/Memoize.js
@@ -30,7 +30,7 @@ const memoize = (func, cache = new Map()) =>{
 /**
 * Arguments converted to JSON string for use as a key of Map - it's easy to detect collections like -> Object and Array
 * If the args input is -> [new Set([1, 2, 3, 4]),{name: 'myName', age: 23}]
- * Then the agrsKey generate to -> '[[1,2,3,4],{"name":"myName","age":23}]' which is JSON mean string
+ * Then the argsKey generate to -> '[[1,2,3,4],{"name":"myName","age":23}]' which is JSON mean string
 * Now it's ready to be a perfect key for Map
 */
 const argsKey = JSON.stringify(args, jsonReplacer)
diff --git a/Ciphers/test/AffineCipher.test.js b/Ciphers/test/AffineCipher.test.js
@@ -19,7 +19,7 @@ describe('Test Affine Cipher', () =>{
 expect(() => encrypt('null', 4, 1)).toThrow()
 })
 
- it('Test - 3 Pass string value to encrypt and ecrypt function', () =>{
+ it('Test - 3 Pass string value to encrypt and decrypt function', () =>{
 expect(decrypt(encrypt('HELLO WORLD', 5, 8), 5, 8)).toBe('HELLO WORLD')
 expect(decrypt(encrypt('ABC DEF', 3, 5), 3, 5)).toBe('ABC DEF')
 expect(decrypt(encrypt('Brown fox jump over the fence', 7, 3), 7, 3)).toBe(
diff --git a/Ciphers/test/KeywordShiftedAlphabet.test.js b/Ciphers/test/KeywordShiftedAlphabet.test.js
@@ -1,12 +1,12 @@
 import{encrypt, decrypt } from '../KeywordShiftedAlphabet'
 
-test('Hello world! === dcrypt(encrypt(Hello world!))', () =>{
+test('Hello world! === decrypt(encrypt(Hello world!))', () =>{
 const word = 'Hello world!'
 const result = decrypt('keyword', encrypt('keyword', word))
 expect(result).toMatch(word)
 })
 
-test('The Algorithms === dcrypt(encrypt(The Algorithms))', () =>{
+test('The Algorithms === decrypt(encrypt(The Algorithms))', () =>{
 const word = 'The Algorithms'
 const result = decrypt('keyword', encrypt('keyword', word))
 expect(result).toMatch(word)
diff --git a/Ciphers/test/VigenereCipher.test.js b/Ciphers/test/VigenereCipher.test.js
@@ -1,12 +1,12 @@
 import{encrypt, decrypt } from '../VigenereCipher'
 
-test('Hello world! === dcrypt(encrypt(Hello world!))', () =>{
+test('Hello world! === decrypt(encrypt(Hello world!))', () =>{
 const word = 'Hello world!'
 const result = decrypt(encrypt(word, 'code'), 'code')
 expect(result).toMatch(word)
 })
 
-test('The Algorithms === dcrypt(encrypt(The Algorithms))', () =>{
+test('The Algorithms === decrypt(encrypt(The Algorithms))', () =>{
 const word = 'The Algorithms'
 const result = decrypt(encrypt(word, 'code'), 'code')
 expect(result).toMatch(word)
diff --git a/Conversions/BinaryToHex.js b/Conversions/BinaryToHex.js
@@ -29,7 +29,7 @@ const hexLookup = (bin) =>{
 }
 const binaryToHex = (binaryString) =>{
 /*
- Function for convertung Binary to Hex
+ Function for converting Binary to Hex
 
 1. The conversion will start from Least Significant Digit (LSB) to the Most Significant Bit (MSB).
 2. We divide the bits into sections of 4-bits starting from LSB to MSB.
diff --git a/Conversions/RailwayTimeConversion.js b/Conversions/RailwayTimeConversion.js
@@ -21,9 +21,9 @@ const RailwayTimeConversion = (timeString) =>{
 return new TypeError('Argument is not a string.')
 }
 // split the string by ':' character.
- const [hour, minute, scondWithShift] = timeString.split(':')
+ const [hour, minute, secondWithShift] = timeString.split(':')
 // split second and shift value.
- const [second, shift] = [scondWithShift.substr(0, 2), scondWithShift.substr(2)]
+ const [second, shift] = [secondWithShift.substr(0, 2), secondWithShift.substr(2)]
 // convert shifted time to not-shift time(Railway time) by using the above explanation.
 if (shift === 'PM'){
 if (parseInt(hour) === 12){return `${hour}:${minute}:${second}` } else{return `${parseInt(hour) + 12}:${minute}:${second}` }
diff --git a/Conversions/test/TemperatureConversion.test.js b/Conversions/test/TemperatureConversion.test.js
@@ -80,19 +80,19 @@ describe('Testing Conversion of Rankine to Kelvin', () =>{
 expect(test1).toBe(6)
 })
 })
-describe('Testing Conversion of Reamur to Celsius', () =>{
- it('with Reamur value', () =>{
+describe('Testing Conversion of Reaumur to Celsius', () =>{
+ it('with Reaumur value', () =>{
 const test1 = tc.reaumurToCelsius(100)
 expect(test1).toBe(125)
 })
 })
-describe('Testing Conversion of Reamur to Fahrenheit', () =>{
- it('with Reamur value', () =>{
+describe('Testing Conversion of Reaumur to Fahrenheit', () =>{
+ it('with Reaumur value', () =>{
 const test1 = tc.reaumurToFahrenheit(100)
 expect(test1).toBe(257)
 })
 })
-describe('Testing Conversion of Reamur to Kelvin', () =>{
+describe('Testing Conversion of Reaumur to Kelvin', () =>{
 it('with Reamur value', () =>{
 const test1 = tc.reaumurToKelvin(100)
 expect(test1).toBe(398)
diff --git a/Data-Structures/Array/LocalMaximomPoint.js b/Data-Structures/Array/LocalMaximomPoint.js
@@ -3,7 +3,7 @@
 *
 * Notes:
 * - works by using divide and conquer
- * - the function gets the array A with n Real numbersand returns the local max point index (if more than one exists return the first one)
+ * - the function gets the array A with n Real numbers and returns the local max point index (if more than one exists return the first one)
 *
 * @complexity: O(log(n)) (on average )
 * @complexity: O(log(n)) (worst case)
diff --git a/Data-Structures/Tree/Trie.js b/Data-Structures/Tree/Trie.js
@@ -83,8 +83,8 @@ Trie.prototype.remove = function (word, count){
 if (child.count >= count) child.count -= count
 else child.count = 0
 
- // If some occurrences are left we dont delete it or else
- // if the object forms some other objects prefix we dont delete it
+ // If some occurrences are left we don't delete it or else
+ // if the object forms some other objects prefix we don't delete it
 // For checking an empty object
 // https://stackoverflow.com/questions/679915/how-do-i-test-for-an-empty-javascript-object
 if (child.count <= 0 && (Object.keys(child.children).length && child.children.constructor === Object)){
@@ -110,7 +110,7 @@ Trie.prototype.contains = function (word){
 return true
 }
 
-Trie.prototype.findOccurences = function (word){
+Trie.prototype.findOccurrences = function (word){
 // find the node with given prefix
 const node = this.findPrefix(word)
 // No such word exists
diff --git a/Dynamic-Programming/KadaneAlgo.js b/Dynamic-Programming/KadaneAlgo.js
@@ -1,6 +1,6 @@
 /* Kadane's algorithm is one of the most efficient ways to
 * calculate the maximum contiguous subarray sum for a given array.
- * Below is the implementation of kadanes's algorithm along with
+ * Below is the implementation of Kadane's algorithm along with
 * some sample test cases.
 * There might be a special case in this problem if al the elements
 * of the given array are negative. In such a case, the maximum negative
@@ -10,14 +10,14 @@
 */
 
 export function kadaneAlgo (array){
- let cummulativeSum = 0
+ let cumulativeSum = 0
 let maxSum = Number.NEGATIVE_INFINITY // maxSum has the least possible value
 for (let i = 0; i < array.length; i++){
- cummulativeSum = cummulativeSum + array[i]
- if (maxSum < cummulativeSum){
- maxSum = cummulativeSum
- } else if (cummulativeSum < 0){
- cummulativeSum = 0
+ cumulativeSum = cumulativeSum + array[i]
+ if (maxSum < cumulativeSum){
+ maxSum = cumulativeSum
+ } else if (cumulativeSum < 0){
+ cumulativeSum = 0
 }
 }
 return maxSum
diff --git a/Dynamic-Programming/UniquePaths2.js b/Dynamic-Programming/UniquePaths2.js
@@ -63,7 +63,7 @@ const uniquePaths2 = (obstacles) =>{
 grid[0][j] = 1
 }
 // Fill the rest of grid by dynamic programming
- // using following reccurent formula:
+ // using following recurrent formula:
 // K[i][j] = K[i - 1][j] + K[i][j - 1]
 for (let i = 1; i < rows; i++){
 for (let j = 1; j < columns; j++){
diff --git a/Geometry/Circle.js b/Geometry/Circle.js
@@ -2,7 +2,7 @@
 * This class represents a circle and can calculate it's perimeter and area
 * https://en.wikipedia.org/wiki/Circle
 * @constructor
- * @param{number} radius - The radius of the circule.
+ * @param{number} radius - The radius of the circle.
 */
 export default class Circle{
 constructor (radius){
diff --git a/Graphs/BinaryLifting.js b/Graphs/BinaryLifting.js
@@ -3,7 +3,7 @@
 * Binary Lifting implementation in Javascript
 * Binary Lifting is a technique that is used to find the kth ancestor of a node in a rooted tree with N nodes
 * The technique requires preprocessing the tree in O(N log N) using dynamic programming
- * The techniqe can answer Q queries about kth ancestor of any node in O(Q log N)
+ * The technique can answer Q queries about kth ancestor of any node in O(Q log N)
 * It is faster than the naive algorithm that answers Q queries with complexity O(Q K)
 * It can be used to find Lowest Common Ancestor of two nodes in O(log N)
 * Tutorial on Binary Lifting: https://codeforces.com/blog/entry/100826
diff --git a/Graphs/LCABinaryLifting.js b/Graphs/LCABinaryLifting.js
@@ -1,6 +1,6 @@
 /**
 * Author: Adrito Mukherjee
- * Findind Lowest Common Ancestor By Binary Lifting implementation in JavaScript
+ * Finding Lowest Common Ancestor By Binary Lifting implementation in JavaScript
 * The technique requires preprocessing the tree in O(N log N) using dynamic programming)
 * It can be used to find Lowest Common Ancestor of two nodes in O(log N)
 * Tutorial on Lowest Common Ancestor: https://www.geeksforgeeks.org/lca-in-a-tree-using-binary-lifting-technique
diff --git a/Maths/BinomialCoefficient.js b/Maths/BinomialCoefficient.js
@@ -7,7 +7,7 @@
 
 /**
 * @function findBinomialCoefficient
- * @description -> this function returns bonimial coefficient
+ * @description -> this function returns binomial coefficient
 * of two numbers n & k given by n!/((n-k)!k!)
 * @param{number} n
 * @param{number} k
diff --git a/Maths/CheckKishnamurthyNumber.js b/Maths/CheckKishnamurthyNumber.js
@@ -37,7 +37,7 @@ const CheckKishnamurthyNumber = (number) =>{
 sumOfAllDigitFactorial += factorial(lastDigit)
 newNumber = Math.floor(newNumber / 10)
 }
- // if the sumOftheFactorial is equal to the given number it means the number is a Krishnamurthy number.
+ // if the sumOfAllDigitFactorial is equal to the given number it means the number is a Krishnamurthy number.
 return sumOfAllDigitFactorial === number
 }
 
diff --git a/Maths/ExtendedEuclideanGCD.js b/Maths/ExtendedEuclideanGCD.js
@@ -1,7 +1,7 @@
 /**
 * Problem statement and explanation: https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
 *
- * This algorithm plays an important role for modular arithmetic, and by extension for cyptography algorithms
+ * This algorithm plays an important role for modular arithmetic, and by extension for cryptography algorithms
 *
 * Basic explanation:
 * The Extended Euclidean algorithm is a modification of the standard Euclidean GCD algorithm.
diff --git a/Maths/FermatPrimalityTest.js b/Maths/FermatPrimalityTest.js
@@ -21,7 +21,7 @@
 * 1 / 2^50 = 8.8 * 10^-16 (a pretty small number)
 *
 * For comparison, the probability of a cosmic ray causing an error to your
- * infalible program is around 1.4 * 10^-15. An order of magnitude below!
+ * infallible program is around 1.4 * 10^-15. An order of magnitude below!
 *
 * But because nothing is perfect, there's a major flaw to this algorithm, and
 * the cause are the so called Carmichael Numbers. These are composite numbers n
diff --git a/Maths/test/MeanAbsoluteDeviation.test.js b/Maths/test/MeanAbsoluteDeviation.test.js
@@ -9,7 +9,7 @@ describe('tests for mean absolute deviation', () =>{
 expect(() => meanAbsoluteDeviation('fgh')).toThrow()
 })
 
- it('should return the mean absolute devition of an array of numbers', () =>{
+ it('should return the mean absolute deviation of an array of numbers', () =>{
 const meanAbDev = meanAbsoluteDeviation([2, 34, 5, 0, -2])
 expect(meanAbDev).toBe(10.479999999999999)
 })
diff --git a/Project-Euler/Problem003.js b/Project-Euler/Problem003.js
@@ -1,18 +1,18 @@
 // https://projecteuler.net/problem=3
 
 export const largestPrime = (num = 600851475143) =>{
- let newnumm = num
+ let newnum = num
 let largestFact = 0
 let counter = 2
- while (counter * counter <= newnumm){
- if (newnumm % counter === 0){
- newnumm = newnumm / counter
+ while (counter * counter <= newnum){
+ if (newnum % counter === 0){
+ newnum = newnum / counter
 } else{
 counter++
 }
 }
- if (newnumm > largestFact){
- largestFact = newnumm
+ if (newnum > largestFact){
+ largestFact = newnum
 }
 return largestFact
 }
diff --git a/Project-Euler/Problem008.js b/Project-Euler/Problem008.js
@@ -2,11 +2,11 @@
 
 const largestAdjacentNumber = (grid, consecutive) =>{
 grid = grid.split('\n').join('')
- const splitedGrid = grid.split('\n')
+ const splitGrid = grid.split('\n')
 let largestProd = 0
 
- for (const row in splitedGrid){
- const currentRow = splitedGrid[row].split('').map(x => Number(x))
+ for (const row in splitGrid){
+ const currentRow = splitGrid[row].split('').map(x => Number(x))
 
 for (let i = 0; i < currentRow.length - consecutive; i++){
 const combine = currentRow.slice(i, i + consecutive)
diff --git a/Project-Euler/Problem023.js b/Project-Euler/Problem023.js
@@ -14,7 +14,7 @@
 */
 
 /**
- * collect the abundant numbers, generate and store their sums with each other, and check for numbers not in the llst of sums, adds them and returns their sum.
+ * collect the abundant numbers, generate and store their sums with each other, and check for numbers not in the list of sums, adds them and returns their sum.
 * @param{number} [n = 28123]
 * @returns{number}
 */
diff --git a/Project-Euler/Problem028.js b/Project-Euler/Problem028.js
@@ -40,7 +40,7 @@ function problem28 (dim){
 * Third corner: i^2 - 2 * (i - 1)
 * Fourth corner: i^2 - 3 * (i - 1)
 *
- * Doing the sum of each corner and simplifing, we found that the result for each dimension is:
+ * Doing the sum of each corner and simplifying, we found that the result for each dimension is:
 * sumDim = 4 * i^2 + 6 * (1 - i)
 *
 * In this case I skip the 1x1 dim matrix because is trivial, that's why I start in a 3x3 matrix
diff --git a/Sorts/IntroSort.js b/Sorts/IntroSort.js
@@ -1,5 +1,5 @@
 /**
- * @function Intosort (As implemented in STD C++ Lib)
+ * @function Introsort (As implemented in STD C++ Lib)
 * The function performs introsort which is used in
 * C++ Standard LIbrary, the implementation is inspired from]
 * library routine itself.
@@ -88,7 +88,7 @@ function introsort (array, compare){
 const THRESHOLD = 16
 /**
 * @constant TUNEMAXDEPTH
- * Constant usec to increase or decrease value
+ * Constant used to increase or decrease value
 * of maxDepth
 */
 const TUNEMAXDEPTH = 1

-Original file line number
+Diff line change
 expect(()=>encrypt('null',4,1)).toThrow()
 })
 -it('Test - 3 Pass string value to encrypt and ecrypt function',()=>{
 +it('Test - 3 Pass string value to encrypt and decrypt function',()=>{
 expect(decrypt(encrypt('HELLO WORLD',5,8),5,8)).toBe('HELLO WORLD')
 expect(decrypt(encrypt('ABC DEF',3,5),3,5)).toBe('ABC DEF')
 expect(decrypt(encrypt('Brown fox jump over the fence',7,3),7,3)).toBe(
-Original file line number
+Diff line change
@@ @@ -1,12 +1,12 @@ @@
 import{encrypt,decrypt}from'../KeywordShiftedAlphabet'
 -test('Hello world! === dcrypt(encrypt(Hello world!))',()=>{
 +test('Hello world! === decrypt(encrypt(Hello world!))',()=>{
 constword='Hello world!'
 constresult=decrypt('keyword',encrypt('keyword',word))
 expect(result).toMatch(word)
 })
 -test('The Algorithms === dcrypt(encrypt(The Algorithms))',()=>{
 +test('The Algorithms === decrypt(encrypt(The Algorithms))',()=>{
 constword='The Algorithms'
 constresult=decrypt('keyword',encrypt('keyword',word))
 expect(result).toMatch(word)
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ const hexLookup = (bin) =>{`
`29`	`29`	`}`
`30`	`30`	`constbinaryToHex=(binaryString)=>{`
`31`	`31`	`/*`
`32`		`- Function for convertung Binary to Hex`
	`32`	`+ Function for converting Binary to Hex`
`33`	`33`
`34`	`34`	`1. The conversion will start from Least Significant Digit (LSB) to the Most Significant Bit (MSB).`
`35`	`35`	`2. We divide the bits into sections of 4-bits starting from LSB to MSB.`
-Original file line number
+Diff line change
 returnnewTypeError('Argument is not a string.')
+}
 // split the string by ':' character.
 -const[hour,minute,scondWithShift]=timeString.split(':')
 +const[hour,minute,secondWithShift]=timeString.split(':')
 // split second and shift value.
 -const[second,shift]=[scondWithShift.substr(0,2),scondWithShift.substr(2)]
 +const[second,shift]=[secondWithShift.substr(0,2),secondWithShift.substr(2)]
 // convert shifted time to not-shift time(Railway time) by using the above explanation.
 if(shift==='PM'){
 if(parseInt(hour)===12){return`${hour}:${minute}:${second}`}else{return`${parseInt(hour)+12}:${minute}:${second}`}
-Original file line number
+Diff line change
 expect(test1).toBe(6)
 })
 })
 -describe('Testing Conversion of Reamur to Celsius',()=>{
 -it('with Reamur value',()=>{
 +describe('Testing Conversion of Reaumur to Celsius',()=>{
 +it('with Reaumur value',()=>{
 consttest1=tc.reaumurToCelsius(100)
 expect(test1).toBe(125)
 })
 })
 -describe('Testing Conversion of Reamur to Fahrenheit',()=>{
 -it('with Reamur value',()=>{
 +describe('Testing Conversion of Reaumur to Fahrenheit',()=>{
 +it('with Reaumur value',()=>{
 consttest1=tc.reaumurToFahrenheit(100)
 expect(test1).toBe(257)
 })
 })
 -describe('Testing Conversion of Reamur to Kelvin',()=>{
 +describe('Testing Conversion of Reaumur to Kelvin',()=>{
 it('with Reamur value',()=>{
 consttest1=tc.reaumurToKelvin(100)
 expect(test1).toBe(398)
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`*`
`4`	`4`	`* Notes:`
`5`	`5`	`* - works by using divide and conquer`
`6`		`- * - the function gets the array A with n Real numbersand returns the local max point index (if more than one exists return the first one)`
	`6`	`+ * - the function gets the array A with n Real numbers and returns the local max point index (if more than one exists return the first one)`
`7`	`7`	`*`
`8`	`8`	`* @complexity: O(log(n)) (on average )`
`9`	`9`	`* @complexity: O(log(n)) (worst case)`
-Original file line number
+Diff line change
@@ @@ -1,6 +1,6 @@ @@
 /* Kadane's algorithm is one of the most efficient ways to
  * calculate the maximum contiguous subarray sum for a given array.
 - * Below is the implementation of kadanes's algorithm along with
 + * Below is the implementation of Kadane's algorithm along with
  * some sample test cases.
  * There might be a special case in this problem if al the elements
  * of the given array are negative. In such a case, the maximum negative
  */
 exportfunctionkadaneAlgo(array){
 -letcummulativeSum=0
 +letcumulativeSum=0
 letmaxSum=Number.NEGATIVE_INFINITY// maxSum has the least possible value
 for(leti=0;i<array.length;i++){
 -cummulativeSum=cummulativeSum+array[i]
 -if(maxSum<cummulativeSum){
 -maxSum=cummulativeSum
 -}elseif(cummulativeSum<0){
 -cummulativeSum=0
 +cumulativeSum=cumulativeSum+array[i]
 +if(maxSum<cumulativeSum){
 +maxSum=cumulativeSum
 +}elseif(cumulativeSum<0){
 +cumulativeSum=0
+}
+}
 returnmaxSum