Code Challenges

.gitignore

@@ -1 +1,3 @@
 .DS_Store
+node_modules
+package-lock.json

adders.js

@@ -0,0 +1,124 @@
+
+function NAND(x, y) {
+  return (!x || !y);
+}
+
+const NAND_truth = [
+	[false,false,true],
+	[false,true,true],
+	[true,false,true],
+	[true,true,false]
+];
+
+function XOR(x, y) {
+    const n = NAND(x, y)
+    return NAND(NAND(x,n), NAND(n, y))
+}
+
+const XOR_truth = [
+    [false,false,false],
+    [false,true,true],
+    [true,false,true],
+    [true,true,false]
+];
+
+function AND(x,y) {
+    const n = NAND(x, y);
+    return NAND(n, n);
+}
+
+const AND_truth = [
+    [false,false,false],
+    [false,true,false],
+    [true,false,false],
+    [true,true,true],
+]
+
+function OR(x, y) {
+    const n1 = NAND(x, x);
+    const n2 = NAND(y, y);
+    return NAND(n1, n2);
+}
+
+const OR_truth = [
+    [false,false,false],
+    [false,true,true],
+    [true,false,true],
+    [true,true,true]
+];
+
+function NOT(x) {
+    return !x;
+}
+
+const NOT_truth = [
+    [false,true],
+    [true,false]
+];
+
+tester(NAND, NAND_truth);
+tester(XOR, XOR_truth);
+tester(AND, AND_truth);
+tester(OR, OR_truth);
+tester(NOT, NOT_truth);
+
+function halfAdder(a, b) {
+    return [AND(a[0], b[0]), XOR(a[0], b[0])];
+}
+
+halfAdder_truth = [
+    [[false],[false],[false,false]],
+    [[false],[true],[false,true]],
+    [[true],[false],[false,true]],
+    [[true],[true],[true,false]]
+]
+
+tester(halfAdder, halfAdder_truth);
+
+function fullAdder(c, a, b) {
+    const ha1 = halfAdder(a[0], b[0]);
+    if (b[0] === true) process.exit();
+    const ha2 = halfAdder(c[0], ha1[1]);
+    const cOut = OR(ha1[0], ha2[0]);
+
+    return [cOut, ha2[1]];
+}
+
+const fullAdder_truth = [
+    [[false],[false],[false],[false,false]],
+    [[false],[false],[true],[false,true]],
+    [[false],[true],[false],[false,true]],
+    [[false],[true],[true],[true,false]],
+    [[true],[false],[false],[false,true]],
+    [[true],[false],[true],[true,false]],
+    [[true],[true],[false],[true,false]],
+    [[true],[true],[true],[true,true]]
+];
+
+tester(fullAdder, fullAdder_truth);
+
+function deepEquals (a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+	return a.every((e,i) => deepEquals(e, b[i]))
+    }
+    else return a === b;
+}
+
+function tester(fn, truth) {
+    console.log(`testing ${fn}`);
+    truth.forEach(e => {
+	const args = e.slice(0, e.length - 1);
+	const exp = e[e.length - 1];
+	const ans = fn.apply(null, args);
+	if (deepEquals(ans, exp))
+	    return
+	else {
+	    console.log(`args: ${args}`);
+	    console.log(`expected: ${exp}`);
+	    console.log(`got: ${ans}`);
+	    console.log();
+	}
+    });
+    console.log();
+}
+

allAnagrams/allAnagrams.js

@@ -1,7 +1,8 @@
 /**
- * Given a single input string, write a function that produces all possible anagrams
- * of a string and outputs them as an array. At first, don't worry about
- * repeated strings.  What time complexity is your solution?
+ * Given a  single input  string, write a  function that  produces all
+ * possible anagrams  of a  string and  outputs them  as an  array. At
+ * first, don't worry about repeated strings.  What time complexity is
+ * your solution?
  *
  * Extra credit: Deduplicate your return array.
  */
@@ -10,4 +11,71 @@
   * example usage:
   * const anagrams = allAnagrams('abc');
   * console.log(anagrams); // [ 'abc', 'acb', 'bac', 'bca', 'cab', 'cba' ]
-  */
+  */
+
+/** This algorithm  utilizes a recursive  tree structure to  avoid any
+  * duplicate strings; the constructor creates  a new object, and then
+  * recursively solves the anagram  by dividing (using 'divide()') the
+  * string  into  smaller  and  smaller pieces,  storing  each  single
+  * character in  a node with  the remaining string,  then recursively
+  * doing the  same for the  remaining string.  After it  has finished
+  * splitting  the  string into  individual  nodes,  it then  produces
+  * (using 'produce()') all of the  anagrams by walking each branch of
+  * the tree and collecting individual  letters; when it has reached a
+  * tip of a  branch, it stores the anagram in  the answer property of
+  * the root (an array of answers) to be returned at the end.
+  */
+
+class Anagram {
+  constructor(string, letter = null) {
+    this.string = string;
+    this.letter = letter;
+    this.children = [];
+    this.answer = [];
+    this.divide();
+    this.produce();
+  }
+
+  // divide() recursively  splits the  string into  a tree  of objects
+  // containing a letter and the remaining string
+  divide() {
+    // create a new tree branch for each character in the string, with
+    // the remaing string, and then create children from the remaining
+    // string's characters, etc., producing a big tree.
+    const arr = this.string.split('');
+    arr.forEach(l => {
+      const rest = arr.filter(x => x !== l).join('');
+      // create a new node with an individual letter and the remaining
+      // string; when Anagram's constructor  is called, it recursively
+      // breaks the string  into smaller and smaller  pieces, and then
+      // produces an answer, which is pushed onto the answer property.
+      const anagram = new Anagram(rest, l);
+      this.children.push(anagram);
+    });
+  }
+
+  // recursively runs  through all  branches of  the tree  picking out
+  // single letters and catenating them together to produce anagrams
+  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);
+  }
+}
+
+// acts as main(), returning the answers in an array
+function allAnagrams(s) {
+  return (new Anagram(s)).answer;
+}
+
+const anagrams = allAnagrams('abc');
+console.log(anagrams);
+const abcd = allAnagrams('abcd');
+console.log(abcd);

array/array.js

@@ -7,3 +7,71 @@
  * 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?
  */
+
+/*
+ * I think property accesses in an object are based upon a hash, and so would be
+ * constant time accesses.  Push and pop would be constant time accesses in a linked
+ * list.  However, searching for an item in a linked list is linear, whereas it would
+ * be constant time in an object.  Deleting an item in a linked list is a constant time
+ * operation, whereas it would be a linear operation in an object.  Tradeoffs.
+ */
+
+class Array {
+  constructor(value) {
+    this.length = 0;
+    this.arrayObj = {};
+  }
+
+  lastIndex() {
+    return this.length - 1;
+  }
+
+  nextIndex() {
+    this.length++;
+    return this.lastIndex();
+  }
+
+  reduceIndex() {
+    this.length--;
+    return this.length;
+  }
+
+  push(value) {
+    this.arrayObj[this.nextIndex()] = value;
+  }
+
+  pop() {
+    const value = this.arrayObj[this.lastIndex()];
+    delete this.arrayObj[this.reduceIndex()];
+    return value;
+  }
+
+  get(index) {
+    return this.arrayObj[index]
+  }
+
+  delete(index) {
+    let value;
+    if ((value = this.arrayObj[index])) {
+      for (let i = index; i < this.length - 1; i++) {
+        this.arrayObj[i] = this.arrayObj[i + 1];
+      }
+      this.pop();
+    }
+    return value;
+  }
+}
+
+const myArray = new Array();
+myArray.push('first');
+myArray.push('second');
+myArray.push('third');
+myArray.push('fourth');
+console.log(myArray);
+console.log(myArray.pop());
+console.log(myArray);
+console.log(myArray.get(2));
+console.log(myArray.get(3));
+console.log(myArray.get(0));
+console.log(myArray.delete(1));
+console.log(myArray);

binarySearch/binarySearch.js

@@ -10,6 +10,38 @@
  *	* console.log(index); // 1
 **/
 
+// binarySearch returns index of target number or -1 on failure
 const binarySearch = (nums, target) => {
 
+  const min = 0;
+  const max = nums.length;
+  const index = Math.floor((max - min) / 2);
+
+  // next index downward
+  const nextDown = (i) => {
+    if (i === min) return -1;
+    return Math.floor((i - min) / 2);
+  };
+
+  // next index upward
+  const nextUp = (i) => {
+    if (i === (max - 1)) return -1;
+    return i + Math.floor((max - i) / 2);
+  }
+
+  const bs = (i) => {
+    if (i === -1) return -1;
+    if (nums[i] === target) return i;
+    if (nums[i] > target) return bs(nextDown(i));
+    return bs(nextUp(i));
+  };
+
+  return bs(index);
 };
+
+const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+console.log(binarySearch(nums, 2));
+console.log(binarySearch(nums, 1));
+console.log(binarySearch(nums, 10));
+console.log(binarySearch(nums, 0));
+console.log(binarySearch(nums, 11));

brainTeasers/waterJugs.md

@@ -1,3 +1,10 @@
 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.
+
+Step 1: Fill the five-quart jug.
+Step 2: Using the five-quart jug, fill the three-quart jug.  The five-quart jug will have two quarts remaining.
+Step 3: Empty the three-quart jug, then pour the two quarts into the three-quart jug.
+Step 4: Fill the five-quart jug, then fill the three quart jug using the five-quart jug, removing one quart from the five-quart jug.
+
+Solution: The five-quart jug will have four quarts remaining.

breadthFirstSearch/breadthFirstSearch.js

@@ -14,4 +14,35 @@
  *	a: 2,
  * };
  * breadthFirstSearch(tree, 2);// will return true before it recursively searches `z`
- */
+ */
+
+const breadthFirstSearch = (tree, val) => {
+
+  let Q = (Object.entries(tree));
+
+  while (Q.length) {
+    const C = Q.shift();
+    console.log(C, "-", Q);
+    if (C[1] === val) return true;
+    if (typeof C[1] === 'object' && C[1] !== null) {
+      const O = Object.entries(C[1]);
+      O.forEach(e => Q.push(e));
+    }
+  }
+  return false;
+}
+
+const tree = {
+x: 1,
+y: 1,
+n: null,
+z: {
+	x: 1,
+	y: 1,
+	z: 1,
+	},
+a: 2,
+};
+
+console.log(breadthFirstSearch(tree, 2));
+console.log(breadthFirstSearch(tree, 3));