Followalong

exercises/anagrams/index.js

@@ -8,6 +8,65 @@
 //   anagrams('RAIL! SAFETY!', 'fairy tales') --> True
 //   anagrams('Hi there', 'Bye there') --> False
 
-function anagrams(stringA, stringB) {}
+function anagrams(stringA, stringB) {
+  return cleanString(stringA) === cleanString(stringB);
+}
+
+function cleanString(str) {
+  return str.replace(/[^\w]/g, '').toLowerCase().split('').sort().join('');
+}
 
 module.exports = anagrams;
+
+// first solution
+// function anagrams(stringA, stringB) {
+//     const aCharMap = buildCharMap(stringA);
+//     const bCharMap = buildCharMap(stringB);
+
+//     if (Object.keys(aCharMap).length !== Object.keys(bCharMap).length) {
+//       return false;
+//     }
+
+//     for (let char in aCharMap) {
+//       if (aCharMap[char] !== bCharMap[char]) {
+//         return false;
+//       }
+//     }
+//     return true;
+//   }
+
+//   function buildCharMap(str) {
+//     const charMap = {};
+//     for (let char of str.replace(/[^\w]/g, '').toLowerCase()) {
+//       charMap[char] = charMap[char] + 1 || 1;
+//     }
+
+//     return charMap;
+//   }
+
+//my half of an attempt
+// function anagrams(stringA, stringB) {
+//     const stringAMap = {}
+//     const stringBMap ={}
+//     stringA = stringA.replace(/[^\w]/g, "").toLowerCase();
+//     stringB = stringB.replace(/[^\w]/g, "").toLowerCase();
+//     if(stringA.length != stringB.length){
+//         return false
+//     } else {
+//         for(char of stringA){
+//             if(charAMap[char]){
+//                 charAMap[char]++
+//             } else {
+//                 charAMap[char] = 1
+//             }
+//         }
+//         for(char of stringB){
+//             if(charBMap[char]){
+//                 charBMap[char]++
+//             } else {
+//                 charBMap[char] = 1
+//             }
+//         }
+
+//     }
+// }

exercises/capitalize/index.js

@@ -7,6 +7,26 @@
 //   capitalize('a lazy fox') --> 'A Lazy Fox'
 //   capitalize('look, it is working!') --> 'Look, It Is Working!'
 
-function capitalize(str) {}
+function capitalize(str) {
+  let result = str[0].toUpperCase();
+  for (let i = 1; i < str.length; i++) {
+    if (str[i - 1] === ' ') {
+      result += str[i].toUpperCase();
+    } else {
+      result += str[i];
+    }
+  }
+  return result;
+}
 
 module.exports = capitalize;
+
+//first solution
+// function capitalize(str) {
+//     const words = [];
+//     for (let word of str.split(' ')) {
+//       words.push(word[0].toUpperCase() + word.slice(1));
+//     }
+
+//     return words.join(' ');
+//   }

exercises/chunk/index.js

@@ -8,6 +8,46 @@
 // chunk([1, 2, 3, 4, 5], 4) --> [[ 1, 2, 3, 4], [5]]
 // chunk([1, 2, 3, 4, 5], 10) --> [[ 1, 2, 3, 4, 5]]
 
-function chunk(array, size) {}
+function chunk(array, size) {
+  const chunked = [];
+  let index = 0;
+
+  while (index < array.length) {
+    chunked.push(array.slice(index, index + size));
+    index += size;
+  }
+  return chunked;
+}
+
+//first solution
+// function chunk(array, size) {
+//     const chunked = [];
+
+//     for (let element of array) {
+//       const last = chunked[chunked.length - 1];
+//       if (!last || last.length === size) {
+//         chunked.push([element]);
+//       } else {
+//         last.push(element);
+//       }
+//     }
+//     return chunked;
+//   }
+
+// My attempt
+//   const chunkArr = [];
+//   for (let i = 0; i < array.length - 1; i++) {
+//     let count = 0;
+//     let subArr = [];
+//     if (count < size) {
+//       count++;
+//       subArr.push(array[i]);
+//     } else if (count === size) {
+//       subArr.push(array[i]);
+//       chunkArr.push(subArr);
+//     }
+//   }
+//   console.log(chunkArr);
+//   return chunkArr;
 
 module.exports = chunk;

exercises/circular/index.js

@@ -12,6 +12,19 @@
 //   c.next = b;
 //   circular(l) // true
 
-function circular(list) {}
+function circular(list) {
+  let slow = list.getFirst();
+  let fast = list.getFirst();
+
+  while (fast.next && fast.next.next) {
+    slow = slow.next;
+    fast = fast.next.next;
+
+    if (slow === fast) {
+      return true;
+    }
+  }
+  return false;
+}
 
 module.exports = circular;

exercises/fib/index.js

@@ -8,6 +8,53 @@
 // Example:
 //   fib(4) === 3
 
-function fib(n) {}
+// recursive solution
+// memoization
+
+function memoize(fn) {
+  const cache = {};
+  return function (...args) {
+    if (cache[args]) {
+      return cache[args];
+    }
+
+    const result = fn.apply(this, args);
+    cache[args] = result;
+
+    return result;
+  };
+}
+
+function slowFib(n) {
+  if (n < 2) {
+    return n;
+  }
+
+  return fib(n - 1) + fib(n - 2);
+}
+
+const fib = memoize(slowFib);
 
 module.exports = fib;
+
+//my iterative solution
+// liner runtime
+// function fib(n) {
+//     const result = [0, 1];
+
+//     for (let i = 1; i < n; i++) {
+//       let sum = result[i] + result[i - 1];
+//       result.push(sum);
+//     }
+//     return result[n];
+//   }
+
+// recursive solution
+// is actually exponential runtime (very bad)
+// function fib(n) {
+//     if (n < 2) {
+//       return n;
+//     }
+
+//     return fib(n - 1) + fib(n - 2);
+//   }

exercises/fizzbuzz/index.js

@@ -12,6 +12,18 @@
 //   4
 //   buzz
 
-function fizzBuzz(n) {}
+function fizzBuzz(n) {
+  for (let i = 1; i <= n; i++) {
+    if (i % 3 === 0 && i % 5 === 0) {
+      console.log('fizzbuzz');
+    } else if (i % 3 === 0) {
+      console.log('fizz');
+    } else if (i % 5 === 0) {
+      console.log('buzz');
+    } else {
+      console.log(i);
+    }
+  }
+}
 
 module.exports = fizzBuzz;

exercises/fromlast/index.js

@@ -11,6 +11,20 @@
 //    list.insertLast('d');
 //    fromLast(list, 2).data // 'b'
 
-function fromLast(list, n) {}
+function fromLast(list, n) {
+  let fast = list.getFirst();
+  let slow = list.getFirst();
+  while (n > 0) {
+    fast = fast.next;
+    n--;
+  }
+
+  while (fast.next) {
+    fast = fast.next;
+    slow = slow.next;
+  }
+
+  return slow;
+}
 
 module.exports = fromLast;