bloominstituteoftechnology · jeshsy · Jul 10, 2017 · Jul 10, 2017 · Jul 10, 2017 · Jul 11, 2017
diff --git a/allAnagrams/allAnagrams.js b/allAnagrams/allAnagrams.js
@@ -10,4 +10,25 @@
   * example usage:
   * const anagrams = allAnagrams('abc');
   * console.log(anagrams); // [ 'abc', 'acb', 'bac', 'bca', 'cab', 'cba' ]
-  */
+  */
+
+  // thoughts. probably going to split that string up into single characters.
+  // maybe use set to get rid of dupes
+  // permutations, but i dunno how to write this
+  // time complexity of n!, which is actually the worst
+  // recursion? I have to stop attempting making everything with recursion.
+  // legit first thought was recursion. stahpw
+  // can stop after string gets completely reversed(maybe multiple of same character might break this)
+
+
+  const allAnagrams = (word) => {
+    arr = [word];
+    if (word.length < 2) return arr;
+    splitChars = word.split('');
+    const recurseAnagrams = () => {
+      for (let i = 0; i < splitChars.length; i++) {
+
+      } 
+    }
+    return arr;
+  }
diff --git a/array/array.js b/array/array.js
@@ -7,3 +7,23 @@
  * 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() {
+    this.indicator = 0;
+    this.array = {};
+  }
+  push(value) {
+    this.array[indicator] = value;
+    this.indicator ++; 
+  }
+  pop() {
+
+  }
+  get(index) {
+
+  }
+  delete(index) {
+
+  }
+}
diff --git a/binarySearch/binarySearch.js b/binarySearch/binarySearch.js
@@ -11,5 +11,19 @@
 **/
 
 const binarySearch = (nums, target) => {
-
-};
+  let min = 0;
+  let max = nums.length;
+  const search = () => {
+    if(nums[max / 2] > target) {
+      max = max / 2 - 1;
+      search();
+    }
+    if(nums[max / 2] < target) {
+      min = max / 2 + 1;
+      search();
+    }
+    if(nums[max / 2] === target) {
+      return max / 2;
+    }
+  };
+};
diff --git a/blueSquares/index.html b/blueSquares/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>title</title>
+  </head>
+  <body>
+
+  </body>
+</html>
diff --git a/blueSquares/script.js b/blueSquares/script.js
diff --git a/blueSquares/styles.css b/blueSquares/styles.css
diff --git a/brainTeasers/waterJugs.md b/brainTeasers/waterJugs.md
@@ -1,3 +1,8 @@
 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.
+
+measure the 5, pour into the 3 to get 2 quarts remaining in the 5 quart. Do this twice.
+
+Apparently you can't do that, as you dont have any other sort of containers.
+So you pour 3 qt into the 5 twice. 5 qts in the 5 and 1 in the 3. Dump the 5, pour the 1 qt into the 5 container, and then pour 3 more into it to get the 4.
diff --git a/bubbleSort/bubbleSort.js b/bubbleSort/bubbleSort.js
@@ -22,5 +22,24 @@
 */
 
 const bubbleSort = (arr) => {
+  if (arr === null) return null;
+  let sorted = false;
+  while (sorted === false) {
+    let counter = 0;
+    for (let i = 1; i < arr.length; i++) {
+      if (arr[i - 1] > arr[i]) {
+        let temp = 0;
+        temp += arr[i];
+        arr[i] = arr[i - 1];
+        arr[i - 1] = temp;
+        sorted = false;
+        counter += 1;
+      }
+    }
+    if (counter === 0) sorted = true;
+  }
+  return arr;
   //code here
 };
+
+console.log(bubbleSort([2, 1, 3, 2, 1, 11, 4, 1, 4, 7, 12, 5]));
diff --git a/callbackPractice/callbackPractice.js b/callbackPractice/callbackPractice.js
@@ -20,51 +20,83 @@
 
 const foods = ['pineapple', 'mango', 'ribeye', 'curry', 'tacos', 'ribeye', 'mango'];
 
+const firstItem = (arr, cb) => {
+  cb(arr[0]);
+}
+
 firstItem(foods, (firstItem) => {
   console.log(`The first item is ${firstItem}.`);
 });
 
 // Write a function called getLength that passes the length of the array into the callback
 
+const getLength(arr, cb) => {
+  cb(arr.length);
+}
+
 getLength(foods, (length) => {
   console.log(`The length of the array is ${length}.`);
 });
 
 // Write a function called last which passes the last item of the array into the callback
 
+const last(arr, cb) => {
+  cb(arr[arr.length - 1]);
+}
+
 last(foods, (lastItem) => {
   console.log(`The last item in the array is ${lastItem}.`);
 });
 
 // Write a function called sumNums that adds two numbers and passes the result to the callback
 
+const sumNums(a, b, cb) => {
+  cb(a + b);
+}
 
 sumNums(5, 10, (sum) => {
   console.log(`The sum is ${sum}.`);
 });
 
 // Write a function called multiplyNums that adds two numbers and passes the result to the callback
 
+const multiplyNums(a, b, cb) => {
+  cb(a * b);
+}
+
 multiplyNums(5, 10, (product) => {
   console.log(`The product is ${product}.`);
 });
 
 // Write a function called contains that checks if an item is present inside of the given array.
 // Pass true to the callback if it is, otherwise pass false
 
+const contains(arr, i, cb) => {
+  cb(arr.includes(i));
+}
+
 contains(foods, 'ribeye', (result) => {
   console.log(result ? 'ribeye is in the array' : 'ribeye is not in the array');
 });
 
 // Write a function called removeDuplicates that removes all duplicate values from the given array.
 // Pass the array to the callback function.  Do not mutate the original array.
 
+const removeDuplicates(arr, cb) => {
+
+}
+
 removeDuplicates(foods, (uniqueFoods) => {
   console.log(`foods with duplicates removed: ${uniqueFoods}`);
 });
 
 // Write a function called forEach that iterates over the provided array and passes the value and index into the callback.
 
+const forEach(arr, cb) => {
+  for (let i = 0; i < arr.length; i++) {
+
+  }
+}
 forEach(foods, (value, index) => {
   console.log(`${value} is at index ${index}.`);
 });
diff --git a/commonCharacters/commonCharacters.js b/commonCharacters/commonCharacters.js
@@ -7,3 +7,6 @@
  * Returns: 'aeiou'
 */
 
+const commonCharacters = (a, b) => {
+
+}
diff --git a/constructors/constructors.js b/constructors/constructors.js
@@ -21,4 +21,43 @@
  *
  * This is how you would structure the game objects in an actual game
  * application in Unity or another similar framework.
- */
+ */
+
+class NPC {
+  constructor(options) {
+    this.hp = options.hp;
+    this.str = options.str;
+    this.def = options.def;
+    this.spd = options.spd;
+  }
+}
+
+class Humanoid extends NPC {
+  constructor(options) {
+    super(options);
+    this.job = options.job;
+  }
+}
+
+class Human extends Humanoid {
+  constructor(options) {
+    super(options);
+    this.race = options.race;
+  }
+}
+
+class Soldier extends Human {
+  constructor(options) {
+    super(options);
+    this.hp += 10;
+    };
+}
+
+ const jeff = new Soldier({
+  hp: 10,
+  str: 10,
+  def: 10,
+  spd: 10,
+  job: 'Baker'
+ });
+ console.log(jeff); 
diff --git a/evenOccurences/evenOccurences.js b/evenOccurences/evenOccurences.js
@@ -11,5 +11,19 @@
  *    */
 
 const evenOccurence = (arr) => {
+    const checker = new Set();
+    let answer = [];
+    let temp = 0;
+    for (let i = 0; i < arr.length; i++) {
+      checker.add(arr[i]);
+      if (checker.size === temp) answer.push(arr[i]);
+      // console.log('size',checker.size, 'temp', temp, 'bool', checker.size === temp);
+      temp += 1;
+    }
+    if (answer.length === 0) return null;
+    return answer[0];
   // Your code here.
 };
+
+const tester = [1,2,2,22,3,44,23,12,22,4];
+console.log(evenOccurence(tester)); //should be 22
diff --git a/insertionSort/insertionSort.js b/insertionSort/insertionSort.js
@@ -11,6 +11,16 @@
 // insertionSort([2, 1, 3, 7, 4, 2, 9, 3, 8]); // yields [1, 2, 2, 3, 3, 4, 7, 8, 9]
 
 const insertionSort = (array) => {
+  for (let i = 1; i < array.length; i++) {
+    for (let j = 0; j < i; j++) {
+      if(array[i] < array[j]) {
+        let removed = array.splice(i, 1);
+        array.splice(j, 0, removed[0]);
+      }
+    }
+  }
   // Your code goes here. Feel free to add helper functions if needed.
   return array;
-};
+};
+
+console.log(insertionSort([2, 1, 3, 7, 4, 2, 9, 3, 8]));
diff --git a/isUnique/isUnique.js b/isUnique/isUnique.js
@@ -4,6 +4,12 @@
 */
 
 const isUnique = (str) => {
+  const tester = str.split("").sort();
+  let check = true;
+  for (let i = 1; i < tester.length; i++) {
+    if (tester[i] === tester[i-1]) check = false;
+  }
+  return check;
 
 };
 

diff --git a/largestPrimePalindrome/largestPrimePalindrome.js b/largestPrimePalindrome/largestPrimePalindrome.js
@@ -6,3 +6,30 @@
  * Extra credit: Modify the function to look for the largest prime palindrome less than any provided number.
  * Extra credit 2: How can you improve the time complexity?  (Google: Sieve of Eratosthenes)
  */
+const isPalindrome = (suspect) => {
+  // checks to see if it's a palindrome
+  // turns int to str, then splits into array of 1 letter characters
+  // then reverses this array, and joins it back to a string
+  // then turns this reversed string back into an int, and checks if the two are equal
+  if (suspect === parseInt(suspect.toString().split('').reverse().join(''), 10)) return true;
+    return false;
+}
+
+const isPrime = (suspect) => {
+  if (suspect === 1) return false;
+  else if (suspect === 2) return true;
+  for (let j = 2; j < suspect; j++) {
+    if (suspect % j === 0) return false;
+  }
+  return true;
+}
+
+const largestPP = (limit) => {
+  const PParray = [];
+  for (let i = 1; i < limit; i++) {
+    if (isPalindrome(i) && isPrime(i)) PParray.push(i);
+  }
+  return PParray.pop();
+}
+
+// console.log(largestPP(1000));
diff --git a/logicGates/logicGates.js b/logicGates/logicGates.js
@@ -11,23 +11,32 @@
 
 const NAND = (x, y) => {
 	// You can use whatever JS operators that you would like: &&, ||, !
+  let temp = !(x && y);
+  if (temp === true) return 1;
+  return 0;
 };
 
 const NOT = (n) => {
+  return NAND(n, n);
 	// Do not use !, &&, or ||
 };
 
 const AND = (x, y) => {
+  return NOT(NAND(x, y));
 	// Do not use &&, ||, or !
 	// You can use any of the functions that you have already written
 };
 
 const OR = (x, y) => {
+  return NAND(NAND(x, x), NAND(y, y));
+  // so it'll be false if x is true and same for y
+  // so if either are false, nand will pull out true
 	// Do not use ||, &&, or !
 	// You can use any of the functions that you have already written
 };
 
 const XOR = (x, y) => {
+  AND(OR(x, y), NAND(x, y));
 	// Do not use ||, &&, or !
 	// You can use any of the functions that you have already written
 };
diff --git a/longestRun/longestRun.js b/longestRun/longestRun.js
@@ -8,3 +8,7 @@
 * Input: "abcdefgh" Output: [ 0, 0 ]
 * Input: "aabbbcccc" Output: [ 5, 4 ]
 */
+
+const longestRun = (str) => {
+  let arr = [0, 0];
+}
-Original file line number
+Diff line change
@@ Expand Up / @@ -7,3 +7,6 @@ @@
      * Returns: 'aeiou'
     */
+    const commonCharacters = (a, b) => {
+    }