solutions

allAnagrams/allAnagrams.js

@@ -10,4 +10,17 @@
   * example usage:
   * const anagrams = allAnagrams('abc');
   * console.log(anagrams); // [ 'abc', 'acb', 'bac', 'bca', 'cab', 'cba' ]
-  */
+  */
+
+  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;
+};

array/array.js

@@ -7,3 +7,39 @@
  * 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.array = {};
+     this.key = 0;
+   }
+   push(value) {
+     this.array[this.key] = value;
+     this.key += 1
+   }
+   pop() {
+     const value = this.array[this.key - 1];
+     delete this.array[this.key - 1];
+     this.key -= 1;
+     return value;
+   }
+   get(index) {
+     //console.log(index);
+     return this.array[index];
+   }
+   delete(index) {
+    delete this.array[index];
+     for (let i = index; i < this.key; i++) {
+       this.array[i] = this.array[i + 1];
+     }
+     this.key--;
+   }
+ }
+
+ const a = new Array();
+ a.push(5);
+ a.push(53);
+ a.push(54);
+ console.log(a);
+ a.delete(0);
+ console.log(a);

binarySearch/binarySearch.js

@@ -11,5 +11,18 @@
 **/
 
 const binarySearch = (nums, target) => {
+  let high = nums.length - 1;
+  let low = 0;
+  let middle;
 
+  while (low < high) {
+    middle = Math.floor((low + high) / 2);
+    if (target === nums[middle]) return middle;
+    else if (target > nums[middle]) {
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return 'not found';
 };

brainTeasers/waterJugs.md

@@ -1,3 +1,9 @@
 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.
+
+i would fill both the 3 and 5 quart jugs at the same time and stop the water flow when the 3
+quart jug is full. Now the 5 quart jug has 3 quarts and the 3 quart jug is filled. Then, i will pour
+out the 3 quart jug in the 5 quart jug until it is filled. Now my 3 quart jug is left with 1 quart. Now
+i empty the 5 quart jug and pour the 1 quart from the 3 quart jug. Finally, i will fill the 3 quart jug
+and then pour it in the 5 quart jug that currently has one quart and i will end up with 4 quarts in the 5 quart jug.

breadthFirstSearch/breadthFirstSearch.js

@@ -14,4 +14,16 @@
  *	a: 2,
  * };
  * breadthFirstSearch(tree, 2);// will return true before it recursively searches `z`
- */
+ */
+
+ const breadthFirstSearch = (tree, searchTerm) => {
+  let queue = Object.values(tree);
+  while (queue.length > 0) {
+    value = queue.shift();
+    if (value === searchTerm) return true;
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      queue = queue.concat(Object.values(value));
+    }
+  }
+  return false;
+};

bubbleSort/bubbleSort.js

@@ -23,4 +23,22 @@
 
 const bubbleSort = (arr) => {
   //code here
+  const bubbleSort = (arr) => {
+  let swappedValue;
+  do {
+    swappedValue = false;
+    for (let i = 0; i < arr.length; i++) {
+      console.log(arr);
+      if (arr[i] > arr[i + 1]) { // [2, 1, 3]
+        let temp = arr[i]; // temp = 2
+        arr[i] = arr[i + 1]; // [1, 1, 3] temp = 2;
+        arr[i + 1] = temp; // [1, 2, 3];
+        swappedValue = true;
+      }
+    }
+  } while (swappedValue);
+  return arr;
+};
+
+console.log(bubbleSort([5, 6, 7, 3, 2, 1])); // returns [1, 2, 3]
 };

callbackPractice/callbackPractice.js

@@ -19,52 +19,79 @@
 // Write a function called firstItem that passes the first item of the given array to the callback function
 
 const foods = ['pineapple', 'mango', 'ribeye', 'curry', 'tacos', 'ribeye', 'mango'];
+const firstItem = (arr, cb) => {
+  return 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) => {
+  return 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 = (x, y, cb) => {
+  cb(x + y);
+};
 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 = (x, y, cb) => {
+  return cb(x * y);
+};
 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, item, cb) => {
+  return cb(arr.includes(item));
+};
 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) => {
+//   const set = new Set(arr);
+//   console.log(set);
+//   return cb(set);
+// };
+const removeDuplicates = (arr, cb) => {
+  const newArray = arr.filter((item, index, inputArray) => {
+    return inputArray.indexOf(item) === index;
+  });
+  cb(newArray);
+};
 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++) {
+    cb(arr[i], i);
+  }
+};
 forEach(foods, (value, index) => {
   console.log(`${value} is at index ${index}.`);
 });

commonCharacters/commonCharacters.js

@@ -1,9 +1,33 @@
 /**
- * Common Characters: 
- * Write a function that accepts two strings as arguments, and returns only the characters that are common to both strings. * 
- * Your function should return the common characters in the same order that they appear in the first argument. 
- * Do not return duplicate characters and ignore whitespace in your returned string.  * 
- * Example: commonCharacters('acexivou', 'aegihobu')  * 
+ * Common Characters:
+ * Write a function that accepts two strings as arguments, and returns only the characters that are common to both strings. *
+ * Your function should return the common characters in the same order that they appear in the first argument.
+ * Do not return duplicate characters and ignore whitespace in your returned string.  *
+ * Example: commonCharacters('acexivou', 'aegihobu')  *
  * Returns: 'aeiou'
 */
 
+const eliminateWhitespace = (str) => {
+  const re = /\s/g;
+  str = str.replace(re, '');
+  return str;
+};
+
+const commonCharacters = (str1, str2) => {
+  const uniqueCharacters = new Set();
+  str1 = eliminateWhitespace(str1);
+  str2 = eliminateWhitespace(str2);
+  str1 = str1.split('');
+
+  for (let i = 0; i < str1.length; i++) {
+    if (str2.includes(str1[i])) {
+      uniqueCharacters.add(str1[i]);
+    }
+  }
+  const commonLetters = Array.from(uniqueCharacters).join('');
+  return commonLetters;
+};
+
+let str1 = 'acex ivou';
+const str2 = 'aegihobu';
+console.log(commonCharacters(str1, str2)); // --> 'aeiou'

constructors/constructors.js

@@ -21,4 +21,55 @@
  *
  * 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.power = options.power;
+    this.speed = options.speed
+
+  }
+  delete() {
+    `${this.name} has been removed from the game`;
+  }
+}
+
+class Humanoid extends NPC {
+  constructor(options) {
+    super(options);
+    this.name = options.name;
+    this.height = options.height;
+    this.gender = options.gender;
+  }
+  walk() {
+    `${this.name} is walking`;
+  }
+}
+
+class Human extends Humanoid {
+  constructor(options) {
+    this.language = options.language;
+    this.liniage = options.liniage;
+  }
+  talk() {
+    `${this.name} is talking ${this.language}`
+  }
+}
+
+class Elf extends Humanoid {
+  constructor(options) {
+    this.clan = options.clan;
+  }
+  shootBow() {
+    `${this.name} shot a bow!`;
+  }
+}
+
+class Orc extends Humanoid {
+  constructor(options) {
+    this.tribe = options,tribe;
+  }
+  swingSword() {
+    `${this.name} swung a sword!`;
+  }
+}

evenOccurences/evenOccurences.js

@@ -10,6 +10,23 @@
  *    * console.log(onlyEven); //  4
  *    */
 
-const evenOccurence = (arr) => {
-  // Your code here.
-};
+ const evenOccurence = (arr) => {
+   // Your code here.
+   let numberStorage = {};
+   arr.forEach((number) => {
+     if (numberStorage[number]) {
+       numberStorage[number] = numberStorage[number]+1
+     } else {
+       numberStorage[number] = 1;
+     }
+   })
+   for (let i = 0; i < arr.length; i++) {
+     let currentNumber = arr[i];
+     if (numberStorage[currentNumber] % 2 === 0) {
+       return currentNumber;
+     }
+   }
+   return null;
+ };
+ const onlyEven = evenOccurence([1, 7, 2, 4, 5, 1, 6, 8, 9, 6, 4, 1]);
+ console.log(onlyEven);