Merge pull request #88 from PatOnTheBack/master

Improved JSLint Compliance and Created Math Algorithms

Algorithms/EucledianGCD.js

@@ -1,37 +1,37 @@
-function euclideanGCDRecursive (first, second) {
+function euclideanGCDRecursive(first, second) {
-	/*
+    /*
-	Calculates GCD of two numbers using Euclidean Recursive Algorithm
+    Calculates GCD of two numbers using Euclidean Recursive Algorithm
-	:param first: First number
+    :param first: First number
-	:param second: Second number
+    :param second: Second number
-	:return: GCD of the numbers
+    :return: GCD of the numbers
-	*/
+    */
-	if (second == 0) {
+    if (second === 0) {
-		return first;
+        return first;
-	} else {
+    } else {
-		return euclideanGCDRecursive(second, (first % second));
+        return euclideanGCDRecursive(second, (first % second));
-	}
+    }
 }
 
-function euclideanGCDIterative (first, second) {
+function euclideanGCDIterative(first, second) {
-	/*
+    /*
-	Calculates GCD of two numbers using Euclidean Iterative Algorithm
+    Calculates GCD of two numbers using Euclidean Iterative Algorithm
-	:param first: First number
+    :param first: First number
-	:param second: Second number
+    :param second: Second number
-	:return: GCD of the numbers
+    :return: GCD of the numbers
-	*/
+    */
-	while (second != 0) {
+    while (second !== 0) {
-		let temp = second;
+        let temp = second;
-		second = first % second;
+        second = first % second;
-		first = temp;
+        first = temp;
-	}
+    }
-	return first;
+    return first;
 }
 
-function main () {
+function main() {
-	let first = 20;
+    let first = 20;
-	let second = 30;
+    let second = 30;
-	console.log('Recursive GCD for %d and %d is %d', first, second, euclideanGCDRecursive(first, second));
+    console.log('Recursive GCD for %d and %d is %d', first, second, euclideanGCDRecursive(first, second));
-	console.log('Iterative GCD for %d and %d is %d', first, second, euclideanGCDIterative(first, second));
+    console.log('Iterative GCD for %d and %d is %d', first, second, euclideanGCDIterative(first, second));
 }
 
 main();

Algorithms/sieveOfEratosthenes.js

@@ -1,31 +1,31 @@
-function sieveOfEratosthenes (n) {
+function sieveOfEratosthenes(n) {
-	/*
+    /*
-	* Calculates prime numbers till a number n
+     * Calculates prime numbers till a number n
-	* :param n: Number upto which to calculate primes
+     * :param n: Number upto which to calculate primes
-	* :return: A boolean list contaning only primes
+     * :return: A boolean list contaning only primes
-	*/
+     */
-	let primes = new Array(n + 1);
+    let primes = new Array(n + 1);
-	primes.fill(true);  // set all as true initially
+    primes.fill(true); // set all as true initially
-	primes[0] = primes[1] = false;  // Handling case for 0 and 1
+    primes[0] = primes[1] = false; // Handling case for 0 and 1
-	let sqrtn = Math.ceil(Math.sqrt(n));
+    let sqrtn = Math.ceil(Math.sqrt(n));
-	for (let i = 2; i <= sqrtn; i++) {
+    for (let i = 2; i <= sqrtn; i++) {
-		if (primes[i]) {
+        if (primes[i]) {
-			for (let j = 2 * i; j <= n; j += i) {
+            for (let j = 2 * i; j <= n; j += i) {
-				primes[j] = false;
+                primes[j] = false;
-			}
+            }
-		}
+        }
-	}
+    }
-	return primes;
+    return primes;
 }
 
-function main () {
+function main() {
-	let n = 69; // number till where we wish to find primes
+    let n = 69; // number till where we wish to find primes
-	let primes = sieveOfEratosthenes(n);
+    let primes = sieveOfEratosthenes(n);
-	for (let i = 2; i <= n; i++) {
+    for (let i = 2; i <= n; i++) {
-		if (primes[i]) {
+        if (primes[i]) {
-			console.log(i);
+            console.log(i);
-		}
+        }
-	}
+    }
 }
 
 main();

Ciphers/caesarsCipher.js

@@ -1,6 +1,6 @@
 /**
  * Caesar's Cipher - also known as the ROT13 Cipher is when
- * a letter is replaced by the one that is 13 spaces away 
+ * a letter is replaced by the one that is 13 spaces away
  * from it in the alphabet. If the letter is in the first half
  * of the alphabet we add 13, if it's in the latter half we
  * subtract 13 from the character code value.
@@ -12,27 +12,27 @@
  * @return {String} decrypted string
  */
 function rot13(str) {
-  let response = [];
+    let response = [];
-  let strLength = str.length;
+    let strLength = str.length;
 
-  for (let i =0; i < strLength; i++) {
+    for (let i = 0; i < strLength; i++) {
-    const char = str.charCodeAt(i);
+        const char = str.charCodeAt(i);
+
+        if (char < 65 || (char > 90 && char < 97) || char > 122) {
+            response.push(str.charAt(i));
+        } else if ((char > 77 && char <= 90) || (char > 109 && char <= 122)) {
+            response.push(String.fromCharCode(str.charCodeAt(i) - 13));
+        } else {
+            response.push(String.fromCharCode(str.charCodeAt(i) + 13));
+        }
 
-    if (char < 65 || (char > 90 && char < 97) || char > 122) {
-      response.push(str.charAt(i));
-    } else if ((char > 77 && char <= 90 ) || (char > 109 && char <= 122)) {
-      response.push(String.fromCharCode(str.charCodeAt(i) - 13));
-    } else {
-      response.push(String.fromCharCode(str.charCodeAt(i) + 13));
     }
-    
+    return response.join("");
-  }
-  return response.join('');
 }
 
 
 // Caesars Cipher Example
-const encryptedString = 'Uryyb Jbeyq';
+const encryptedString = "Uryyb Jbeyq";
 const decryptedString = rot13(encryptedString);
 
-console.log(decryptedString); // Hello World
+console.log(decryptedString); // Hello World

Conversions/DecimalToBinary.js

@@ -4,7 +4,7 @@ function decimalToBinary(num) {
   bin.unshift(num % 2);
   num >>= 1; // basically /= 2 without remainder if any
   }
-  console.log("The decimal in binary is " + bin.join(''));
+  console.log("The decimal in binary is " + bin.join(""));
 }
 
 decimalToBinary(2);

Search/binarySearch.js

@@ -1,27 +1,27 @@
 /*Binary Search-Search a sorted array by repeatedly dividing the search interval
-* in half. Begin with an interval covering the whole array. If the value of the
+ * in half. Begin with an interval covering the whole array. If the value of the
-* search key is less than the item in the middle of the interval, narrow the interval
+ * search key is less than the item in the middle of the interval, narrow the interval
-* to the lower half. Otherwise narrow it to the upper half. Repeatedly check until the
+ * to the lower half. Otherwise narrow it to the upper half. Repeatedly check until the
-* value is found or the interval is empty.
+ * value is found or the interval is empty.
-*/
+ */
 
 function binarySearch(arr, i) {
     var mid = Math.floor(arr.length / 2);
     if (arr[mid] === i) {
-        console.log('match', arr[mid], i);
+        console.log("match", arr[mid], i);
         return arr[mid];
     } else if (arr[mid] < i && arr.length > 1) {
         binarySearch(arr.splice(mid, Number.MAX_VALUE), i);
     } else if (arr[mid] > i && arr.length > 1) {
         binarySearch(arr.splice(0, mid), i);
     } else {
-        console.log('not found', i);
+        console.log("not found", i);
         return -1;
     }
 
 }
 
-var ar=[1,2,3,4,5,6,7,8,9,10];
+var ar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-binarySearch(ar,3);
+binarySearch(ar, 3);
-binarySearch(ar,7);
+binarySearch(ar, 7);
-binarySearch(ar,13);
+binarySearch(ar, 13);

Search/linearSearch.js

@@ -1,24 +1,24 @@
 /*
-* Linear search or sequential search is a method for finding a target
+ * Linear search or sequential search is a method for finding a target
-* value within a list. It sequentially checks each element of the list
+ * value within a list. It sequentially checks each element of the list
-* for the target value until a match is found or until all the elements
+ * for the target value until a match is found or until all the elements
-* have been searched.
+ * have been searched.
-*/
+ */
 function SearchArray(searchNum, ar) {
-  var position = Search(ar, searchNum);
+    var position = Search(ar, searchNum);
-  if (position != -1) {
+    if (position != -1) {
-    console.log("The element was found at " + (position + 1));
+        console.log("The element was found at " + (position + 1));
-  } else {
+    } else {
-    console.log("The element not found");
+        console.log("The element not found");
-  }
+    }
 }
 
 // Search “theArray” for the specified “key” value
 function Search(theArray, key) {
-  for (var n = 0; n < theArray.length; n++)
+    for (var n = 0; n < theArray.length; n++)
-    if (theArray[n] == key)
+        if (theArray[n] == key)
-      return n;
+            return n;
-  return -1;
+    return -1;
 }
 
 var ar = [1, 2, 3, 4, 5, 6, 7, 8, 9];

Sorts/bogoSort.js

@@ -1,48 +1,48 @@
 /*
-* A simple helper function that checks, if the array is
+ * A simple helper function that checks, if the array is
-* sorted in ascending order.
+ * sorted in ascending order.
-*/
+ */
-Array.prototype.isSorted = function() {
+Array.prototype.isSorted = function () {
 
-  let length = this.length;
+    let length = this.length;
 
-  if (length < 2) {
+    if (length < 2) {
-    return true;
+        return true;
-  }
-
-  for (let i = 0; i < length - 1; i++) {
-    if (this[i] > this[i + 1]) {
-      return false;
     }
-  }
+
-  return true;
+    for (let i = 0; i < length - 1; i++) {
+        if (this[i] > this[i + 1]) {
+            return false;
+        }
+    }
+    return true;
 };
 
 /*
-* A simple helper function to shuffle the array randomly in place.
+ * A simple helper function to shuffle the array randomly in place.
-*/
+ */
-Array.prototype.shuffle = function() {
+Array.prototype.shuffle = function () {
 
-  for (let i = this.length -1; i; i--) {
+    for (let i = this.length - 1; i; i--) {
-    let m = Math.floor(Math.random() * i);
+        let m = Math.floor(Math.random() * i);
-    let n = this[i - 1];
+        let n = this[i - 1];
-    this[i - 1] = this[m];
+        this[i - 1] = this[m];
-    this[m] = n;
+        this[m] = n;
-  }
+    }
 
 };
 
 /*
-* Implementation of the bogosort algorithm. This sorting algorithm randomly
+ * Implementation of the bogosort algorithm. This sorting algorithm randomly
-* rearranges the array until it is sorted.
+ * rearranges the array until it is sorted.
-* For more information see: https://en.wikipedia.org/wiki/Bogosort
+ * For more information see: https://en.wikipedia.org/wiki/Bogosort
-*/
+ */
 function bogoSort(items) {
 
-  while(!items.isSorted()){
+    while (!items.isSorted()) {
-    items.shuffle()
+        items.shuffle()
-  }
+    }
-  return items;
+    return items;
 }
 
 //Implementation of bogoSort
@@ -52,4 +52,4 @@ var ar = [5, 6, 7, 8, 1, 2, 12, 14];
 console.log(ar);
 bogoSort(ar);
 //Array after sort
-console.log(ar);
+console.log(ar);

Sorts/wiggleSort.js

@@ -1,18 +1,18 @@
 /*
-* Wiggle sort sorts the array into a wave like array.
+ * Wiggle sort sorts the array into a wave like array.
-* An array ‘arr[0..n-1]’ is sorted in wave form if arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= …..
+ * An array ‘arr[0..n-1]’ is sorted in wave form if arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= …..
-*
+ *
-*/
+ */
 
-Array.prototype.wiggleSort = function() {
+Array.prototype.wiggleSort = function () {
-  for (let i = 0; i < this.length; ++i) {
+    for (let i = 0; i < this.length; ++i) {
-    const shouldNotBeLessThan = i % 2;
+        const shouldNotBeLessThan = i % 2;
-    const isLessThan = this[i] < this[i + 1];
+        const isLessThan = this[i] < this[i + 1];
-    if (shouldNotBeLessThan && isLessThan) {
+        if (shouldNotBeLessThan && isLessThan) {
-      [this[i], this[i + 1]] = [this[i + 1], this[i]];
+            [this[i], this[i + 1]] = [this[i + 1], this[i]];
+        }
     }
-  }
+    return this;
-  return this;
 };
 
 //Implementation of wiggle sort

maths/abs.js

@@ -0,0 +1,26 @@
+/*
+    author: PatOnTheBack
+    license: GPL-3.0 or later
+
+    Modified from:
+        https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py
+
+    This script will find the absolute value of a number.
+
+    More about absolute values:
+        https://en.wikipedia.org/wiki/Absolute_value
+*/
+
+function abs_val(num) {
+    // Find absolute value of `num`.
+    "use strict";
+    if (num < 0) {
+        return -num
+    }
+    // Executes if condition is not met.
+    return num
+}
+
+// Run `abs` function to find absolute value of two numbers.
+console.log("The absolute value of -34 is " + abs_val(-34));
+console.log("The absolute value of 34 is " + abs_val(34));

maths/average_mean.js

@@ -0,0 +1,30 @@
+/*
+    author: PatOnTheBack
+    license: GPL-3.0 or later
+
+    Modified from:
+        https://github.com/TheAlgorithms/Python/blob/master/maths/average.py
+
+    This script will find the average (mean) of an array of numbers.
+
+    More about mean:
+        https://en.wikipedia.org/wiki/Mean
+*/
+
+function mean(nums) {
+    "use strict";
+    var sum = 0;
+    var avg;
+
+    // This loop sums all values in the 'nums' array.
+    nums.forEach(function (current) {
+        sum += current;
+    });
+
+    // Divide sum by the length of the 'nums' array.
+    avg = sum / nums.length;
+    return avg;
+}
+
+// Run `mean` Function to find average of a list of numbers.
+console.log(mean([2, 4, 6, 8, 20, 50, 70]));

maths/factorial.js

@@ -0,0 +1,52 @@
+/*
+    author: PatOnTheBack
+    license: GPL-3.0 or later
+
+    Modified from:
+        https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py
+
+    This script will find the factorial of a number provided by the user.
+
+    More about factorials:
+        https://en.wikipedia.org/wiki/factorial
+*/
+
+"use strict";
+
+function calc_range(num) {
+    // Generate a range of numbers from 1 to `num`.
+    var i = 1;
+    var range = [];
+    while (i <= num) {
+        range.push(i);
+        i += 1;
+    }
+    return range;
+}
+
+function calc_factorial(num) {
+    var factorial;
+    var range = calc_range(num);
+
+    // Check if the number is negative, positive, null, undefined, or zero
+    if (num < 0) {
+        return "Sorry, factorial does not exist for negative numbers.";
+    }
+    if (num === null || num === undefined) {
+        return "Sorry, factorial does not exist for null or undefined numbers.";
+    }
+    if (num === 0) {
+        return "The factorial of 0 is 1.";
+    }
+    if (num > 0) {
+        factorial = 1;
+        range.forEach(function (i) {
+            factorial = factorial * i;
+        });
+        return "The factorial of " + num + " is " + factorial;
+    }
+}
+
+// Run `factorial` Function to find average of a list of numbers.
+var num = prompt("Enter a number: ");
+alert(calc_factorial(num));

maths/find_lcm.js

@@ -0,0 +1,38 @@
+/*
+    author: PatOnTheBack
+    license: GPL-3.0 or later
+
+    Modified from:
+        https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py
+
+    More about LCM:
+        https://en.wikipedia.org/wiki/Least_common_multiple
+*/
+
+"use strict";
+
+// Find the LCM of two numbers.
+function find_lcm(num_1, num_2) {
+    var max_num;
+    var lcm;
+    // Check to see whether num_1 or num_2 is larger.
+    if (num_1 > num_2) {
+        max_num = num_1;
+    } else {
+        max_num = num_2;
+    }
+    lcm = max_num;
+
+    while (true) {
+        if ((lcm % num_1 === 0) && (lcm % num_2 === 0)) {
+            break;
+        }
+        lcm += max_num;
+    }
+    return lcm;
+}
+
+// Run `find_lcm` Function
+var num_1 = 12;
+var num_2 = 76;
+console.log(find_lcm(num_1, num_2));