Somewhere here the git history has been mangled, clean up some issues until I go through and start adding tests for them all.

Author: blakeembrey

Readme.md

@@ -1,3 +1,16 @@
 # Code Problems
 
-This repo is full of code problems that I have received prior or during an interview. I'll present all my solutions here in JavaScript, but feel free to add your own solutions in another language and even optimise my solutions. If you have your own code problems you would like to contribute, I would love to see them as well.
+This is my repo full of code problems that I have completed prior to or during an interview. I hope that all these problems (and solutions) are useful to practice against and review. Feel free to contribute any solutions and optimisations, given they are algorithmic optimisations. Please add your own problems that you find as well, as I would love to see them.
+
+## Contributing
+
+In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality.
+
+Indentation should be set to two spaces. Please lint and test your code with any means available - currently only JavaScript has tests and linting via Mocha and JSHint.
+
+## Testing
+
+```sh
+npm install # Installs `mocha` and any other dependencies needed to run
+npm test    # Runs the testing scripts
+```

anagram-detection/Readme.md

@@ -2,7 +2,6 @@
 
 Write a function that accepts two parameters, a parent and a child string. Determine how many times the child string - or an anagram of the of the child string - appears in the parent string. There is a solution which can be done in near instant time.
 
-
 ```js
 f('AdnBndAndBdaBn', 'dAn') // 4 ("Adn", "ndA", "dAn", "And")
 f('AbrAcadAbRa', 'cAda') // 2

hotel-room/index.php hotel-room/hotel-room.php

@@ -1,4 +1,4 @@
-var findUniquePairs = function (n, array) {
+var integerDifference = function (n, array) {
   var hash  = {},
       total = 0;
 

integer-difference/integer-difference.js

@@ -1,7 +1,7 @@
 <?php
 
-function IntegerLength($num){
-    return strlen((string) $num);
+function IntegerLength ($num) {
+  return strlen((string) $num);
 }
 
-?>
+?>

integer-length/integer-length.php

@@ -1,22 +1,25 @@
-var kthElementInArray = function (k, array) {
+var kthLargestElementInArray = function (k, array) {
   // I believe we can store it in a hash to achieve an O(n) complexity
   var hash  = {},
       count = 0;
+
   // Loop through each of the array items putting the values as keys in the hash
   array.forEach(function (num) {
     hash[num] = hash[num] + 1 || 1;
   });
+
   // Loop through each of the keys in the hash and keep track of the total count
   for (var i in hash) {
     // Check if `k` is smaller or equal to the current count plus the current
     // hash index, but also greater than the previous count (this will mean it
     // is stored in this integer key)
     if (k <= count + hash[i] && k > count) {
       // Coerce the output back to a number, since that is expected
-      return Number(i);
+      return +i;
     }
     // Increment the total count
     count += hash[i];
   }
+
   return -1;
 };

kth-largest-element-in-array/kth-largest-element-in-array.js

@@ -45,8 +45,3 @@ LinkedList.prototype.containsNode = function (value) {
 
   return false;
 };
-
-// Maker function to return instances of linked lists
-var makeLinkedList = function (value) {
-  return new LinkedList(value);
-};

linked-list/linked-list.js

@@ -8,8 +8,8 @@ module.exports = function (list) {
   // Inserts a word into the prefix tree structure
   insertWord = function (word) {
     var index  = 0,
-	active = prefixes,
-	char;
+      active = prefixes,
+      char;
 
     while (char = word[index++]) {
       active = (active[char] = active[char] || {});
@@ -21,10 +21,10 @@ module.exports = function (list) {
   // Finds the longest prefix we can make using the word
   findPrefixes = function (word) {
     var prefix = '',
-	found  = [],
-	index  = 0,
-	active = prefixes,
-	char;
+        found  = [],
+        index  = 0,
+        active = prefixes,
+        char;
 
     while (char = word[index++]) {
       if (!active[char]) { break; }
@@ -52,22 +52,22 @@ module.exports = function (list) {
 
   possibleWords.forEach(function (possible) {
     var word     = possible[0],
-	prefixes = possible[1],
-	found    = false,
-	findCompoundWord, loopPrefixes;
+        prefixes = possible[1],
+        found    = false,
+        findCompoundWord, loopPrefixes;
 
     findCompoundWord = function (suffix) {
       // Find all future prefixes and continue search
       if (suffix) {
-	return findPrefixes(suffix).forEach(function (prefix) {
-	  !found && loopPrefixes(prefix, suffix);
-	});
+        return findPrefixes(suffix).forEach(function (prefix) {
+          !found && loopPrefixes(prefix, suffix);
+        });
       }
       // If the suffix doesn't exist, it must be because we have found an
       // exact compound word
       if (word.length > longestLength) {
-	longestWords  = [];
-	longestLength = word.length;
+        longestWords  = [];
+        longestLength = word.length;
       }
       // If the word is equal to the length of the current longest word, push it
       // into the result array, then set found to be true so we can break the

longest-compound-word/longest-compound-word.js

@@ -1,31 +1,30 @@
-
-        char[] delimiter = new char[] { ' ' };
-        public List<string> FindLongestWords(string sentence)
+char[] delimiter = new char[] { ' ' };
+public List<string> FindLongestWords(string sentence)
+{
+  List<string> longestWords = new List<string>();
+  int currentLongestLength = 0;
+  string[] words = sentence.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
+  if (words != null && words.Length > 0)
+  {
+    foreach (string word in words)
+    {
+      // Duplicate check.
+      if (!longestWords.Contains(word.ToLower()))
+      {
+        // If word is longer than the current longest. We clear our word list and add only this one.
+        if (word.Length > currentLongestLength)
         {
-            List<string> longestWords = new List<string>();
-            int currentLongestLength = 0;
-            string[] words = sentence.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
-            if (words != null && words.Length > 0)
-            {
-                foreach (string word in words)
-                {
-                    // Duplicate check.
-                    if (!longestWords.Contains(word.ToLower()))
-                    {
-                        // If word is longer than the current longest. We clear our word list and add only this one.
-                        if (word.Length > currentLongestLength)
-                        {
-                            longestWords.Clear();
-                            longestWords.Add(word.ToLower());
-                            currentLongestLength = word.Length;
-                        }
-                        // If word's length equals currentLongest, we just add it to the list.
-                        else if (word.Length == currentLongestLength)
-                        {
-                            longestWords.Add(word);
-                        }
-                    }
-                }
-            }
-            return longestWords;
+          longestWords.Clear();
+          longestWords.Add(word.ToLower());
+          currentLongestLength = word.Length;
         }
+        // If word's length equals currentLongest, we just add it to the list.
+        else if (word.Length == currentLongestLength)
+        {
+          longestWords.Add(word);
+        }
+      }
+    }
+  }
+  return longestWords;
+}

longest-words/LongestWords.cs

@@ -31,22 +31,22 @@ var medianStream = {
     if (!this._median) { this._median = new LinkedList(number); return; }
 
     var node = this._median,
-	prevNode;
+        prevNode;
 
     // If the number is greater than the median value, need to insert somewhere
     // after the current median node
     if (number > this._median.value) {
       while (node && node.value < number) {
-	prevNode = node;
-	node     = node.next;
+        prevNode = node;
+        node     = node.next;
       }
       (node || prevNode).append(number);
       // Increment the counter of right nodes
       ++this._right;
     } else {
       while (node && node.value > number) {
-	prevNode = node;
-	node     = node.prev;
+        prevNode = node;
+        node     = node.prev;
       }
       (node || prevNode).prepend(number);
       // Increment the counter of left nodes

median-integer-stream/median-integer-stream.js

@@ -14,7 +14,7 @@ exports.iterative = function (number) {
   return string.join('.');
 };
 
-exports.regex = function (number) {
+exports.regexp = function (number) {
   var string = ('' + number).split('.');
 
   string[0] = string[0].replace(/(\d)(?=(?:\d{3})+(?:\.|$))/g, '$1,');

number-format/number-format.js

@@ -1,7 +1,8 @@
 var primeNumber = function (n) {
-  if (n < 2) { return false; }
+  if (n === 2) { return true; }
+  if (n < 2 || !(n&1)) { return false; }
 
-  for (var i = 2, l = Math.floor(Math.pow(n, 0.5)); i <= l; i++) {
+  for (var i = 3, l = Math.floor(Math.pow(n, 0.5)); i <= l; i += 2) {
     if (n % i === 0) {
       return false;
     }

prime-number/prime-number.js

@@ -4,7 +4,7 @@ var Queue = function () {
   this.length = 0;
 }
 
-Queue.prototype.add = function (value) {
+Queue.prototype.enqueue = function (value) {
   var node = {
     value: value,
     next: null
@@ -26,7 +26,7 @@ Queue.prototype.add = function (value) {
   return this.length += 1;
 };
 
-Queue.prototype.remove = function () {
+Queue.prototype.dequeue = function () {
   if (!this.head) { return; }
 
   var node = this.head;

queue/queue.js

@@ -3,7 +3,7 @@ var Stack = function () {
   this.length = 0;
 }
 
-Stack.prototype.add = function (value) {
+Stack.prototype.push = function (value) {
   var node = {
     value: value,
     next: null
@@ -19,7 +19,7 @@ Stack.prototype.add = function (value) {
   return this.length += 1;
 };
 
-Stack.prototype.remove = function () {
+Stack.prototype.pop = function () {
   // If there is no head node, return `undefined`
   if (!this.head) { return; }
 

shortest-fizz-buzz/index.php shortest-fizz-buzz/shortest-fizz-buzz.php

@@ -1,7 +1,7 @@
 var stringFormat = function (string /* , args */) {
-    var args = Array.prototype.slice.call(arguments, 1);
+  var args = Array.prototype.slice.call(arguments, 1);
 
-    return string.replace(/\{(\d+)\}/g, function (_, arg) {
-      return arg in args ? args[arg] : _;
-    });
+  return string.replace(/\{(\d+)\}/g, function (_, arg) {
+    return arg in args ? args[arg] : _;
+  });
 };

stack/stack.js

@@ -1,9 +1,9 @@
-        public int SumOfIntegers(int[] integerArray)
-        {
-            int sum = 0;
-            foreach (int item in integerArray)
-            {
-                sum += item;
-            }
-            return sum + integerArray.Length;
-        }
+public int SumOfIntegers(int[] integerArray)
+{
+  int sum = 0;
+  foreach (int item in integerArray)
+  {
+    sum += item;
+  }
+  return sum + integerArray.Length;
+}

string-format/string-format.js

@@ -1,11 +1,11 @@
 <?php
 
-function SumOfIntegers($integerArray){
-    $sum = 0;
-    foreach($integerArray as $valor){
-        $sum += $valor;
-    }
-    return $sum + count($integerArray);
+function SumOfIntegers ($integerArray) {
+  $sum = 0;
+  foreach ($integerArray as $valor) {
+    $sum += $valor;
+  }
+  return $sum + count($integerArray);
 }
 
 ?>

sum-of-array-plus-one/sum-of-array-plus-one.cs

@@ -8,26 +8,26 @@ var transformWord = function (dictionary, start, end) {
     var isOneCharDifference = function (word1, word2) {
       // If the second word is larger than the first word, reverse the arguments and run again
       if (word2.length > word1.length) {
-	return isOneCharDifference(word2, word1);
+        return isOneCharDifference(word2, word1);
       }
 
       // If the difference in length between the words is greater than one,
       // or the words are identical anyway, it's impossible
       if (word1 === word2 || word2.length < word1.length - 1) {
-	return false;
+        return false;
       }
 
       for (var i = 0; i < word1.length; i++) {
-	// First we check whether replacing the character with the equivelent from
-	// the second word with make the second word
-	if (word1.substr(0, i) + word2[i] + word1.substr(i + 1) === word2) {
-	  return true;
-	}
-	// Next we check if removing a single letter from the first word will
-	// result in the second word
-	if (word1.substr(0, i) + word1.substr(i + 1) === word2) {
-	  return true;
-	}
+        // First we check whether replacing the character with the equivelent from
+        // the second word with make the second word
+        if (word1.substr(0, i) + word2[i] + word1.substr(i + 1) === word2) {
+          return true;
+        }
+        // Next we check if removing a single letter from the first word will
+        // result in the second word
+        if (word1.substr(0, i) + word1.substr(i + 1) === word2) {
+          return true;
+        }
       }
 
       return false;
@@ -38,11 +38,11 @@ var transformWord = function (dictionary, start, end) {
       graph[word] = [];
       // Check all the other words in the graph so far and see if they are connections
       Object.keys(graph).forEach(function (connection) {
-	if (isOneCharDifference(word, connection)) {
-	  graph[word].push(connection);
-	  // Push the word into the connection if it's been created
-	  graph[connection] && graph[connection].push(word);
-	}
+        if (isOneCharDifference(word, connection)) {
+          graph[word].push(connection);
+          // Push the word into the connection if it's been created
+          graph[connection] && graph[connection].push(word);
+        }
       });
     });