initial commit

Author: koalamango

.gitignore

@@ -0,0 +1,6 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+.DS_Store
+.env*
+.idea/
+

README.md

@@ -1,2 +1,97 @@
-# javascript-algorithms
-✨ Algorithms in JavaScript
+ # Common Algorithms in JavaScript 
+
+
+#### What's an algorithm?
+
+> An algorithm is a set of instruction to solve problems. 
+
+Still confused? [Watch the video](https://www.youtube.com/watch?v=6hfOvs8pY1k) 
+of Professor David J. Malan explains how algorithms can be used in seemingly 
+simple situations and also complex ones. 
+
+#### List of common algorithms
+ 
+* [Fizz Buzz](src/fizzbuzz.js)
+
+Fizz-Buzz is a group word game for children to teach them about division. 
+Players take turns to count incrementally, replacing any multiple of three 
+with the word "fizz", and any multiple of five with the word "buzz".
+   
+* [Two Sum](src/TwoSum.js)
+
+You are given an array of n integers and a number k. Determine whether there is a pair
+of elements in the array that sums to exactly k. For example, given the array [1, 3, 7] and
+k = 8, the answer is "yes" but given k = 6 the answer is "no"
+
+* [Harmless Ransom Note](src/HarmlessRansomNote.js)
+
+The harmless ransom note is simply a note made of words cut out from a magazine text.
+
+You have been given two strings. You have to find out whether you can make up the 
+first string with the words present in the second string.
+
+* [Is Palindrome](src/IsPalindrome.js)
+
+A palindrome is a word, phrase, number or sequence of words that reads the same backward 
+as forward. Punctuation and spaces between the words or lettering is allowed. 
+
+* [Caesar Cipher](src/CaesarCipher.js)
+
+Caesar cipher is to replace each plaintext letter with a different one a fixed number of 
+places down the alphabet. The cipher illustrated here uses a left shift of three, so that 
+(for example) each occurrence of E in the plaintext becomes B in the ciphertext.
+
+* [Reverse Words](src/ReverseWords.js)
+
+Reverse the string without using array.prototype.reverse().
+
+* [Reverse Array In Place](src/ReverseArrayInPlace.js)
+
+Reverse the order of the elements of an array. 
+
+* [Mean Median Mode](src/MeanMedianMode.js)
+
+Calculate the mean, median, or mode of a data set!
+
+* [Fibonacci](src/Fibonacci.js)
+
+The Fibonacci Sequence is the series of numbers: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . . 
+Each subsequent number is the sum of the previous two.
+
+Write a function to return an n element in Fibonacci sequence
+
+* [Sieve of Eratosthenes](src/SieveOfEratosthenes.js)
+
+In mathematics, the sieve of Eratosthenes is an ancient algorithm for finding all prime 
+numbers up to any given limit. It does so by iteratively marking as composite (i.e., 
+not prime) the multiples of each prime, starting with the first prime number, 2.
+
+Given a number n, print all primes smaller than or equal to n. It is also given that n 
+is a small number.
+
+* [Max Stock Profit](src/MaxStockProfit.js)
+
+Given an array of stock prices over time, need to figure out the best buy and sell price 
+so that we get the maximum profit. The selling should occur after buying of the stock.
+ 
+
+* Plurality (winner take all) 
+
+In the plurality vote, every voter gets to vote for one candidate. At the end 
+of the election, whichever candidate has the greatest number of votes is 
+declared the winner of the election.
+
+* Runoff
+
+In a ranked-choice system, voters can vote for more than one candidate. Instead 
+of just voting for their top choice, they can rank the candidates in order of 
+preference. 
+
+* Readability
+* Liner Search
+* Binary Search
+* Bubble Sort
+* Selection Sort
+* Insertion Sort
+* Recursion
+* Merge Sort

src/CaesarCipher.js

@@ -0,0 +1,25 @@
+function caesarCipher(str,num) {
+  num = num % 26;
+  var lowerCaseString = str.toLowerCase();
+  var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
+  var newString = '';
+
+  for (var i = 0; i < lowerCaseString.length; i++) {
+    var currentLetter = lowerCaseString[i];
+    if (currentLetter === ' ') {
+      newString += currentLetter;
+      continue;
+    }
+    var currentIndex = alphabet.indexOf(currentLetter);
+    var newIndex = currentIndex + num;
+    if (newIndex > 25) newIndex = newIndex - 26;
+    if (newIndex < 0) newIndex = 26 + newIndex;
+    if (str[i] === str[i].toUpperCase()) {
+      newString += alphabet[newIndex].toUpperCase();
+    }
+    else newString += alphabet[newIndex];
+  };
+
+  return newString;
+}
+caesarCipher('Sunny Day', 2);

src/Fibonacci.js

@@ -0,0 +1,13 @@
+function fibonacci(index, cache) {
+  cache = cache || [];
+  if (cache[index]) return cache[index];
+  else {
+    if (index < 3) return 1;
+    else {
+      cache[index] = fibonacci(index - 1, cache) + fibonacci(index - 2, cache);
+    }
+  }
+  return cache[index];
+}
+
+fibonacci(500);

src/HarmlessRansomNote.js

@@ -0,0 +1,23 @@
+function harmlessRansomNote(noteText, magazineText) {
+  var noteArr = noteText.split(' ');
+  var magazineArr = magazineText.split(' ');
+  var magazineObj = {};
+
+  magazineArr.forEach(word => {
+    if (!magazineObj[word]) magazineObj[word] = 0;
+    magazineObj[word]++;
+  });
+
+  var noteIsPossible = true;
+  noteArr.forEach(word => {
+    if (magazineObj[word]) {
+      magazineObj[word]--;
+      if (magazineObj[word] < 0) noteIsPossible = false;
+    }
+    else noteIsPossible = false;
+  });
+
+  return noteIsPossible;
+}
+
+harmlessRansomNote('Here is the secret message');

src/IsPalindrome.js

@@ -0,0 +1,14 @@
+function isPalindrome(string) {
+  string = string.toLowerCase();
+  var charactersArr = string.split('');
+  var validCharacters = 'abcdefghijklmnopqrstuvwxyz'.split('');
+
+  var lettersArr = [];
+  charactersArr.forEach(char => {
+    if (validCharacters.indexOf(char) > -1) lettersArr.push(char);
+  });
+
+  return lettersArr.join('') === lettersArr.reverse().join('');
+}
+
+isPalindrome("Madam, I'm Adam");

src/MaxStockProfit.js

@@ -0,0 +1,25 @@
+function maxStockProfit (pricesArr) {
+  var maxProfit = -1;
+  var buyPrice = 0;
+  var sellPrice = 0;
+
+  var changeBuyPrice = true;
+
+  for (var i = 0; i < pricesArr.length; i++) {
+    if (changeBuyPrice) buyPrice = pricesArr[i];
+    sellPrice = pricesArr[i + 1];
+
+    if (sellPrice < buyPrice) {
+      changeBuyPrice = true;
+    }
+    else {
+      var tempProfit = sellPrice - buyPrice;
+      if (tempProfit > maxProfit) maxProfit = tempProfit;
+      changeBuyPrice = false;
+    }
+  }
+
+  return maxProfit;
+}
+
+maxStockProfit([10, 18, 4, 5, 9, 6, 16, 12]);

src/MeanMedianMode.js

@@ -0,0 +1,61 @@
+function meanMedianMode(array) {
+  return {
+    mean: getMean(array),
+    median: getMedian(array),
+    mode: getMode(array)
+  }
+}
+
+function getMean(array) {
+  var sum = 0;
+
+  array.forEach(num => {
+    sum += num;
+  });
+
+  var mean = sum / array.length;
+  return mean;
+}
+
+function getMedian(array) {
+  array.sort(function(a, b){return a-b});
+  var median;
+
+  if (array.length % 2 !== 0) {
+    median = array[Math.floor(array.length / 2)];
+  }
+  else {
+    var mid1 = array[(array.length / 2) - 1];
+    var mid2 = array[array.length / 2];
+    median = (mid1 + mid2) / 2;
+  }
+
+  return median;
+}
+
+function getMode(array) {
+  var modeObj = {};
+
+  // create modeObj
+  array.forEach(num => {
+    if (!modeObj[num]) modeObj[num] = 0;
+    modeObj[num]++;
+  });
+
+  // create array of mode/s
+  var maxFrequency = 0;
+  var modes = [];
+  for (var num in modeObj) {
+    if (modeObj[num] > maxFrequency) {
+      modes = [num];
+      maxFrequency = modeObj[num];
+    }
+    else if (modeObj[num] === maxFrequency) modes.push(num);
+  }
+  // if every value appears same amount of times
+  if (modes.length === Object.keys(modeObj).length) modes = [];
+  return modes;
+}
+
+
+meanMedianMode([9,10,23,10,23,9]);

src/ReverseArrayInPlace.js

@@ -0,0 +1,11 @@
+function reverseArrayInPlace(arr) {
+  for (var i = 0; i < arr.length / 2; i++) {
+    var tempVar = arr[i];
+    arr[i] = arr[arr.length - 1 - i];
+    arr[arr.length - 1 - i] = tempVar;
+  }
+
+  return arr;
+}
+
+reverseArrayInPlace([1, 2, 3, 4, 5, 6, 7, 8]);

src/ReverseWords.js

@@ -0,0 +1,16 @@
+function reverseWords(string) {
+  var wordsArr = string.split(' ');
+  var reversedWordsArr = [];
+
+  wordsArr.forEach(word => {
+    var reversedWord = '';
+    for (var i = word.length - 1; i >= 0; i--) {
+      reversedWord += word[i];
+    };
+    reversedWordsArr.push(reversedWord);
+  });
+
+  return reversedWordsArr.join(' ');
+}
+
+reverseWords('Algorithm in JavaScript');

src/SieveOfEratosthenes.js

@@ -0,0 +1,24 @@
+function sieveOfEratosthenes(n) {
+  var primes = [];
+  for (var i = 0; i <= n; i++) {
+    primes[i] = true;
+  }
+
+  primes[0] = false;
+  primes[1] = false;
+
+  for (var i = 2; i <= Math.sqrt(n); i++) {
+    for (j = 2; i * j <= n; j++) {
+      primes[i * j] = false;
+    }
+  }
+
+  var result = [];
+  for (var i = 0; i < primes.length; i++) {
+    if (primes[i]) result.push(i);
+  }
+
+  return result;
+}
+
+sieveOfEratosthenes(49);

src/TwoSum.js

@@ -0,0 +1,19 @@
+function twoSum(numArray, sum) {
+  let pairs = [];
+  let hashtable = [];
+
+  for (let i = 0; i < numArray.length; i++) {
+    let currNum = numArray[i];
+    let counterpart = sum - currNum;
+    if (hashtable.indexOf(counterpart) !== -1) {
+      pairs.push([currNum, counterpart]);
+    }
+    hashtable.push(currNum);
+  }
+
+  return pairs;
+}
+
+twoSum([1, 6, 4, 5, 3, 3], 7);
+// return [ [ 6, 1 ], [ 3, 4 ], [ 3, 4 ] ]
+

src/fizzbuzz.js

@@ -0,0 +1,10 @@
+function fizzBuzz(num) {
+  for (let i = 1; i <= num; i++) {
+    if (i % 15 === 0) console.log('FizzBuzz');
+    else if (i % 3 === 0) console.log('Fizz');
+    else if (i % 5 === 0) console.log('Buzz');
+    else console.log(i);
+  }
+}
+
+fizzBuzz(30);