matrix rotation and logic gates

allAnagrams/allAnagramAlternatives.js

@@ -0,0 +1,79 @@
+// Recursive:
+const allAnagrams = (str, start = '') => {
+  if (str.length === 1) return [start + str];
+  const anagrams = [];
+
+  for (let i = 0; i < str.length; i++) {
+    const result = allAnagrams(str.substr(0, i) + str.substr(i + 1), str[i]);
+    for (let j = 0; j < result.length; j++) {
+      anagrams.push(start + result[j]);
+    }
+  }
+  return anagrams;
+};
+
+// Depth First Search, turning string into tree:
+class Anagram {
+  constructor(string, letter = null) {
+    this.string = string;
+    this.letter = letter;
+    this.children = [];
+    this.answer = [];
+    this.divide();
+    this.produce();
+  }
+
+  divide() {
+    const arr = this.string.split('');
+    arr.forEach(l => {
+      const rest = arr.filter(x => x !== l).join('');
+      const anagram = new Anagram(rest, l);
+      this.children.push(anagram);
+    });
+  }
+
+  produce(a = this, b = null) {
+    if (a.letter) {
+      b = b ? b.concat(a.letter) : a.letter;
+    }
+    if (a.children.length) {
+      a.children.forEach(aa => {
+        return this.produce(aa, b ? b : null)
+      });
+      return this.answer;
+    }
+    this.answer.push(b);
+  }
+}
+
+function allAnagrams(s) {
+  return (new Anagram(s)).answer;
+}
+
+const anagrams = allAnagrams('abcdefghi');
+console.log(anagrams);
+
+// JS implementation of Heap's Permutation Algorithm, also using generator:
+var swap = function (array, pos1, pos2) {
+  var temp = array[pos1];
+  array[pos1] = array[pos2];
+  array[pos2] = temp;
+};
+
+var heapsPermute = function (array, output, n) {
+  n = n || array.length; // set n default to array.length
+  if (n === 1) {
+    output(array);
+  } else {
+    for (var i = 1; i <= n; i += 1) {
+      heapsPermute(array, output, n - 1);
+      if (n % 2) {
+        var j = 1;
+      } else {
+        var j = i;
+      }
+      swap(array, j - 1, n - 1); // -1 to account for javascript zero-indexing
+    }
+  }
+};
+https://gist.github.com/dsernst/2570de0dc7d44a8cbbd0

allAnagrams/allAnagrams.js

@@ -10,4 +10,23 @@
   * example usage:
   * const anagrams = allAnagrams('abc');
   * console.log(anagrams); // [ 'abc', 'acb', 'bac', 'bca', 'cab', 'cba' ]
-  */
+  */
+
+function anagrams(string) {
+  const results = []; 
+  if (string.length < 2) {
+    return string;
+  }
+  for (let i = 0; i < string.length; i++) {
+    let firstChar = string[i];
+    let charsLeft = string.substring(0, i) + string.substring(i + 1);
+    let innerPermutations = anagrams(charsLeft);
+    for (let j = 0; j < innerPermutations.length; j++) {
+      results.push(firstChar + innerPermutations[j]);
+    }
+  }
+  return results;
+}
+
+
+console.log(anagrams('abc'));

armstrongNumbers/armstrongNumbers.js

@@ -0,0 +1,15 @@
+//An Armstrong number is an n-digit number that is equal to the sum of the n'th powers of its digits. Determine if the input numbers are Armstrong numbers.  Return either true or false .
+
+// For example with the number 153 there are 3 digits so you would add together the cubed values of all the digits like this: 1^3 + 5^3 + 3^3 === 153
+
+function isArmstrongNumber(n){
+  const arr = n.toString().split('');
+  let acc = 0;
+  for (let i = 0; i < arr.length; i++) {
+    acc = Math.pow(Number(arr[i]), arr.length) + acc;
+  }
+  if (acc === n) {
+    return true;
+  }
+  return false;
+}

array/array.js

@@ -7,3 +7,66 @@
  * How do these operations compare to that of a linked list?
  * How does the time complexity of insertion and deletion compare to that of a linked list?
  */
+class Array {
+  constructor(item) {
+    this[0] = item;
+    this.length = 1;
+  }
+
+  push(item){
+    this[this.length] = item;
+    this.length = this.length + 1;
+  }
+
+  pop(){
+    const toReturn = this.length-1;
+    delete this[(this.length-1)];
+    this.length = this.length-1;
+    return toReturn;
+  }
+
+  get(index){
+    return this[index];
+  }
+
+  delete(index){
+    // make sure to shift the items after deletion
+    for (let n = index; n + 1 < this.length; n++) {
+      this[n] = this[n + 1];
+    }
+    delete this[this.length - 1];
+    this.length = this.length - 1;
+  }
+
+}
+
+//**************************************************************************************************
+// Check if constructor works
+// const arr = new Array('first');
+// console.log(arr);
+// Check if push works (builds on constructor working test)
+// arr.push('second');
+// arr.push('third');
+// arr.push('fourth');
+// console.log(arr);
+// ***********************Leave this arr for remaining tests
+// check if length works
+// const arr = {
+//  0: 'first',
+//  1: 'second',
+//  2: 'third',
+//  3: 'fourth',
+// }
+// *****************************************
+// console.log(arr.length); // 4
+// check if push works 
+// arr.push('fifth');
+// console.log(arr);
+// check if pop works
+// arr.pop();
+// console.log(arr);
+// test get(index)
+// console.log(arr.get(1)); // third
+// test delete 
+// arr.delete(1);
+// console.log(arr);

binarySearch/binarySearch.js

@@ -9,7 +9,58 @@
  *  * const index = binarySearch([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2);
  *	* console.log(index); // 1
 **/
+// const binarySearch = (nums, target) => {
+//   function bSearch(nums, target, low, high) {
+//     if (high === low) {
+//       return low;
+//     }
+//     let mid = Math.ceil((low + high)/2);
+//     if (nums[mid] === target) {
+//       return mid;
+//     } else if (nums[mid] < target) {
+//      if (low === mid) {
+//        return false;
+//       else {
+//         return bSearch(nums, target, mid + 1, high);
+//       } 
+//     } if (nums[mid] > target) {
+//      if (high = mid) {
+//        return false;
+//       else {
+//         return bSearch(nums, target, low, mid - 1)
+//       }
+//     }
+//   }
+//   if (nums.length === 0) {
+//     return false;
+//   } else {
+//     return bSearch(nums, target, 0, nums.length - 1);
+//   }
+// };
 
 const binarySearch = (nums, target) => {
-
+  function bSearch(nums, target, low, high) {
+    if (target === nums[low]) {
+      return low;
+    }
+    if (nums[high] === target){
+      return high;
+    }
+    let middle = Math.floor((low + high) / 2);
+    let middleElement = nums[middle];
+    if (target === middleElement) {
+      return middle;
+    } else if (target > middleElement) {
+      return bSearch(nums, target, middle, high-1);
+    } else if (target < middleElement) {
+      return bSearch(nums, target, low+1, middle);
+    }
+  }
+  return bSearch(nums, target, 0, nums.length-1);
 };
+
+
+// const index = binarySearch([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2);
+// console.log(index); // 1
+
+export { binarySearch };

blueSquares/index.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<header>
+  <link rel="stylesheet" type="text/css" href="styles.css">
+  <script src="scripts.js"></script>
+</header>
+<body>
+  <div class="container">
+    <a class="box" href="#">1</a>
+    <a class="box" href="#">2</a>
+    <a class="box" href="#">3</a>
+    <a class="box" href="#">4</a>
+    <a class="box" href="#">5</a>
+    <a class="box" href="#">6</a>
+    <a class="box" href="#">7</a>
+    <a class="box" href="#">8</a>
+    <a class="box" href="#">9</a>
+    <a class="box" href="#">10</a>
+    <a class="box" href="#">11</a>
+    <a class="box" href="#">12</a>
+  </div>
+</body>
+</html>

blueSquares/styles.css

@@ -0,0 +1,26 @@
+body {
+}
+
+.container {
+  display: flex;
+  flex-direction: row;
+  flex-wrap: wrap;
+  justify-content: space-around;
+}
+
+.box {
+  background: tomato;
+  padding: 5px;
+  width: 200px;
+  height: 150px;
+  margin-top: 10px;
+  line-height: 150px;
+  color: white;
+  font-weight: bolder;
+  font-size: 3em;
+  text-align: center;
+}
+
+a:hover {
+  background-color: blue;
+}

brainTeasers/waterJugs.md

@@ -1,3 +1,5 @@
 You have a five-quart jug, a three-quart jug, and an unlimited supply of water (but no measuring cups).
 How would you come up with exactly four quarts of water?
 Note that the jugs are oddly shaped, such that filling up exactly "half" of the jug would be impossible.
+
+Take the full 5, use it to fill the 3-quart jug.  Empty the 3-quart jug, and place the remaining 2-quarts from the 5-quart jug into the small jug.  Refill the large jug.  Pour enough out of the large jug to fill the small jug.  This leaves 4 quarts in the larger jug.

breadthFirstSearch/breadthFirstSearch.js

@@ -14,4 +14,48 @@
  *	a: 2,
  * };
  * breadthFirstSearch(tree, 2);// will return true before it recursively searches `z`
- */
+ */
+
+// Use a helper queue
+class Queue {
+  constructor(){
+    this.items = [];
+    this.size = 0;
+  }
+  enqueue(item){
+    this.items.push(item);
+    this.size++;
+  }
+  dequeue(){
+    return this.items.shift();
+  }
+  isEmpty(){
+    if (this.size === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}
+const breadthFirst = (tree, value) => {
+  const queue = new Queue();
+// Enqueue first vertex
+// Dequeue first vertex, enqueue its children
+// Continue dequeueing a vertex and enqueueing its children
+}
+
+// Ben's code:
+// const BFS = (tree, searchTerm) => {
+//   const queue = Object.values(tree);
+//   while(queue.length > 0) {
+//     const value = queue.shift();
+//     if (value === searchTerm) {
+//       return true;
+//     }
+//     if (typeOf value === 'object' && value !== null && !Array.isArray(value)) {
+//       queue = queue.concat(Object.values(value));  // push would just nest array instead of making it a big array
+//     }
+//   }
+//   return false;
+// };
+// O(n)

bubbleSort/bubbleSort.js

@@ -22,5 +22,21 @@
 */
 
 const bubbleSort = (arr) => {
-  //code here
+  let sorted = false;
+  let temp = null;
+  while(!sorted) {
+    sorted = true;
+    for (let i = 0; i < arr.length - 1; i++) {
+      if(arr[i] > arr[i + 1]) {
+        swap = false;
+        temp = arr[i];
+        arr[i] = arr[i +1];
+        arr[i + 1] = temp;
+      }
+    }
+  }
+  return arr;
 };
+
+
+console.log(bubbleSort([2, 1, 3]));