Some labs finished

README.md

@@ -0,0 +1,3 @@
+# AlgoCasts
+
+Companion repo to a course on Udemy.com

completed_exercises/adding_big_sums.js

@@ -0,0 +1,9 @@
+function aVeryBigSum(ar) {
+    let sum = 0
+
+    for (let index of ar) {
+        sum+=index
+    }
+
+    return sum
+}

completed_exercises/anagrams/index.js

@@ -0,0 +1,51 @@
+// --- Directions
+// Check to see if two provided strings are anagrams of eachother.
+// One string is an anagram of another if it uses the same characters
+// in the same quantity. Only consider characters, not spaces
+// or punctuation.  Consider capital letters to be the same as lower case
+// --- Examples
+//   anagrams('rail safety', 'fairy tales') --> True
+//   anagrams('RAIL! SAFETY!', 'fairy tales') --> True
+//   anagrams('Hi there', 'Bye there') --> False
+
+function anagrams(stringA, stringB) {
+  return cleanString(stringA) === cleanString(stringB);
+}
+
+function cleanString(str) {
+  return str
+    .replace(/[^\w]/g, '')
+    .toLowerCase()
+    .split('')
+    .sort()
+    .join('');
+}
+
+module.exports = anagrams;
+
+// 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;
+// }

completed_exercises/area_circ_circle.js

@@ -0,0 +1,19 @@
+function area(r) {
+
+    let rSquared = r*r
+
+    console.log(Math.PI * rSquared)
+
+}
+
+function circumference(r){
+
+    let rTimes2 = r*2
+
+    console.log(Math.PI * rTimes2)
+
+}
+
+area(4)
+
+circumference(4)

completed_exercises/array_comparisons.js

@@ -0,0 +1,20 @@
+function compareTriplets(a, b) {
+    let aWins = 0
+    let bWins = 0
+    let finalArray;
+
+
+    for (let i = 0; i < a.length; i++){
+        if ( a[i] > b[i]){
+            aWins++;
+        }
+        else if ( a[i] < b[i]){
+            bWins++;
+        }
+        else{
+            finalArray
+        }
+
+    }
+    return finalArray = [aWins, bWins]
+}

completed_exercises/array_sum.js

@@ -0,0 +1,7 @@
+function simpleArraySum(ar) {
+    let sum = 0
+    for ( let i = 0; i < ar.length; i++){
+        sum += ar[i]
+    }
+    return sum
+}

completed_exercises/bst/index.js

@@ -0,0 +1,49 @@
+// --- Directions
+// 1) Implement the Node class to create
+// a binary search tree.  The constructor
+// should initialize values 'data', 'left',
+// and 'right'.
+// 2) Implement the 'insert' method for the
+// Node class.  Insert should accept an argument
+// 'data', then create an insert a new node
+// at the appropriate location in the tree.
+// 3) Implement the 'contains' method for the Node
+// class.  Contains should accept a 'data' argument
+// and return the Node in the tree with the same value.
+// If the value isn't in the tree return null.
+
+class Node {
+  constructor(data) {
+    this.data = data;
+    this.left = null;
+    this.right = null;
+  }
+
+  insert(data) {
+    if (data < this.data && this.left) {
+      this.left.insert(data);
+    } else if (data < this.data) {
+      this.left = new Node(data);
+    } else if (data > this.data && this.right) {
+      this.right.insert(data);
+    } else if (data > this.data) {
+      this.right = new Node(data);
+    }
+  }
+
+  contains(data) {
+    if (this.data === data) {
+      return this;
+    }
+
+    if (this.data < data && this.right) {
+      return this.right.contains(data);
+    } else if (this.data > data && this.left) {
+      return this.left.contains(data);
+    }
+
+    return null;
+  }
+}
+
+module.exports = Node;

completed_exercises/bst/test.js

@@ -0,0 +1,41 @@
+const Node = require('./index');
+
+test('Node is a constructor', () => {
+  expect(typeof Node.prototype.constructor).toEqual('function');
+});
+
+test('Node can insert correctly', () => {
+  const node = new Node(10);
+  node.insert(5);
+  node.insert(15);
+  node.insert(17);
+
+  expect(node.left.data).toEqual(5);
+  expect(node.right.data).toEqual(15);
+  expect(node.right.right.data).toEqual(17);
+});
+
+test('Contains returns node with the same data', () => {
+  const node = new Node(10);
+  node.insert(5);
+  node.insert(15);
+  node.insert(20);
+  node.insert(0);
+  node.insert(-5);
+  node.insert(3);
+
+  const three = node.left.left.right;
+  expect(node.contains(3)).toEqual(three);
+});
+
+test('Contains returns null if value not found', () => {
+  const node = new Node(10);
+  node.insert(5);
+  node.insert(15);
+  node.insert(20);
+  node.insert(0);
+  node.insert(-5);
+  node.insert(3);
+
+  expect(node.contains(9999)).toEqual(null);
+});