Fix spellings

.github/workflows/ci.yml

@@ -20,11 +20,4 @@ jobs:
 
       - name: 💄 Code style
         run: npm run style
-  codespell:
-    name: Check for spelling errors
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: codespell-project/actions-codespell@master
-        with:
-          check_filenames: true      
+

.github/workflows/codespell.yml

@@ -0,0 +1,13 @@
+name: codespell
+on: [push, pull_request]
+jobs:
+  codespell:
+    name: Check for spelling errors
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: codespell-project/actions-codespell@master
+        with:
+          # file types to ignore
+          skip: "*.json,*.yml,DIRECTORY.md,PermutateString.test.js,SubsequenceRecursive.js"
+

Backtracking/AllCombinationsOfSizeK.js

@@ -2,7 +2,7 @@
   Problem: Given two numbers, n and k, make all unique combinations of k numbers from 1 to n and in sorted order
 
   What is combinations?
-  - Combinations is selecting items froms a collections without considering order of selection
+  - Combinations is selecting items from a collections without considering order of selection
 
   Example:
   - We have an apple, a banana, and a jackfruit

Conversions/RailwayTimeConversion.js

@@ -4,8 +4,8 @@
     some changes on hours and minutes and if the time in 'PM' it means the only
     want some changes in hour value.
 
-    Input Formate -> 07:05:45PM
-    Output Formate -> 19:05:45
+    Input Format -> 07:05:45PM
+    Output Format -> 19:05:45
 
     Problem & Explanation Source : https://www.mathsisfun.com/time.html
 */

Conversions/TemperatureConversion.js

@@ -1,5 +1,5 @@
 // This files has functions to convert different temperature units
-// Functions take temperature value as a arguement and returns corresponding converted value
+// Functions take temperature value as a argument and returns corresponding converted value
 
 const celsiusToFahrenheit = (celsius) => {
   // Wikipedia reference: https://en.wikipedia.org/wiki/Celsius
@@ -40,7 +40,7 @@ const fahrenheitToRankine = (fahrenheit) => {
 const kelvinToCelsius = (kelvin) => {
   // Wikipedia reference: https://en.wikipedia.org/wiki/Kelvin
   // Wikipedia reference: https://en.wikipedia.org/wiki/Celsius
-  return Math.round((kelvin) - 273.15)
+  return Math.round((kelvin) - 273.15)
 }
 
 const kelvinToFahrenheit = (kelvin) => {

DIRECTORY.md

@@ -135,12 +135,6 @@
   * [SHA1](https://github.com/TheAlgorithms/Javascript/blob/master/Hashes/SHA1.js)
   * [SHA256](https://github.com/TheAlgorithms/Javascript/blob/master/Hashes/SHA256.js)
 
-## Linear-Algebra
-  * src
-    * [la_lib](https://github.com/TheAlgorithms/Javascript/blob/master/Linear-Algebra/src/la_lib.js)
-  * test
-    * [test](https://github.com/TheAlgorithms/Javascript/blob/master/Linear-Algebra/test/test.js)
-
 ## Maths
   * [Abs](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/Abs.js)
   * [AliquotSum](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/AliquotSum.js)
@@ -197,6 +191,7 @@
   * [ReverseNumber](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/ReverseNumber.js)
   * [ReversePolishNotation](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/ReversePolishNotation.js)
   * [SieveOfEratosthenes](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/SieveOfEratosthenes.js)
+  * [SimpsonIntegration](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/SimpsonIntegration.js)
   * [Softmax](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/Softmax.js)
   * [SquareRoot](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/SquareRoot.js)
   * [SumOfDigits](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/SumOfDigits.js)

Data-Structures/Array/NumberOfLocalMaximumPoints.js

@@ -2,7 +2,7 @@
  * [NumberOfLocalMaximumPoints](https://www.geeksforgeeks.org/find-indices-of-all-local-maxima-and-local-minima-in-an-array/) is an algorithm to find relative bigger numbers compared to their neighbors
  *
  * Notes:
- * - like the other similar local maxima search function find relative maxima points in array but doesnt stop at one but returns total point count
+ * - like the other similar local maxima search function find relative maxima points in array but doesn't stop at one but returns total point count
  * - runs on array A of size n and returns the local maxima count using divide and conquer methodology
  *
  * @complexity: O(n) (on average )

Data-Structures/Array/test/LocalMaximomPoint.test.js

@@ -1,17 +1,17 @@
 import { LocalMaximomPoint } from '../LocalMaximomPoint'
 
-describe('LocalMaximomPoint tests', () => {
-  it('test boundry maximom points - last element', () => {
+describe('LocalMaximumPoint tests', () => {
+  it('test boundary maximum points - last element', () => {
     const Array = [1, 2, 3, 4, 5, 6, 12]
     expect(LocalMaximomPoint(Array)).toEqual(6)
   })
 
-  it('test boundry maximom points - first element', () => {
+  it('test boundary maximum points - first element', () => {
     const Array2 = [13, 6, 5, 4, 3, 2, 1]
     expect(LocalMaximomPoint(Array2)).toEqual(0)
   })
 
-  it('test boundry maximom points - should find first maximom point from the top', () => {
+  it('test boundary maximum points - should find first maximom point from the top', () => {
     // Test a mix of number types (i.e., positive/negative, numbers with decimals, fractions)
     const Array = [13, 2, 3, 4, 5, 6, 12]
     expect(LocalMaximomPoint(Array)).toEqual(6)

Data-Structures/Array/test/NumberOfLocalMaximumPoints.test.js

@@ -1,41 +1,41 @@
 import { NumberOfLocalMaximumPoints } from '../NumberOfLocalMaximumPoints'
 
 describe('LocalMaximomPoint tests', () => {
-  it('test boundry maximom points - last element', () => {
+  it('test boundary maximum points - last element', () => {
     const Array = [1, 2, 3, 4, 5, 6, 12]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(1)
   })
 
-  it('test boundry maximom points - first element', () => {
+  it('test boundary maximum points - first element', () => {
     const Array = [13, 6, 5, 4, 3, 2, 1]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(1)
   })
 
-  it('test boundry maximom points - both boundries have maximum points', () => {
+  it('test boundary maximum points - both boundaries have maximum points', () => {
     // Test a mix of number types (i.e., positive/negative, numbers with decimals, fractions)
     const Array = [13, 2, 3, 4, 5, 6, 12]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(2)
   })
 
-  it('multiple maximom points in the middle', () => {
+  it('multiple maximum points in the middle', () => {
     // Test a mix of number types (i.e., positive/negative, numbers with decimals, fractions)
     const Array = [1, 3, 2, 5, 6, 9, 2, 7, 12, 1, 0]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(3)
   })
 
-  it('multiple maximom points in the middle with one at end', () => {
+  it('multiple maximum points in the middle with one at end', () => {
     // Test a mix of number types (i.e., positive/negative, numbers with decimals, fractions)
     const Array = [1, 3, 2, 5, 6, 9, 2, 7, 12, 1, 10]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(4)
   })
 
-  it('multiple maximom points in the middle with one at start', () => {
+  it('multiple maximum points in the middle with one at start', () => {
     // Test a mix of number types (i.e., positive/negative, numbers with decimals, fractions)
     const Array = [10, 3, 2, 5, 6, 9, 2, 7, 12, 1, 0]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(3)
   })
 
-  it('multiple maximom points in the middle with two more at both ends', () => {
+  it('multiple maximum points in the middle with two more at both ends', () => {
     // Test a mix of number types (i.e., positive/negative, numbers with decimals, fractions)
     const Array = [10, 3, 11, 5, 6, 9, 2, 7, 12, 1, 10]
     expect(NumberOfLocalMaximumPoints(Array)).toEqual(5)

Data-Structures/Heap/MinPriorityQueue.js

@@ -57,7 +57,7 @@ class MinPriorityQueue {
     output(this.heap.slice(1))
   }
 
-  // heap reverse can be done by performing swaping the first
+  // heap reverse can be done by performing swapping the first
   // element with the last, removing the last element to
   // new array and calling sink function.
   heapReverse () {

Dynamic-Programming/KadaneAlgo.js

@@ -1,5 +1,5 @@
 /* Kadane's algorithm is one of the most efficient ways to
- * calculate the maximum contiguos subarray sum for a given array.
+ * calculate the maximum contiguous subarray sum for a given array.
  * Below is the implementation of kadanes's algorithm along with
  * some sample test cases.
  * There might be a special case in this problem if al the elements
@@ -11,7 +11,7 @@
 
 export function kadaneAlgo (array) {
   let cummulativeSum = 0
-  let maxSum = Number.NEGATIVE_INFINITY // maxSum has the least posible value
+  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) {

Dynamic-Programming/MaxNonAdjacentSum.js

@@ -19,7 +19,7 @@ function maximumNonAdjacentSum (nums) {
   return Math.max(maxExcluding, maxIncluding)
 }
 
-// Exmaple
+// Example
 
 // maximumNonAdjacentSum([1, 2, 3]))
 // maximumNonAdjacentSum([1, 5, 3, 7, 2, 2, 6]))

Dynamic-Programming/SieveOfEratosthenes.js

@@ -1,7 +1,7 @@
 function sieveOfEratosthenes (n) {
   /*
      * Calculates prime numbers till a number n
-     * :param n: Number upto which to calculate primes
+     * :param n: Number up to which to calculate primes
      * :return: A boolean list containing only primes
      */
   const primes = new Array(n + 1)

Hashes/SHA1.js

@@ -34,7 +34,7 @@ function pad (str, bits) {
  * @return {array} - array of original string split into chunks
  *
  * @example
- *      chunkify("this is a test", 2); // ["th", "is", " i", "s ", "a ", "te", "st"]
+ *      chunkify("this is a test", 2)
  */
 function chunkify (str, size) {
   const chunks = []

Hashes/SHA256.js

@@ -45,7 +45,7 @@ function pad (str, bits) {
  * @return {array} - array of original string split into chunks
  *
  * @example
- *      chunkify("this is a test", 2); // ["th", "is", " i", "s ", "a ", "te", "st"]
+ *      chunkify("this is a test", 2)
  */
 function chunkify (str, size) {
   const chunks = []
@@ -76,7 +76,7 @@ function rotateRight (bits, turns) {
  * @return {string} - processed message
  */
 function preProcess (message) {
-  // covert message to binary representation padded to
+  // convert message to binary representation padded to
   // 8 bits, and add 1
   let m = message.split('')
     .map(e => e.charCodeAt(0))