Solutions

allAnagrams/allAnagrams.js

@@ -10,4 +10,16 @@
   * example usage:
   * const anagrams = allAnagrams('abc');
   * console.log(anagrams); // [ 'abc', 'acb', 'bac', 'bca', 'cab', 'cba' ]
-  */
+  */
+    const allAnagrams = (word) => {
+     let arr = [];
+     for(let i = 0; i < word.length; i++) {
+       for(let j = word.length; j>0; j--) {
+         let cur = word.substring(i, i + 1);
+         let before = word.substring(0, i);
+         let after = word.substring(i + 1);
+         console.log( cur+before + after);
+       }
+      }
+  }
+  const anagrams = allAnagrams('abc');

array/array.js

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

binarySearch/binarySearch.js

@@ -12,4 +12,26 @@
 
 const binarySearch = (nums, target) => {
 
+	let min = 0;
+  let max = nums.length - 1;
+   let mid = Math.floor((min + max)/2);
+
+    while (min <= max){
+
+       mid = Math.floor((min + max)/2);
+
+    	if(nums[mid] === target) {
+    		return mid;
+    	}
+        else if (nums[mid] < target){
+      	    min = mid + 1;
+        }
+        else if (nums[mid] > target){
+    	    max = mid - 1;
+        }
+    }
+  return -1;
+
 };
+ const index = binarySearch([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2);
+ console.log(index); // 1

bubbleSort/bubbleSort.js

@@ -23,4 +23,22 @@
 
 const bubbleSort = (arr) => {
   //code here
+  let n = arr.length;
+  let temp;
+
+    for(let i = 0; i < n; i++) {
+        for(let j = 1; j < (n - i); j++) {
+
+            if (arr[j - 1] > arr[j]) {
+                temp = arr[j - 1];
+                arr[j - 1] = arr[j];
+                arr[j] = temp;
+            }
+
+        }
+    }
+  console.log(arr);
 };
+
+bubbleSort([2, 1, 3]);
+bubbleSort([4, 9, 3]);

callbackPractice/callbackPractice.js

@@ -19,52 +19,81 @@
 // 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) => {
+  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
 
+// Write a function called getLength that passes the length of the array into the callback
+const getLength = (arr, cb) => {
+  cb(arr.length);
+};
+const length = getLength;
 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
 
+// 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 = (num1, num2, cb) => {
+  cb(num1 + num2);
+};
 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 = (num1, num2, cb) => {
+  cb(num1 * num2);
+};
 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) => {
+  if (cb(arr.indexOf(item) >= 0)){ return true;}
+  return 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 obj = {};
+  const aarr = [];
+  arr.forEach((item) => {
+    if (!obj[item]) {
+      obj[item] = true;
+      aarr.push(item);
+    }
+  }
+  cb(aarr);
+};
 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}.`);
 });