Merge branch 'solutions' into master

Author: xandora

.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+    "extends": "airbnb-base",
+    "plugins": [
+        "import"
+    ]
+};

.gitignore

@@ -1 +1,4 @@
-.vscode
+.vscode
+node_modules
+.eslintrc
+.DS_Store

caesar/caesar.js

@@ -1,5 +1,26 @@
-const caesar = function() {
+const caesar = function(string, shift) {
+  return string
+    .split("")
+    .map(char => shiftChar(char, shift))
+    .join("");
+};
 
-}
+const codeSet = code => (code < 97 ? 65 : 97);
 
-module.exports = caesar
+// this function is just a fancy way of doing % so that it works with negative numbers
+// see this link for details:
+// https://stackoverflow.com/questions/4467539/javascript-modulo-gives-a-negative-result-for-negative-numbers
+const mod = (n, m) => (n % m + m) % m;
+
+const shiftChar = (char, shift) => {
+  const code = char.charCodeAt();
+
+  if ((code >= 65 && code <= 90) || (code >= 97 && code <= 122)) {
+    return String.fromCharCode(
+      mod(code + shift - codeSet(code), 26) + codeSet(code)
+    );
+  }
+  return char;
+};
+
+module.exports = caesar;

caesar/caesar.spec.js

@@ -1,23 +1,23 @@
-const caesar = require('./caesar')
+const caesar = require("./caesar");
 
-describe('caesar', function() {
-  it('works with single letters', function() {
-    expect(caesar('A', 1)).toEqual('B');
+describe("caesar", () => {
+  it("works with single letters", () => {
+    expect(caesar("A", 1)).toEqual("B");
   });
-  xit('works with words', function() {
-    expect(caesar('Aaa', 1)).toEqual('Bbb');
+  it("works with words", () => {
+    expect(caesar("Aaa", 1)).toEqual("Bbb");
   });
-  xit('works with phrases', function() {
-    expect(caesar('Hello, World!', 5)).toEqual('Mjqqt, Btwqi!');
+  it("works with phrases", () => {
+    expect(caesar("Hello, World!", 5)).toEqual("Mjqqt, Btwqi!");
   });
-  xit('works with negative shift', function() {
-    expect(caesar('Mjqqt, Btwqi!', -5)).toEqual('Hello, World!');
+  it("works with negative shift", () => {
+    expect(caesar("Mjqqt, Btwqi!", -5)).toEqual("Hello, World!");
   });
-  xit('wraps', function() {
-    expect(caesar('Z', 1)).toEqual('A');
+  it("wraps", () => {
+    expect(caesar("Z", 1)).toEqual("A");
   });
-  xit('works with large shift factors', function() {
-    expect(caesar('Hello, World!', 75)).toEqual('Ebiil, Tloia!');
+  it("works with large shift factors", () => {
+    expect(caesar("Hello, World!", 75)).toEqual("Ebiil, Tloia!");
   });
   xit('works with large negative shift factors', function() {
     expect(caesar('Hello, World!', -29)).toEqual('Ebiil, Tloia!');

calculator/calculator.js

@@ -1,32 +1,48 @@
-function add () {
-	
+function add(a, b) {
+  return a + b;
 }
 
-function subtract () {
-	
+function subtract(a, b) {
+  return a - b;
 }
 
-function sum () {
-	
+function sum(array) {
+  return array.reduce((total, current) => total + current, 0);
 }
 
-function multiply () {
-	
+function multiply(array) {
+    return array.length
+      ? array.reduce((accumulator, nextItem) => accumulator * nextItem)
+      : 0;
 }
 
-function power() {
-	
+function power(a, b) {
+  return Math.pow(a, b);
 }
 
-function factorial() {
-	
+function factorial(n) {
+  if (n == 0) return 1;
+  let product = 1;
+  for (let i = n; i > 0; i--) {
+    product *= i;
+  }
+  return product;
+}
+
+// This is another implementation of Factorial that uses recursion
+// THANKS to @ThirtyThreeB!
+function recursiveFactorial(n) {
+  if (n===0){
+    return 1;
+  }
+  return n * recursiveFactorial (n-1);
 }
 
 module.exports = {
-	add,
-	subtract,
-	sum,
-	multiply,
-    power,
-	factorial
-}
+  add,
+  subtract,
+  sum,
+  multiply,
+  power,
+  factorial
+};

fibonacci/fibonacci.js

@@ -1,5 +1,14 @@
-const fibonacci = function() {
+const fibonacci = function(count) {
+  if (count < 0) return "OOPS";
+  if (count == 0) return 0;
+  let a = 0;
+  let b = 1;
+  for (let i = 1; i < count; i++) {
+    const temp = b;
+    b = a + b;
+    a = temp;
+  }
+  return b;
+};
 
-}
-
-module.exports = fibonacci
+module.exports = fibonacci;

fibonacci/fibonacci.spec.js

@@ -1,31 +1,25 @@
-const fibonacci = require('./fibonacci')
+const fibonacci = require("./fibonacci");
 
-describe('fibonacci', function() {
-  it('works', function() {
+describe("fibonacci", () => {
+  it("works", () => {
     expect(fibonacci(4)).toEqual(3);
   });
-  xit('works', function() {
+  it("works", () => {
     expect(fibonacci(6)).toEqual(8);
   });
-  xit('works', function() {
+  it("works", () => {
     expect(fibonacci(10)).toEqual(55);
   });
-  xit('works', function() {
+  it("works", () => {
     expect(fibonacci(15)).toEqual(610);
   });
-  xit('works', function() {
+  it("works", () => {
     expect(fibonacci(25)).toEqual(75025);
   });
-  xit('doesn\'t accept negatives', function() {
+  it("doesn't accept negatives", () => {
     expect(fibonacci(-25)).toEqual("OOPS");
   });
-  xit('DOES accept strings', function() {
-    expect(fibonacci("1")).toEqual(1);
-  });
-  xit('DOES accept strings', function() {
-    expect(fibonacci("2")).toEqual(1);
-  });
-  xit('DOES accept strings', function() {
+  it("DOES accept strings", () => {
     expect(fibonacci("8")).toEqual(21);
   });
 });

findTheOldest/README.md

@@ -7,3 +7,4 @@ given an array of objects representing people with a birth and death year, retur
 - this can be done with a couple of chained array methods, or by using `reduce`.
 - One of the tests checks for people with no death-date.. use JavaScript's Date function to get their age as of today.
 
+

findTheOldest/findTheOldest.js

@@ -1,5 +1,16 @@
-let findTheOldest = function() {
+const findTheOldest = function(array) {
+  return array.reduce((oldest, currentPerson) => {
+    const oldestAge = getAge(oldest.yearOfBirth, oldest.yearOfDeath)
+    const currentAge = getAge(currentPerson.yearOfBirth, currentPerson.yearOfDeath)
+    return oldestAge < currentAge ? currentPerson : oldest
+  })
+}
 
+const getAge = function(birth, death) {
+  if (!death) {
+    death = new Date().getFullYear();
+  }
+  return death - birth;
 }
 
 module.exports = findTheOldest

findTheOldest/findTheOldest.spec.js

@@ -21,7 +21,7 @@ describe('findTheOldest', function() {
     ]
     expect(findTheOldest(people).name).toEqual('Ray');
   });
-  xit('finds the oldest person if someone is still living', function() {
+  it('finds the oldest person if someone is still living', function() {
     const people = [
       {
         name: 'Carly',
@@ -40,7 +40,7 @@ describe('findTheOldest', function() {
     ]
     expect(findTheOldest(people).name).toEqual('Ray');
   });
-  xit('finds the oldest person if the OLDEST is still living', function() {
+  it('finds the oldest person if the OLDEST is still living', function() {
     const people = [
       {
         name: 'Carly',
@@ -61,3 +61,4 @@ describe('findTheOldest', function() {
   });
 
 });
+

getTheTitles/README.md

@@ -1,4 +1,4 @@
-# Get the Titles!
+# GET THE TITLES!
 
 You are given an array of objects that represent books with an author and a title that looks like this:
 
@@ -24,3 +24,4 @@ getTheTitles(books) // ['Book','Book2']
 ## Hints
 
 - You should use a built-in javascript method to do most of the work for you!
+<Paste>

getTheTitles/getTheTitles.js

@@ -1,5 +1,5 @@
-const getTheTitles = function() {
-
+var getTheTitles = function(array) {
+  return array.map(book => book.title)
 }
 
-module.exports = getTheTitles;
+module.exports = getTheTitles

getTheTitles/getTheTitles.spec.js

@@ -1,16 +1,16 @@
 let getTheTitles = require('./getTheTitles')
 
 describe('getTheTitles', function() {
-    const books = [
-      {
-        title: 'Book',
-        author: 'Name'
-      },
-      {
-        title: 'Book2',
-        author: 'Name2'
-      }
-    ]
+  const books = [
+    {
+      title: 'Book',
+      author: 'Name'
+    },
+    {
+      title: 'Book2',
+      author: 'Name2'
+    }
+  ]
 
   it('gets titles', function() {
     expect(getTheTitles(books)).toEqual(['Book','Book2']);

helloWorld/helloWorld.js

@@ -1,5 +1,5 @@
-const helloWorld = function() {
-  return ''
+var helloWorld = function() {
+  return 'Hello, World!'
 }
 
 module.exports = helloWorld

leapYears/README.md

@@ -2,9 +2,7 @@
 
 Create a function that determines whether or not a given year is a leap year. Leap years are determined by the following rules:
 
-> Leap years are years divisible by four (like 1984 and 2004). However, years divisible by 100 are not leap years (such as 1800 and 1900) unless they are divisible by 400 (like 1600 and 2000, which were in fact leap years). (Yes, it's all pretty confusing)
->
-> -- <cite>[Learn to Program](https://pine.fm/LearnToProgram/chap_06.html) by Chris Pine</cite>
+>There is a leap year every year whose number is perfectly divisible by four - except for years evenly divisible by 100, which are not leap years unless evenly divisible by 400. The second part of the rule affects century years. For example; the century years 1600 and 2000 are leap years, but the century years 1700, 1800, and 1900 are not.
 
 ```javascript
 leapYears(2000) // is a leap year: returns true

leapYears/leapYears.js

@@ -1,5 +1,5 @@
-const leapYears = function() {
-
+var leapYears = function(year) {
+  return year % 4 === 0 && ( year % 100 !== 0 || year % 400 == 0)
 }
 
 module.exports = leapYears

leapYears/leapYears.spec.js

@@ -4,19 +4,19 @@ describe('leapYears', function() {
   it('works with non century years', function() {
     expect(leapYears(1996)).toEqual(true);
   });
-  xit('works with non century years', function() {
+  it('works with non century years', function() {
     expect(leapYears(1997)).toEqual(false);
   });
-  xit('works with ridiculously futuristic non century years', function() {
+  it('works with ridiculously futuristic non century years', function() {
     expect(leapYears(34992)).toEqual(true);
   });
-  xit('works with century years', function() {
+  it('works with century years', function() {
     expect(leapYears(1900)).toEqual(false);
   });
-  xit('works with century years', function() {
+  it('works with century years', function() {
     expect(leapYears(1600)).toEqual(true);
   });
-  xit('works with century years', function() {
+  it('works with century years', function() {
     expect(leapYears(700)).toEqual(false);
   });
 });