All passing

indifferentghost · indifferentghost · commit 2ed323772976 · 2017-10-04T22:23:09.000-07:00
diff --git a/src/class.js b/src/class.js
@@ -7,7 +7,15 @@
 // for a potential password that will be compared to the `password` property.
 // Return true if the potential password matches the `password` property.  Otherwise return false.
 
-// code here
+class User {
+  constructor(options) {
+    this.email = options.email;
+    this.password = options.password;
+  }
+  comparePasswords(passMatch) {
+    return this.password === passMatch;
+  }
+}
 
 // Part 2
 // Create a class called `Animal` and a class called `Cat` using ES6 classes.
@@ -19,8 +27,24 @@
 // `meow` that should return the string `<name> meowed!` where `<name>` is the `name`
 // property set on the Cat instance.
 
-// code here
+class Animal {
+  constructor(options) {
+    this.age = options.age;
+  }
+  growOlder() {
+    return ++this.age;
+  }
+}
 
+class Cat extends Animal {
+  constructor(options) {
+    super(options);
+    this.name = options.name;
+  }
+  meow() {
+    return `${this.name} meowed!`;
+  }
+}
 /* eslint-disable no-undef */
 
 module.exports = {
diff --git a/src/prototype.js b/src/prototype.js
@@ -49,6 +49,57 @@
   hamsterHuey.destroy(); // returns 'Game object was removed from the game.'
 */
 
+/*
+  GameObject
+    createdAt
+    dimensions
+    destroy() // prototype method -> returns the string 'Game object was removed from the game.'
+*/
+function GameObject(options) {
+  this.createdAt = options.createdAt;
+  this.dimensions = options.dimensions;
+}
+GameObject.prototype.destroy = function () {
+  return 'Game object was removed from the game.';
+};
+
+/*
+  NPC
+    hp
+    name
+    takeDamage() // prototype method -> returns the string '<object name> took damage.'
+    // should inherit destroy() from GameObject's prototype
+*/
+function NPC(options) {
+  GameObject.call(this, options);
+  this.hp = options.hp;
+  this.name = options.name;
+}
+NPC.prototype = Object.create(GameObject.prototype);
+NPC.prototype.takeDamage = function () {
+  return `${this.name} took damage.`;
+};
+
+/*
+  Humanoid
+    faction
+    weapons
+    language
+    greet() // prototype method -> returns the string '<object name> offers a greeting in <object language>.'
+    // should inherit destroy() from GameObject through NPC
+    // should inherit takeDamage() from NPC
+*/
+function Humanoid(options) {
+  NPC.call(this, options);
+  this.faction = options.faction;
+  this.weapons = options.weapons;
+  this.language = options.language;
+}
+Humanoid.prototype = Object.create(NPC.prototype);
+Humanoid.prototype.greet = function () {
+  return `${this.name} offers a greeting in ${this.language}.`;
+};
+
 /* eslint-disable no-undef */
 
 module.exports = {
diff --git a/src/recursion.js b/src/recursion.js
@@ -3,17 +3,44 @@
 const nFibonacci = (n) => {
   // fibonacci sequence: 1 2 3 5 8 13 ...
   // return the nth number in the sequence
+  if (n === 0 || n === 1) return 1;
+
+  return nFibonacci(n - 1) + nFibonacci(n - 2);
 };
 
+nFibonacci(5);
+
 const nFactorial = (n) => {
   // factorial example: !5 = 5 * 4 * 3 * 2 * 1
   // return the factorial of `n`
+  if (n === 1) return n;
+
+  return n * nFactorial(n - 1);
 };
 
 /* Extra Credit */
 const checkMatchingLeaves = (obj) => {
   // return true if every property on `obj` is the same
   // otherwise return false
+  const check = (objPass) => {
+    const arr = [];
+    Object.keys(objPass).forEach((key) => {
+      if (typeof objPass[key] === 'object') {
+        const flatObj = check(objPass[key]);
+        Object.keys(flatObj).forEach((secKey) => {
+          arr.push(flatObj[secKey]);
+        });
+      } else {
+        arr.push(objPass[key]);
+      }
+    });
+    return arr;
+  };
+  const arr = check(obj);
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] !== arr[i + 1] && i + 1 !== arr.length) return false;
+  }
+  return true;
 };
 
 /* eslint-enable no-unused-vars */
diff --git a/src/this.js b/src/this.js
@@ -7,10 +7,15 @@
 class User {
   constructor(options) {
     // set a username and password property on the user object that is created
+    this.username = options.username;
+    this.password = options.password;
   }
   // create a method on the User class called `checkPassword`
   // this method should take in a string and compare it to the object's password property
   // return `true` if they match, otherwise return `false`
+  checkPassword(matchPassword) {
+    return matchPassword === this.password;
+  }
 }
 
 const me = new User({
@@ -27,6 +32,7 @@ const checkPassword = function comparePasswords(passwordToCompare) {
   // use `this` to access the object's `password` property.
   // do not modify this function's parameters
   // note that we use the `function` keyword and not `=>`
+  return passwordToCompare === this.password;
 };
 
 // invoke `checkPassword` on `me` by explicitly setting the `this` context
@@ -37,3 +43,4 @@ const checkPassword = function comparePasswords(passwordToCompare) {
 // .apply
 
 // .bind
+checkPassword.call(me, 'correcthorsebatterystaple');
