Merge branch 'main' into fix_typo_readme

Author: Alex-Nemet

.circleci/config.yml

@@ -0,0 +1,20 @@
+version: 2.1
+
+orbs:
+  node: circleci/node@5.1.0
+
+jobs:
+  test-solutions:
+    executor: node/default
+    steps: 
+      - checkout
+      - node/install-packages:
+          pkg-manager: npm
+      - run:
+          command: npm run test solution
+          name: Run tests in **/solution/*.spec.js
+
+workflows:
+  test-solutions:
+    jobs:
+      - test-solutions

01_helloWorld/solution/helloWorld-solution.js

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

01_helloWorld/solution/helloWorld-solution.spec.js

@@ -0,0 +1,7 @@
+const helloWorld = require('./helloWorld-solution');
+
+describe('Hello World', function () {
+  test('says "Hello, World!"', function () {
+    expect(helloWorld()).toEqual('Hello, World!');
+  });
+});

02_repeatString/solution/repeatString-solution.js

@@ -0,0 +1,10 @@
+const repeatString = function (word, times) {
+  if (times < 0) return "ERROR";
+  let string = "";
+  for (let i = 0; i < times; i++) {
+    string += word;
+  }
+  return string;
+};
+
+module.exports = repeatString;

02_repeatString/solution/repeatString-solution.spec.js

@@ -0,0 +1,39 @@
+const repeatString = require('./repeatString-solution');
+
+describe('repeatString', () => {
+  test('repeats the string', () => {
+    expect(repeatString('hey', 3)).toEqual('heyheyhey');
+  });
+  test('repeats the string many times', () => {
+    expect(repeatString('hey', 10)).toEqual('heyheyheyheyheyheyheyheyheyhey');
+  });
+  test('repeats the string 1 times', () => {
+    expect(repeatString('hey', 1)).toEqual('hey');
+  });
+  test('repeats the string 0 times', () => {
+    expect(repeatString('hey', 0)).toEqual('');
+  });
+  test('returns ERROR with negative numbers', () => {
+    expect(repeatString('hey', -1)).toEqual('ERROR');
+  });
+  test('repeats the string a random amount of times', function () {
+    /*The number is generated by using Math.random to get a value from between
+    0 to 1, when this is multiplied by 1000 and rounded down with Math.floor it 
+    equals a number between 0 to 999 (this number will change everytime you run
+    the test).*/
+
+    // DO NOT use Math.floor(Math.random() * 1000) in your code,
+    // this test generates a random number, then passes it into your code with a function parameter.
+    // If this doesn't make sense, you should go read about functions here: https://www.theodinproject.com/paths/foundations/courses/foundations/lessons/fundamentals-part-3
+    const number = Math.floor(Math.random() * 1000);
+    /*The .match(/((hey))/g).length is a regex that will count the number of heys
+    in the result, which if your function works correctly will equal the number that
+    was randomaly generated. */
+    expect(repeatString('hey', number).match(/((hey))/g).length).toEqual(
+      number
+    );
+  });
+  test('works with blank strings', () => {
+    expect(repeatString('', 10)).toEqual('');
+  });
+});

03_reverseString/README.md

@@ -6,7 +6,5 @@ Pretty simple, write a function called `reverseString` that returns its input, r
 reverseString('hello there') // returns 'ereht olleh'
 ```
 
-You will notice in this exercise that there are multiple tests, after making the first one pass, enable the others one by one by deleting the `.skip` in front the `test.skip()` function.
-
 ## Hints
 Strings in JavaScript cannot be reversed directly so you're going to have to split it into something else first.. do the reversal and then join it back together into a string.

03_reverseString/solution/reverseString-solution.js

@@ -0,0 +1,5 @@
+const reverseString = function (string) {
+  return string.split("").reverse().join("");
+};
+
+module.exports = reverseString;

03_reverseString/solution/reverseString-solution.spec.js

@@ -0,0 +1,18 @@
+const reverseString = require('./reverseString-solution');
+
+describe('reverseString', () => {
+  test('reverses single word', () => {
+    expect(reverseString('hello')).toEqual('olleh');
+  });
+
+  test('reverses multiple words', () => {
+    expect(reverseString('hello there')).toEqual('ereht olleh');
+  });
+
+  test('works with numbers and punctuation', () => {
+    expect(reverseString('123! abc!')).toEqual('!cba !321');
+  });
+  test('works with blank strings', () => {
+    expect(reverseString('')).toEqual('');
+  });
+});

04_removeFromArray/solution/removeFromArray-solution.js

@@ -0,0 +1,28 @@
+// we have 2 solutions here, an easier one and a more advanced one.
+// The easiest way to get an array of the rest of the arguments that are passed to a function
+// is using the rest operator. If this is unfamiliar to you look it up!
+const removeFromArray = function (array, ...args) {
+  // create a new empty array
+  const newArray = [];
+  // use forEach to go through the array
+  array.forEach((item) => {
+    // push every element into the new array
+    // UNLESS it is included in the function arguments
+    // so we create a new array with every item, except those that should be removed
+    if (!args.includes(item)) {
+      newArray.push(item);
+    }
+  });
+  // and return that array
+  return newArray;
+};
+
+// A simpler, but more advanced way to do it is to use the 'filter' function,
+// which basically does what we did with the forEach above.
+
+// var removeFromArray = function(array, ...args) {
+//   return array.filter(val => !args.includes(val))
+// }
+//
+
+module.exports = removeFromArray;

04_removeFromArray/solution/removeFromArray-solution.spec.js

@@ -0,0 +1,25 @@
+const removeFromArray = require('./removeFromArray-solution');
+
+describe('removeFromArray', () => {
+  test('removes a single value', () => {
+    expect(removeFromArray([1, 2, 3, 4], 3)).toEqual([1, 2, 4]);
+  });
+  test('removes multiple values', () => {
+    expect(removeFromArray([1, 2, 3, 4], 3, 2)).toEqual([1, 4]);
+  });
+  test('ignores non present values', () => {
+    expect(removeFromArray([1, 2, 3, 4], 7, 'tacos')).toEqual([1, 2, 3, 4]);
+  });
+  test('ignores non present values, but still works', () => {
+    expect(removeFromArray([1, 2, 3, 4], 7, 2)).toEqual([1, 3, 4]);
+  });
+  test('can remove all values', () => {
+    expect(removeFromArray([1, 2, 3, 4], 1, 2, 3, 4)).toEqual([]);
+  });
+  test('works with strings', () => {
+    expect(removeFromArray(['hey', 2, 3, 'ho'], 'hey', 3)).toEqual([2, 'ho']);
+  });
+  test('only removes same type', () => {
+    expect(removeFromArray([1, 2, 3], '1', 3)).toEqual([1, 2]);
+  });
+});