merged master

Author: blundell

.editorconfig

@@ -0,0 +1,22 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+
+[*]
+
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab
+indent_size = 4

.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
 .idea
 /out
-/core
+/core
+node_modules

.jshintignore

@@ -0,0 +1,4 @@
+node_modules
+
+# Pretty dodgy JS to keep it so small
+shortest-fizz-buzz

.jshintrc

@@ -0,0 +1,33 @@
+{
+  "node": true,
+  "browser": true,
+  "jquery": true,
+  "devel": true,
+  "nonstandard": true,
+  "worker": true,
+  "esnext": true,
+  "bitwise": false,
+  "boss": true,
+  "camelcase": true,
+  "curly": true,
+  "eqeqeq": true,
+  "eqnull": true,
+  "expr": true,
+  "forin": true,
+  "immed": true,
+  "latedef": true,
+  "newcap": true,
+  "noarg": true,
+  "quotmark": "single",
+  "regexp": true,
+  "strict": false,
+  "undef": true,
+  "unused": true,
+  "trailing": true,
+  "smarttabs": true,
+  "immed": true,
+  "globals": {
+    "it": true,
+    "describe": true
+  }
+}

byte-string/README.md

@@ -0,0 +1,15 @@
+# Byte String
+
+Convert a number to a string that represents a rounded size in bytes.
+
+## Example
+
+```
+f(156833213) // => "149.57 MB"
+f(8101)      // => "7.91 KB"
+f(12331, 3)  // => "12.042 KB"
+```
+
+## Source
+
+By [Riga](https://github.com/riga).

byte-string/byte-string.js

@@ -0,0 +1,8 @@
+module.exports = function (bytes, precision) {
+  var suffixes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
+      factor   = Math.pow(10, precision > 0 ? precision : 2);
+  // Using a for loop since it's perfect for this kind of problem
+  for (var i = bytes, k = 0; i >= 1024 && k < suffixes.length; i /= 1024, k++) {}
+  // Return the number rounded to precision
+  return (Math.round(i * factor) / factor) + ' ' + suffixes[k];
+};

debounce/Readme.md

@@ -0,0 +1,5 @@
+# Debounce
+
+Write a function that accepts a function and timeout, `x`, in number of milliseconds. It will return a new function that can only be executed on per timeout period - and if the function is invoked during the timeout period, the timeout period restarts. This is useful for functions that can be need to be blocked on subsequent attempts over short period of times. Once such is example, is clicks on a button.
+
+Once written, add a third parameter that will allow the function to be executed immediately if set to true. Otherwise the function will run at the end of the timeout period.

debounce/debounce.js

@@ -0,0 +1,22 @@
+module.exports = function (fn, delay, execAsap) {
+  var timeout; // Keep a reference to the timeout outside the function
+
+  return function () {
+    // Keep the functions execution context and arguments in tact
+    var that = this,
+        args = arguments;
+
+    // If we already have a function ready to execute, clear it
+    // Else if we are allowed to execute immediately, call the function
+    if (timeout) {
+      clearTimeout(timeout);
+    } else if (execAsap) {
+      fn.apply(that, args);
+    }
+
+    timeout = setTimeout(function () {
+      execAsap || fn.apply(that, args);
+      timeout = null;
+    }, delay || 100);
+  };
+};

factorial/factorial.js

@@ -0,0 +1,29 @@
+// Recursive function example
+exports.recursive = function factorial (number) {
+  if (number < 2) { return 1; }
+
+  return number * factorial(number - 1);
+};
+
+// Iterative solution
+exports.iterative = function (number) {
+  var result = 1;
+
+  for (var i = 1; i <= number; i++) {
+    result *= i;
+  }
+
+  return result;
+};
+
+// Iterative using a reverse loop
+exports.iterativeReverse = function (number) {
+  var result = 1;
+
+  while (number) {
+    result *= number;
+    number -= 1;
+  }
+
+  return result;
+};

factorial/factorial.php

@@ -0,0 +1,32 @@
+<?php
+
+    // Iterative solution
+    function factorial($number){
+        $result = 1;
+        for($i=1; $i <= $number ; $i++){
+            $result *=$i;
+        }
+        return $result;
+    }
+
+    // Iterative using a reverse loop
+    function factorialReverse($number){
+        $result = 1;
+        while($number !=1){
+            $result *= $number;
+            $number--;
+        }
+        return $result;
+    }
+
+    // Recursive solution
+    function factorialRecursive($number){
+        if($number ==1){
+            return 1;
+        }
+        else{
+            return $number *factorialRecursive($number-1);
+        }
+    }
+
+?>

factorial/readme.md

@@ -0,0 +1,8 @@
+Factorial
+==========
+
+Factorial of any number n is defined as the multiplication of numbers from one to the given number. 
+
+``
+n! = 1 x 2 x 3 x 4 x ........ x n
+``

hotel-room/hotel-room.cs

@@ -0,0 +1,89 @@
+/* this is program written in C# by Alvareto */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace hotelRoom
+{
+    class Program
+    {
+        static int[] getDivisors (int number)
+        {
+            List<int> divisors = new List<int>();
+            for (int i = number; --i > 0; )
+                if (number % i == 0)
+                    divisors.Add(i);
+            return divisors.ToArray();
+        }
+        
+        //get the smallest integer m greater than n,
+        //both n and m have same number of '1' in their binary string
+        static int getNextN(int n){
+            int temp1 = n & (-n);//point out the first '1' in n's binary string form right to left
+            int temp2 = n + temp1;
+            int ret = temp2 | ((n ^ temp2) / temp1) >> 2;
+            return ret;
+        }
+        static List<List<int>> getSubsets(int[] divisors)
+        {
+            List<List<int>> subsets = new List<List<int>>();
+            int num = divisors.Length;
+            for (int i = 1; i <= num; i++) { //get divisors's i element subsets 
+                int beginIdx = (1 << i) - 1;
+                int endIdx = (1 << num) - (1 << (num - i));
+                for (int j = beginIdx; j <= endIdx; ) { //the index of '1' in j's binary string from rigth to left indicates divisors[index] is in the subset
+                    //TODO:output subset
+                    List<int> subset = new List<int>();
+                    int index = 0;
+                    int k = j;
+                    while (k>0) {
+                        if (k % 2 == 1) subset.Add(divisors[index]);
+                        k /= 2;
+                        index++;
+                    }
+                    subsets.Add(subset);
+                    j = getNextN(j);
+                }
+            }
+            return subsets;
+        }
+
+
+        static bool isRoom(List<List<int>> subsets, int room)
+        {
+            foreach (List<int> subset in subsets)
+            {
+                if (subset.Sum() == room)
+                    return false;
+            }
+            return true;
+        }
+        
+        static void findRoom(int totalRooms)
+        {
+            for (int i = 0; ++i < 101; )
+            {
+                int[] divisors = getDivisors(i);
+                int sum = divisors.Sum();
+
+                if (sum <= i)
+                    continue;
+
+                if (isRoom(getSubsets(divisors), i))
+                {
+                    Console.WriteLine(i);
+                    break;
+                }
+            }
+        }
+
+        static void Main(string[] args)
+        {
+            int input = Convert.ToInt32(Console.ReadLine());
+            findRoom(input);
+        }
+    }
+}

integer-length/integer-length.php

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

longest-words/LongestWords.cs

@@ -0,0 +1,31 @@
+
+        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)
+                        {
+                            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;
+        }

merge-sort/Readme.md

@@ -0,0 +1,3 @@
+# Merge Sort
+
+Implement the [merge sort algorithm](http://en.wikipedia.org/wiki/Merge_sort).

merge-sort/merge-sort.js

@@ -0,0 +1,37 @@
+// Sort the array by breaking it down into smaller chunks
+module.exports = function mergeSort (array, compare) {
+  // If's not an array or an array of just one element, it's already sorted
+  if (!Array.isArray(array) || array.length < 2) { return array; }
+
+  var length = array.length,
+      middle = Math.floor(length * 0.5),
+      left   = array.slice(0, middle),
+      right  = array.slice(middle, length);
+
+  // Create a compare func if not passed in
+  if (typeof compare !== 'function') {
+    compare = function (a, b) {
+      return a > b ? 1 : -1;
+    };
+  }
+
+  var merge = function (left, right) {
+    var result = [];
+    while (left.length || right.length) {
+      if (left.length && right.length) {
+        if (compare(left[0], right[0]) < 1) {
+          result.push(left.shift());
+        } else {
+          result.push(right.shift());
+        }
+      } else if (left.length) {
+        result.push(left.shift());
+      } else {
+        result.push(right.shift());
+      }
+    }
+    return result;
+  };
+
+  return merge(mergeSort(left), mergeSort(right));
+};

once/Readme.md

@@ -0,0 +1,5 @@
+# Once
+
+Write a function that accepts a function as it's only argument and returns a new function that can only ever be executed once.
+
+Once completed, add a second arguments that allows the function to be executed `x` number of times before it stops working.

once/once.js

@@ -0,0 +1,17 @@
+module.exports = function (fn, times) {
+  // Set times to one if nothing is passed through and keep track of the
+  // latest return value to return when we run out of execution times
+  var memo;
+  times = times || 1;
+  // Return another function that will be executed
+  return function () {
+    if (!times) { return memo; }
+    // Set memo to the result of the function and decrement the number of executions
+    memo   = fn.apply(this, arguments);
+    times -= 1;
+    // If there are no more execution times, set the function to `null` so
+    // it can be garbage collected and return the memo
+    times || (fn = null);
+    return memo;
+  };
+};