Merge pull request #597 from mao-sz/restructure

Restructure: Group exercises by curriculum section

Author: JoshDevHub

.github/workflows/tests.yml

@@ -12,4 +12,4 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
       - run: npm install
-      - run: npm run test -- **/solution
+      - run: npm run test -- solution

README.md

@@ -20,7 +20,7 @@ If you have a suggestion to improve an exercise, an idea for a new exercise, or
    - A markdown file with a description of the task, an empty (or mostly empty) JavaScript file, and a set of tests.
    - A `solutions` directory that contains an example solution and the same test file with all of the tests unskipped.
 
-   To complete an exercise, you will need to go to the exercise directory with `cd exerciseName` in the terminal and run `npm test exerciseName.spec.js`. This should run the test file and show you the output. When you run a test for the first time, it will fail. This is by design! You must open the exercise file and write the code needed to get the test to pass.
+   To complete an exercise, you will need to go to the exercise directory with `cd <path to file>` in the terminal and run `npm test exerciseName.spec.js`. For example, to go to the first Foundations exercise "helloWorld", you need to `cd foundations/01_helloWorld` then run `npm rest helloWorld`. This should run the test file and show you the output. When you run a test for the first time, it will fail. This is by design! You must open the exercise file and write the code needed to get the test to pass.
 
 1. Some of the exercises have test conditions defined in their spec file as `test.skip` instead of `test`. This is intentional. Once all `test`s pass, you will change the next `test.skip` to `test` and test your code again. You will do this until all conditions are satisfied. **All tests must pass at the same time**, and you should not have any instances of `test.skip` in the spec file when you are finished with an exercise.
 1. Once you successfully finish an exercise, check the `solutions` directory within each exercise.

computer_science/recursion/1_factorial/README.md

@@ -0,0 +1,12 @@
+# Exercise 1 - Factorial
+
+Write a recursive [factorial](https://simple.wikipedia.org/wiki/Factorial) function that takes a non-negative integer, and returns the product of all positive integers less than or equal to the input integer. An input of `0` should return `1`. The function should only accept numbers, so `'4'` should not be accepted as it is a string. All invalid inputs should return `undefined`.
+
+For example:
+
+```javascript
+factorial(5); // 5 * 4 * 3 * 2 * 1, Output: 120
+factorial(0); // Output: 1
+factorial(7.2); // Output: undefined
+factorial('4'); // Output: undefined
+```

computer_science/recursion/1_factorial/factorial.js

@@ -0,0 +1,6 @@
+const factorial = function() {
+
+};
+
+// Do not edit below this line
+module.exports = factorial;

computer_science/recursion/1_factorial/factorial.spec.js

@@ -0,0 +1,37 @@
+const factorial = require("./factorial");
+
+describe('factorial', () => {
+  test('4th factorial number is 24', () => {
+    expect(factorial(4)).toBe(24);
+  });
+  test.skip('6th factorial number is 720', () => {
+    expect(factorial(6)).toBe(720);
+  });
+  test.skip('10th factorial number is 3628800', () => {
+    expect(factorial(10)).toBe(3628800);
+  });
+  test.skip('15th factorial number is 1307674368000', () => {
+    expect(factorial(15)).toBe(1307674368000);
+  });
+  test.skip('25th factorial number is 1.5511210043330986e+25', () => {
+    expect(factorial(25)).toBe(1.5511210043330986e+25);
+  });
+  test.skip('0th factorial number is 1', () => {
+    expect(factorial(0)).toBe(1);
+  });
+  test.skip("doesn't accept negatives", () => {
+    expect(factorial(-25)).toBe(undefined);
+  });
+  test.skip("doesn't accept floats", () => {
+    expect(factorial(5.4)).toBe(undefined);
+  });
+  test.skip("doesn't accept a number as a string", () => {
+    expect(factorial('5')).toBe(undefined);
+  });
+  test.skip("doesn't accept strings", () => {
+    expect(factorial('foo')).toBe(undefined);
+  });
+  test.skip("doesn't accept arrays", () => {
+    expect(factorial([5])).toBe(undefined);
+  });
+});

computer_science/recursion/1_factorial/solution/factorial-solution.js

@@ -0,0 +1,7 @@
+const factorial = function(n) {
+  if (!Number.isInteger(n) || n < 0) return;
+  if (n === 0) return 1;
+  return n * factorial(n - 1);
+};
+
+module.exports = factorial;

computer_science/recursion/1_factorial/solution/factorial-solution.spec.js

@@ -0,0 +1,37 @@
+const factorial = require("./factorial-solution");
+
+describe('factorial', () => {
+  test('4th factorial number is 24', () => {
+    expect(factorial(4)).toBe(24);
+  });
+  test('6th factorial number is 720', () => {
+    expect(factorial(6)).toBe(720);
+  });
+  test('10th factorial number is 3628800', () => {
+    expect(factorial(10)).toBe(3628800);
+  });
+  test('15th factorial number is 1307674368000', () => {
+    expect(factorial(15)).toBe(1307674368000);
+  });
+  test('25th factorial number is 1.5511210043330986e+25', () => {
+    expect(factorial(25)).toBe(1.5511210043330986e+25);
+  });
+  test('0th factorial number is 1', () => {
+    expect(factorial(0)).toBe(1);
+  });
+  test('doesn\'t accept negatives', () => {
+    expect(factorial(-25)).toBe(undefined);
+  });
+  test('doesn\'t accept floats', () => {
+    expect(factorial(5.4)).toBe(undefined);
+  });
+  test('doesn\'t accept a number as a string', () => {
+    expect(factorial('5')).toBe(undefined);
+  });
+  test('doesn\'t accept strings', () => {
+    expect(factorial('foo')).toBe(undefined);
+  });
+  test('doesn\'t accept arrays', () => {
+    expect(factorial([5])).toBe(undefined);
+  });
+});

computer_science/recursion/2_contains/README.md

@@ -0,0 +1,12 @@
+# Exercise 2 - contains
+
+Write a function that searches for a value in a nested object. It returns true if the object contains that value.
+
+Objects are compared by reference.
+
+Examples:
+
+```javascript
+contains({ foo: "foo" }, "bar") // false
+contains({ foo: { bar: "bar" } }, "bar") // true
+```

computer_science/recursion/2_contains/contains.js

@@ -0,0 +1,6 @@
+const contains = function() {
+  
+};
+  
+// Do not edit below this line
+module.exports = contains;

computer_science/recursion/2_contains/contains.spec.js

@@ -0,0 +1,60 @@
+const contains = require("./contains");
+
+describe("contains", () => {
+  const meaningOfLifeArray = [42];
+  const object = {
+    data: {
+      duplicate: "e",
+      stuff: {
+        thing: {
+          banana: NaN,
+          moreStuff: {
+            something: "foo",
+            answer: meaningOfLifeArray,
+          },
+        },
+      },
+      info: {
+        duplicate: "e",
+        magicNumber: 44,
+        empty: null,
+      },
+    },
+  };
+
+  test("true if the provided number is a value within the object", () => {
+    expect(contains(object, 44)).toBe(true);
+  });
+
+  test.skip("true if the provided string is a value within the object", () => {
+    expect(contains(object, "foo")).toBe(true);
+  });
+
+  test.skip("does not convert input string into a number when searching for a value within the object", () => {
+    expect(contains(object, "44")).toBe(false);
+  });
+
+  test.skip("false if the provided string is not a value within the object", () => {
+    expect(contains(object, "bar")).toBe(false);
+  });
+
+  test.skip("true if provided string is within the object, even if duplicated", () => {
+    expect(contains(object, "e")).toBe(true);
+  });
+
+  test.skip("true if the object contains the same object by reference", () => {
+    expect(contains(object, meaningOfLifeArray)).toBe(true);
+  });
+
+  test.skip("false if no matching object reference", () => {
+    expect(contains(object, [42])).toBe(false);
+  });
+
+  test.skip("true if NaN is a value within the object", () => {
+    expect(contains(object, NaN)).toBe(true);
+  });
+
+  test.skip("false if the provided value exists and is null", () => {
+    expect(contains(object, null)).toBe(true);
+  });
+});