completed queueStack challenge

allAnagrams/allAnagrams.js

@@ -10,4 +10,30 @@
   * example usage:
   * const anagrams = allAnagrams('abc');
   * console.log(anagrams); // [ 'abc', 'acb', 'bac', 'bca', 'cab', 'cba' ]
-  */
+  */
+
+const allAnagrams = (str) => {
+  const combos = [];
+  combos.push(str);
+  const strArr = Array.from(str);
+  let length = str.length;
+  if (length < 2) {
+    return str;
+  } else if (length === 2) {
+    strArr[0] = strArr[1];
+    strArr[1] = str[0];
+    combos.push(strArr.join(''));
+    return combos;
+  } else {
+    for (i = str.length - 1; i >= 1; i--) {
+      console.log(strArr);
+      const tempLetter = strArr[i];
+      console.log('tempLetter is ' + tempLetter + ' at i: ' + i);
+      strArr[i] = strArr[i - 1];
+      strArr[i - 1] = tempLetter;
+      console.log('new arr: ' + strArr);
+      combos.push(strArr.join(''));
+    }
+  }
+  return combos;
+};

array/array.js

@@ -7,3 +7,78 @@
  * 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.head = null;
+    this.tail = null;
+    this.length = 0;
+  }
+  push(element) {
+    const newNode = {
+      index: 0,
+      value: element,
+      next: null,
+      previous: null,
+    }; 
+    if (this.length === 0) {
+      this.head = newNode;
+      this.tail = newNode;
+      newNode.index = this.length;
+      this.length++;
+    } else if (this.length === 1) {
+      this.head.next = newNode;
+      newNode.previous = this.head;
+      this.tail = newNode;
+      newNode.index = this.length;
+      this.length++;
+    } else {
+    this.tail.next = newNode;
+    newNode.previous = this.tail;
+    this.tail = newNode;
+    newNode.index = this.length;
+    this.length++;
+    }
+  }
+  pop() {
+    this.tail = this.tail.previous;
+  }
+  get(index) {
+    let currentNode = this.head;
+    while (currentNode.value) {
+      if (currentNode.index === index) {
+        return currentNode.value;
+      }
+      currentNode = currentNode.next;
+    }
+  }
+  delete(index) {
+    let currentNode = this.head;
+    let nodePrevious;
+    let nodeNext;
+    while (currentNode.value) {
+      if (currentNode.index === index - 1) {
+        nodePrevious = currentNode;
+        currentNode = currentNode.next;
+        currentNode = currentNode.next;
+        while (currentNode.next) {
+          currentNode.previous = nodePrevious;
+          nodePrevious = currentNode;
+          currentNode.index -= 1;
+          currentNode = currentNode.next;
+        }
+        currentNode.previous = nodePrevious;
+        currentNode.index -= 1;
+        currentNode = currentNode.previous;
+        while (currentNode.index !== index) {
+          currentNode = currentNode.previous;
+        }
+        nodeNext = currentNode
+        currentNode = currentNode.previous;
+        currentNode.next = nodeNext;
+      return;
+      }
+    currentNode = currentNode.next;
+    }
+  }
+}

binarySearch/binarySearch.js

@@ -11,5 +11,19 @@
 **/
 
 const binarySearch = (nums, target) => {
-
+	let min = 0;
+	let max = nums.length - 1;
+	let mid = Math.floor(max/2);
+	const search = () => {
+		if (target === nums[mid]) {
+			return mid;
+		} else if (target > nums[mid]) {
+			min = mid + 1;
+		} else if (target < nums[mid]) {
+			max = mid - 1;
+		}
+		mid = min + Math.floor((max - min) / 2);
+		return search();
+	}
+	return search();
 };

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.
+
+1.  Fill up the five-quart jug and pour it into the three-quart jug, leaving two quarts left in the five-quart jug.
+2.  Pour out the three-quart jug.
+3.  Pour the two quarts from the five-quart jug into the three-quart jug, leaving two quarts in the three-quart jug and the five-quart jug empty.  
+4.  Fill the the five-quart jug again.
+5.  Pour the five-quart jug into the three-quart jug until the three-quart jug is filled.
+6.  You now have four quarts of water in the five-quart jug.

bubbleSort/bubbleSort.js

@@ -23,4 +23,23 @@
 
 const bubbleSort = (arr) => {
   //code here
+  const sortArr = () => {
+    for (i = 0; i < arr.length;) {
+      if (i < arr.length - 1) {
+        if (arr[i] < arr [i + 1]) {
+          i++;
+        }
+        if (arr[i] > arr[i + 1]) {
+          const x = arr[i + 1];
+          arr[i + 1] = arr[i];
+          arr[i] = x;
+          sortArr();
+        }
+      }
+    }
+  }
+  sortArr();
+  return arr;
 };
+
+// I know the time complexity is really high, but to be honest, I had a hard time getting it to actually work so I don't think I can figure out how to reduce the time complexity.

callbackPractice/callbackPractice.js

@@ -20,51 +20,97 @@
 
 const foods = ['pineapple', 'mango', 'ribeye', 'curry', 'tacos', 'ribeye', 'mango'];
 
+const firstItem = (arr, cb) => {
+  cb(foods[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 = (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) => {
+  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) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === item) {
+      return cb(true);
+    }
+  }
+  return cb(false);
+}
+
 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 duplicateCheck = {};
+  const duplicatesRemoved = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (!duplicateCheck[arr[i]]) {
+      duplicateCheck[arr[i]] = 1;
+      duplicatesRemoved.push(arr[i]);
+    }
+  }
+  cb(duplicatesRemoved);
+}
+
 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) => {
+  arr.forEach((key, i) => {
+    cb(key, i)
+  });
+}
+
 forEach(foods, (value, index) => {
   console.log(`${value} is at index ${index}.`);
 });

commonCharacters/commonCharacters.js

@@ -7,3 +7,13 @@
  * Returns: 'aeiou'
 */
 
+const commonCharacters = (str1, str2) => {
+  let tempSet = new Set(str2);
+  let ansStr = '';
+  for (let i = 0; i < str1.length; i++) {
+    if (tempSet.has(str1[i]) && str1[i] !== ' ') {
+      ansStr += str1[i];
+    }
+  }
+  return ansStr;
+};