empty

.eslintrc.js

@@ -0,0 +1,28 @@
+module.exports = {
+    "env": {
+        "es6": true,
+        "node": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "error",
+            "tab"
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "never"
+        ]
+    }
+};

README.md

@@ -1,13 +1,71 @@
-# Core Algorithms
+# Installation and Setup
 
-Tests and implementations for algorithms commonly used in job interviews. See the full list in the [algorithms.md](algorithms.md) file.
+Installing your dependencies from the package.json file using ```npm install```
 
-Base repository for the [Core Algorithms](http://jsdev.learnersguild.org/goals/123) goal.
+## Usage and Examples
 
-## Installation and Setup
+### Factorial
 
-_Fill this out_
+Returns factorial of number passed in
 
-## Usage and Examples
+```
+let multiplyNumbers = []
+
+for (let i = input; i > 1; i--) {
+	multiplyNumbers.push(i)
+}
+return multiplyNumbers.reduce(function(a, b) {return a * b})
+}
+```
+
+### Factorial Testing
+
+```
+import { expect } from 'chai'
+import factorial from '../src/factorial'
+
+describe.only('factorial()', function(){
+
+  it('should be a function', function(){
+    expect(factorial).to.be.a('function')
+  })
+
+  it('returns factorial of number passed in', function(){
+    expect(factorial(5)).to.deep.equal(120)
+    expect(factorial(10)).to.deep.equal(3628800)
+  })
+})
+```
+
+
+# Core Algorithms [Classic, Numeric, Set]
 
-_...and this_
+- [x] Artifact produced is a fork of the [core-algorithms][core-algorithms] repo.
+- [x] Can run all tests with npm test.
+- [x]  ```makeChange()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```makeChange()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  ```fizzBuzz()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```fizzBuzz()``` exist.
+- [x]  ```isPalindrome()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```isPalindrome()``` exist with at least 2 unit tests using valid inputs.
+- [x]  ```factorial()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```factorial()``` exist with at least 2 unit tests using valid inputs.
+- [x]  ```fibonacci()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```fibonacci()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  ```collatzConjecture()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```collatzConjecture()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  ```setUnion()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```setUnion()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  ```setIntersection()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```setIntersection()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  ```setComplement()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```setComplement()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  ```setSymmetricDifference()``` algorithm is implemented according to the description in algorithms.md.
+- [x]  Tests for ```setSymmetricDifference()``` exist with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
+- [x]  Repository includes a README file with basic installation and setup instructions.
+- [x]  All dependencies are properly declared in package.json.
+- [x]  All major features are added via pull requests with a clear description and concise commit messages.
+- [x]  Code uses a linter and there are no linting errors.
+- [x]  Variables, functions, files, etc. have appropriate and meaningful names.
+- [x]  Functions are small and serve a single purpose.
+- [x]  The artifact produced is properly licensed, preferably with the [MIT license][mit-license].

package.json

@@ -3,11 +3,14 @@
   "description": "Tests and implementations for algorithms commonly used in job interviews.",
   "private": false,
   "version": "0.0.0",
-  "devDependencies": {
+  "dependencies": {
     "babel-cli": "^6.18.0",
     "babel-preset-env": "^1.1.4",
     "babel-register": "^6.18.0",
     "chai": "~1.8.0",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb-base": "^11.1.3",
+    "eslint-plugin-import": "^2.2.0",
     "mocha": "2.0.1"
   },
   "scripts": {

src/collatzConjecture.js

@@ -0,0 +1,23 @@
+export default function collatzConjecture(input) {
+
+  let finalArray = [],
+      currentNumber = input
+
+  if (!Number.isInteger(input)) {
+    return undefined
+  } else if (input === 1) {
+    return [1];
+  } else {
+      while (currentNumber !== 1) {
+        if (currentNumber % 2  === 0) {
+          finalArray.push(currentNumber)
+          currentNumber = currentNumber / 2
+        } else {
+          finalArray.push(currentNumber)
+          currentNumber = (currentNumber * 3) + 1
+        }
+      }
+      finalArray.push(currentNumber)
+      return finalArray
+  }
+}

src/factorial.js

@@ -0,0 +1,9 @@
+export default function factorial(input) {
+
+  let multiplyNumbers = []
+
+  for (let i = input; i > 1; i--) {
+    multiplyNumbers.push(i)
+  }
+  return multiplyNumbers.reduce(function(a, b) {return a * b})
+}

src/fibonacci.js

@@ -0,0 +1,18 @@
+export default function fibonacci(input) {
+
+  const fibArray = [0, 1]
+
+  if (!Number.isInteger(input) || input < 1) {
+    return undefined
+  } else if (input === 1) {
+    return [0]
+  } else if (input === 2) {
+    return fibArray
+  } else {
+    for (let i = 2; i < input; i++) {
+      let current = fibArray[i - 1] + fibArray[i - 2]
+      fibArray.push(current)
+    }
+  }
+  return fibArray
+}

src/fizzBuzz.js

@@ -0,0 +1,17 @@
+  export default function fizzBuzz() {
+
+    let fizzBuzzArray = []
+
+    for (let i = 1; i <= 100; i++) {
+      if (i % 15 === 0) {
+        fizzBuzzArray.push('FizzBuzz')
+      } else if (i % 3 === 0) {
+        fizzBuzzArray.push('Fizz')
+      } else if (i % 5 === 0) {
+        fizzBuzzArray.push('Buzz')
+      } else {
+        fizzBuzzArray.push(i)
+      }
+    }
+    return fizzBuzzArray
+  }

src/isPalindrome.js

@@ -0,0 +1,7 @@
+export default function isPalindrome(input) {
+
+  const condensedString = input.replace(/[\W_]+/g, '').toLowerCase()
+  const reversedString = condensedString.split('').reverse().join('')
+  return condensedString === reversedString
+
+}

src/makeChange.js

@@ -1,3 +1,30 @@
-export default function makeChange({price, amountGiven}) {
-  // your code here
+  export default function makeChange({price, amountGiven}) {
+
+  let changeNeeded = amountGiven - price,
+      coinChange = {quarters: 0, dimes: 0, nickels: 0, pennies: 0}
+
+  if (amountGiven < price) {
+    return 'Gimme more money!'
+  }
+
+  while (changeNeeded >= 25) {
+    coinChange.quarters++
+    changeNeeded -= 25
+  }
+
+  while (changeNeeded >= 10) {
+    coinChange.dimes++
+    changeNeeded -= 10
+  }
+
+  while (changeNeeded >= 5) {
+    coinChange.nickels++
+    changeNeeded -= 5
+  }
+
+  while (changeNeeded >= 1) {
+    coinChange.pennies++
+    changeNeeded -= 1
+  }
+  return coinChange
 }

src/setComplement.js

@@ -0,0 +1,8 @@
+export default function setComplement(firstSet, secondSet) {
+
+  const intersection = new Set([...secondSet].filter(x => !firstSet.includes(x)))
+
+  if (!firstSet || !secondSet) {
+    return undefined
+  } return Array.from(intersection)
+}

src/setIntersection.js

@@ -0,0 +1,8 @@
+export default function setIntersecion(firstSet, secondSet) {
+
+  const intersection = new Set([...firstSet].filter(x => secondSet.includes(x)))
+
+  if (!firstSet || !secondSet) {
+    return undefined
+  } return Array.from(intersection)
+}

src/setSymmetricDifference.js

@@ -0,0 +1,14 @@
+export default function setSymmetricDifference(firstSet, secondSet) {
+
+  const intersection = new Set([...firstSet].filter(x => !secondSet.includes(x)))
+  const intersection2 = new Set([...secondSet].filter(x => !firstSet.includes(x)))
+
+  const intersectionArray = Array.from(intersection)
+  const intersectionArray2 = Array.from(intersection2)
+
+  const setArray = intersectionArray.concat(intersectionArray2)
+
+  if (!firstSet || !secondSet) {
+    return undefined
+  } return setArray
+}

src/setUnion.js

@@ -0,0 +1,9 @@
+export default function setUnion(firstSet, secondSet) {
+
+  if (!firstSet || !secondSet) {
+    return undefined
+  } else {
+    let finalSet = new Set([...firstSet, ...secondSet])
+    return Array.from(finalSet)
+  }
+}

test/collatzConjecture_test.js

@@ -0,0 +1,38 @@
+import { expect } from 'chai';
+import collatzConjecture from '../src/collatzConjecture';
+
+describe.only('collatzConjecture()', () => {
+  it('should be a function', () => {
+    expect(collatzConjecture).to.be.a('function');
+  });
+
+  it('should give you an array of [1] when handed 1', () => {
+    expect(collatzConjecture(1)).to.deep.equal([1]);
+  });
+
+  it('should give you a lengthy array when handed 7', () => {
+    expect(collatzConjecture(7)).to.deep.equal(
+      [7,
+      22,
+      11,
+      34,
+      17,
+      52,
+      26,
+      13,
+      40,
+      20,
+      10,
+      5,
+      16,
+      8,
+      4,
+      2,
+      1]);
+  });
+
+  it('should not evaluate non-numerical values', () => {
+    expect(collatzConjecture('string')).to.equal(undefined);
+    expect(collatzConjecture(['string'])).to.equal(undefined);
+  });
+});

test/factorial_test.js

@@ -0,0 +1,14 @@
+import { expect } from 'chai'
+import factorial from '../src/factorial'
+
+describe.only('factorial()', function(){
+
+  it('should be a function', function(){
+    expect(factorial).to.be.a('function')
+  })
+
+  it('returns an array of numbers 1-100, fizz for multiples of 3, buzz for multiples of 5, fizzbuzz for multiples of 3 and five', function(){
+    expect(factorial(5)).to.deep.equal(120)
+    expect(factorial(10)).to.deep.equal(3628800)
+  })
+})

test/fibonacci_test.js

@@ -0,0 +1,26 @@
+import { expect } from 'chai';
+import fibonacci from '../src/fibonacci';
+
+describe.only('fibonacci()', () => {
+  it('should be a function', () => {
+    expect(fibonacci).to.be.a('function');
+  });
+
+  it('should output an array', () => {
+    expect(fibonacci(1)).to.be.a('array');
+  });
+
+  it('should give a proper array', () => {
+    expect(fibonacci(10)).to.deep.equal([0, 1, 1, 2, 3, 5, 8, 13, 21, 34]);
+  });
+
+  it('should not try to run the function with the values of empty things', () => {
+    expect(fibonacci({})).to.equal(undefined);
+    expect(fibonacci('')).to.equal(undefined);
+    expect(fibonacci([])).to.equal(undefined);
+  });
+
+  it('should not let you plug in negitive integers', () => {
+    expect(fibonacci(-5)).to.equal(undefined);
+  });
+});