Merge pull request #88 from PatOnTheBack/master

Improved JSLint Compliance and Created Math Algorithms

Algorithms/EucledianGCD.js

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

Algorithms/sieveOfEratosthenes.js

@@ -1,4 +1,4 @@
-function sieveOfEratosthenes (n) {
+function sieveOfEratosthenes(n) {
     /*
      * Calculates prime numbers till a number n
      * :param n: Number upto which to calculate primes
@@ -18,7 +18,7 @@ function sieveOfEratosthenes (n) {
     return primes;
 }
 
-function main () {
+function main() {
     let n = 69; // number till where we wish to find primes
     let primes = sieveOfEratosthenes(n);
     for (let i = 2; i <= n; i++) {

Ciphers/caesarsCipher.js

@@ -15,24 +15,24 @@ function rot13(str) {
     let response = [];
     let strLength = str.length;
 
-  for (let i =0; i < strLength; i++) {
+    for (let i = 0; i < strLength; 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)) {
+        } 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

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,9 +1,9 @@
 /*
-* 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);
     if (position != -1) {

Sorts/bogoSort.js

@@ -1,8 +1,8 @@
 /*
-* 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;
 
@@ -19,11 +19,11 @@ Array.prototype.isSorted = function() {
 };
 
 /*
-* 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 n = this[i - 1];
         this[i - 1] = this[m];
@@ -33,13 +33,13 @@ Array.prototype.shuffle = function() {
 };
 
 /*
-* 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()
     }
     return items;

Sorts/wiggleSort.js

@@ -1,10 +1,10 @@
 /*
-* 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) {
         const shouldNotBeLessThan = i % 2;
         const isLessThan = this[i] < this[i + 1];

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));