diff --git a/README.md b/README.md
index ab9fadd9a..41f354fe1 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
-# LAB | JS Functions & Arrays
+# LAB | JS Challenges - Arrays & Functions
+
+
+ 
+
@@ -11,15 +15,12 @@
Upon completion of this exercise, you will be able to:
- - Run predefined tests in Jasmine to verify that the program meets the technical requirements.
+ - Run predefined tests in Jasmine to check that JavaScript program meets the technical requirements.
- Identify expected code behavior by reading and understanding test results and errors.
- - Declare and invoke functions using function declaration, function expression, and arrow function syntax.
- - Use the `return` keyword to return a value from a function.
- - Pass primitive values as arguments to functions.
- - Pass arrays to functions as arguments.
- - Access items stored in arrays using the indexes,
- - Add, remove and check for items in an array using the index and array methods (`unshift`, `push`, `splice`, `shift`, `pop`, `indexOf`, and `includes`).
- - Iterate over arrays using the `for` and `forEach` loops.
+ - Pass arrays and primitive values as arguments to functions.
+ - Use the `return` keyword to return a value from a function.
+ - Access, add, remove, and check for items in an array using the index and array methods (`unshift`, `push`, `splice`, `shift`, `pop`, `indexOf`, and `includes`).
+ - Use loops and `forEach` method to iterate over arrays.
@@ -28,14 +29,23 @@
## Introduction
-Array manipulation is a common task in programming. Whether you are calculating a total for a shopping cart, grabbing only the first names from a list of people, or moving a piece on a chessboard, you are probably modifying or manipulating an array somewhere in the code.
+Arrays are an important data structure as they allow us to group related data together. Similarly, functions are as essential as they help us organize our code and make it reusable in the form of blocks of code that can be called multiple times.
+In this lab, we are going to continue our journey using arrays and functions. You will work on a set of coding challenges that will help you to solidify your knowledge of arrays and functions.
+
+We will be using the same setup as the previous lab, which includes the Jasmine testing library and a set of predefined tests.
+
+
+
## Requirements
- Fork this repo
- Clone it to your machine
+
+
+
## Submission
- Upon completion, run the following commands:
@@ -46,29 +56,16 @@ git commit -m "Solved lab"
git push origin master
```
-- Create a Pull Request so that your TAs can check your work.
-
-## Automated Testing Introduction
-
-### What is automated testing?
-
-Automated software testing is the process of programmatically executing an application to validate and verify that it meets the business needs, as well as the technical requirements, and that it behaves as expected.
-
-Testing should be viewed as a continuous process, not a discrete operation or single activity in the development lifecycle. Designing tests at the beginning of the product lifecycle can mitigate common issues that arise when developing complex code bases.
+- Create a Pull Request and submit your assignment.
-Having a strong *test suite* can provide you the ease of mind since you will be able to confidently improve upon your work while knowing that your not breaking a previously developed feature.
-### Testing labs
-This LAB and some labs you will work on during the bootcamp are equipped with unit tests to provide automated feedback on your lab progress.
-
-### Testing with Jasmine
+## Automated Testing
-Jasmine is an automated testing framework for JavaScript. It is designed to be used in Behavior-driven Development (**BDD**) programming, focusing more on the business value than the technical details.
+This LAB is equipped with [Jasmine](https://jasmine.github.io/) testing library and unit tests to provide automated feedback on your lab progress.
-We have already included Jasmine in the project you just forked, so let's see how to use it to implement our code.
### Usage
@@ -76,229 +73,266 @@ We have already included Jasmine in the project you just forked, so let's see ho
Before starting coding, we will explain the project structure we have provided you:
```
-lab-js-functions-and-arrays
+lab-js-challenges-array-function
├── README.md
+ │
├── SpecRunner.html
- ├── jasmine
+ │
+ ├── jasmine/
│ └── ...
- ├── src
- │ └── functions-and-arrays.js
- └── tests
- └── functions-and-arrays.spec.js
+ │
+ ├── src/
+ │ └── challenges.js
+ │
+ └── tests/
+ └── challenges.spec.js
```
-We will be working with the `src/functions-and-arrays.js`. You can find all the files in the `jasmine` folder needed to use Jasmine. All these files are already linked with the `SpecRunner.html` file.
+All the needed Jasmine testing library files from the `jasmine/` folder are already linked with `SpecRunner.html` and everything is set up for you to start coding.
+
+
+
+
+
+You should write your code and do all the work in the `src/challenges.js` file.
-If you want to check the tests, they are in the `tests/functions-and-arrays.spec.js` file.
+If you want to check the tests, they are located in the `tests/` folder in the file `tests/challenges.spec.js` file.
+
+
+
+
#### Run tests
-Running automated tests with Jasmine is super easy. All you need to do is open the `SpecRunner.html` file in your browser. You will find something similar to this:
+Running automated tests with Jasmine is super easy. All you need to do is open the `SpecRunner.html` file in your browser using the [Live Server](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer) VSCode extension.
+You should see something similar to this:
+
+
[](https://user-images.githubusercontent.com/23629340/33389609-c2f3965c-d533-11e7-9a03-e0a89314dd98.png)
+
-#### Pass the tests
-You should write your code on the `src/functions-and-arrays.js` file. While following the instructions for each iteration, you should check every test and ensure it's *passing*, before moving on.
-Do not rush. You should take your time to read every iteration carefully and address the *breaking* tests as you progress through the exercise.
+#### Pass the tests
-When coding with tests, it is super important that you carefully read and understand the errors you are getting. This way, you will know what's expected from your code.
+You should write your code on the `src/challenges.js` file.
-To see the output of your JavaScript code, open the [Console in the Developer Tools](https://developer.chrome.com/docs/devtools/open/#console).
+Take your time to read each iteration instructions carefully and address any *breaking* tests as you progress through the exercise. Before moving on to the next iteration, make sure that all tests for the current iteration are passing.
-**Important:** Note that **you don't need to execute the functions yourself**; the tests will automatically load and execute the functions on each test run. All you need to do is declare the functions, ensure they handle the parameters passed and return what is indicated in the iteration instructions and the test description. We provide you with a sample array for some iterations, so you can do some **manual** testing if you wish.
-## Instructions
-While following the instructions for each iteration, carefully read the instructions and test descriptions to understand the task requirements fully. Do not rush. It would be best if you took your time to read every iteration carefully.
+To see the `console.log` output of your JavaScript code, open the [Chrome Dev Tools](https://developer.chrome.com/docs/devtools/open/#console).
-### Iteration #1: Find the maximum
-Implement the function `maxOfTwoNumbers` that takes two numbers as arguments and returns the bigger number.
+
+**Important:** **You don't need to execute the functions yourself**; the tests will automatically do this for you on each test run. All you need to do is make sure the function is declared, that it takes correct parameters, and returns what the instructions and tests ask for.
+
+We provided you with a sample arrays in some iterations, so you can optionaly do some **manual** testing.
-### Iteration #2: Find the longest word
-Implement the function `findLongestWord` that takes as an argument an array of words and returns the longest one. If there are 2 with the same length, it should return the first occurrence.
-You can use the following array to test your solution:
+## Instructions
-```javascript
-const words = ['mystery', 'brother', 'aviator', 'crocodile', 'pearl', 'orchard', 'crackpot'];
-```
+For each iteration, make sure to read the instructions and test descriptions carefully to understand the task requirements. Don't rush. Take your time to read the instructions and test descriptions thoroughly.
-### Iteration #3: Calculate the sum
-#### Iteration #3.1: Sum numbers
-Calculating a sum can be as simple as iterating over an array and adding each of the elements together.
-Implement the function named `sumNumbers` that takes an array of numbers as an argument and returns the sum of all the numbers in the array. Later in the course, we will learn how to do this using the `reduce` array method, making your work significantly easier. For now, let's practice _the "declarative"_ way of adding values using loops.
+### Iteration 1 | Count Repetition
+
+Declare a function named `howManyTimes` that will take in an *array of words* as the first argument and a *word to search* for as the second argument. The function should return the number of times the word appears in the array.
+
+
You can use the following array to test your solution:
```javascript
-const numbers = [6, 12, 1, 18, 13, 16, 2, 1, 8, 10];
+const repeatedWords = [
+ "machine",
+ "matter",
+ "subset",
+ "trouble",
+ "starting",
+ "matter",
+ "eating",
+ "matter",
+ "truth",
+ "disobedience",
+ "matter"
+];
```
-#### Bonus - Iteration #3.2: A generic `sum()` function
-
-In iteration 3, you created a function that returns the sum of an array of numbers. But what if we want to calculate the sum of the length of words in an array? What if it also includes _boolean_ values? To achieve this, we must create a function allowing this flexibility.
-You should implement the function `sum()` in this iteration. The function should take an array of mixed values - numbers, strings, and booleans. The function should add all the string lengths, numeric values, and numeric values of booleans to the total sum and return the sum.
-You can use the following array to test your solution:
+**Example:**
```javascript
-const mixedArr = [6, 12, 'miami', 1, true, 'barca', '200', 'lisboa', 8, 10];
-
-// should return: 57
+howManyTimes(repeatedWords, "matter");
```
+**Expected output:**
-Note: Your function should only accept an array with numbers, strings, or booleans. If the array contains any other data type, such as an object, you should [throw an error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). In JavaScript, the syntax for throwing an error is as follows:
```javascript
-throw new Error("Error message goes here");
+4
```
-When specifying the error message, you should be specific and descriptive in explaining the error.
-
-### Iteration #4: Calculate the average
-Calculating an average is a prevalent task. So let's practice it a bit.
-**The logic behind this:**
-1. Find the sum as we did in the first exercise (or how about reusing the function `sumNumbers()`?)
-2. Divide that sum by the number of elements in the array.
+### Iteration 2 | Number Sequence
+
+Declare a function named `createSequence`. The function should take one argument: a number (`n`). The function should return an array of numbers in the range from `0` to `n`.
-#### Iteration #4.1: Array of numbers
-Implement the function `averageNumbers` that expects an array of numbers and returns the average of the numbers.
-You can use the following array to test your solution:
+**Example:**
```javascript
-const numbers = [2, 6, 9, 10, 7, 4, 1, 9];
+createSequence(7);
```
+
+**Expected output:**
+
+```javascript
+[0, 1, 2, 3, 4, 5, 6, 7]
+```
+
-#### Iteration #4.2: Array of strings
-Implement the function named `averageWordLength` that receives as a single argument an array of words and returns the average length of the words:
+
+
+### Iteration 3 | Multiply for Each
+
+Implement the function `multiplyBy` that takes two arguments: an *array of numbers* and a *number* (multiplier). It should return a new array containing each number of the first array multiplied by the multiplier.
+
+
+
+**Important:** **You must use the `forEach()` method** in the function to iterate over the array. If you need a refresher on the `forEach()` method, check today's lesson or the following [MDN page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach).
+
+
+
You can use the following array to test your solution:
```javascript
-const words = ['seat', 'correspond', 'linen', 'motif', 'hole', 'smell', 'smart', 'chaos', 'fuel', 'palace'];
+const numbers = [1, 2, 5, 10, 13, 50];
```
-#### Bonus - Iteration #4.3: A generic `avg()` function
-
-Create function `avg(arr)` that receives any mixed array and calculates the average. For example, consider an array filled with numbers and/or strings and/or booleans as a mixed array.
-The non-numerical values should be counted as follows:
-- Booleans: `true` counts as `1` and `false` counts as `0`.
-- Strings: use the string `length` as the numeric value.
+**Example:**
```javascript
-const mixedArr = [6, 12, 'miami', 1, true, 'barca', '200', 'lisboa', 8, 10];
+multiplyBy(numbers, 3);
+```
+
+**Expected output:**
-// should return: 5.7
+```javascript
+[3, 6, 15, 30, 39, 150]
```
-### Iteration #5: Unique arrays
-Take the following array, remove the duplicates, and return a new array. You are more than likely going to want to check out the Array methods [`indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) and [`includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).
-Do this in the form of a function `uniquifyArray` that receives an array of words as an argument.
+### Iteration 4 | Filter Out
+
+Declare a function `filterOut`. The function should take two arguments: an *array of strings* (original), and an *array of strings to filter out*.
+
+The function should return a new array that only includes the strings from the original array that are not present in the second array. In other words, you should **remove** all the strings listed in the second array.
You can use the following array to test your solution:
```javascript
-const words = [
- 'crab',
- 'poison',
- 'contagious',
- 'simple',
- 'bring',
- 'sharp',
- 'playground',
- 'poison',
- 'communion',
- 'simple',
- 'bring'
-];
+const original = ["cat", "dog", "fish", "bird", "cat", "fish"];
+const toRemove = ["cat", "dog"];
```
-
-### Iteration #6: Find elements
-Let's create a simple array search.
+**Example:**
-Declare a function named `doesWordExist` that will take in an array of words as one argument and a *word to search* for as the other. Return `true` if the word exists in the array; otherwise, return `false`.
+```javascript
+filterOut(original, toRemove);
+```
-You can use the following array to test your solution:
+**Expected output:**
```javascript
-const words = ['machine', 'subset', 'trouble', 'starting', 'matter', 'eating', 'truth', 'disobedience'];
+["fish", "bird", "fish"]
```
-
-### Iteration #7: Count repetition
-Declare a function named `howManyTimes` that will take in an array of words as the first argument and a word to search for as the second argument. The function will return the number of times that word appears in the array.
+
+### Iteration 5 | Unique Arrays
+
+Take the following array, remove the duplicates, and return a new array. You are more than likely going to want to check out the Array methods [`indexOf`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) and [`includes`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).
+
+Do this in the form of a function `uniquifyArray` that receives an array of words as an argument.
+
+
You can use the following array to test your solution:
```javascript
-const words = [
- 'machine',
- 'matter',
- 'subset',
- 'trouble',
- 'starting',
- 'matter',
- 'eating',
- 'matter',
- 'truth',
- 'disobedience',
- 'matter'
+const duplicateWords = [
+ "crab",
+ "poison",
+ "contagious",
+ "poison",
+ "simple",
+ "sharp",
+ "simple"
];
```
+**Example:**
+```javascript
+uniquifyArray(duplicateWords);
+```
-### Bonus - Iteration #8
+**Expected output:**
+```javascript
+[
+ "crab",
+ "poison",
+ "contagious",
+ "simple",
+ "sharp"
+]
+```
+
+
-#### Bonus - Iteration #8.1: Product of adjacent numbers
+
+### Bonus: Iteration 6 | Product of Adjacent Numbers
Given multiple arrays, find the greatest product of four adjacent numbers.
@@ -347,15 +381,7 @@ const matrix = [
-
-
-#### Bonus - Iteration #8.2: Product of diagonals
-
-Following the logic you've used in iteration #8.1, declare a function called `greatestProductOfDiagonals(matrix)`. It takes a matrix as a parameter and returns the greatest product of any four values laid out diagonally, in either direction.
-
-
-
-**Happy coding!** :heart:
+**Happy coding!** :blue_heart:
@@ -537,10 +563,11 @@ Following the logic you've used in iteration #8.1, declare a function called `gr
- How can I compare the length of each word in an array in JavaScript?
+ How can I compare the length of each string in an array in JavaScript?
- To compare the length of each word in an array in JavaScript, you can use a loop to iterate through the array and compare the length of each element using the `.length` property.
+
+ To compare the length of each string in an array in JavaScript, you can use a loop to iterate through the array and compare the length of each string using the `.length` property.
Here is an example of how you loop over an array:
diff --git a/SpecRunner.html b/SpecRunner.html
index 73c156ffd..2d64fae9b 100644
--- a/SpecRunner.html
+++ b/SpecRunner.html
@@ -12,10 +12,10 @@
-
+
-
+
diff --git a/jasmine/jasmine-2.8.0/jasmine-html.js b/jasmine/jasmine-2.8.0/jasmine-html.js
index 86cfc7bee..acb51c071 100644
--- a/jasmine/jasmine-2.8.0/jasmine-html.js
+++ b/jasmine/jasmine-2.8.0/jasmine-html.js
@@ -158,7 +158,7 @@ jasmineRequire.HtmlReporter = function(j$) {
var alert = find('.jasmine-alert');
var order = doneResult && doneResult.order;
labName.appendChild(createDom('img', {src: 'jasmine/jasmine-2.8.0/ironhack-logo.png'}, ''));
- labName.appendChild(createDom('span', {}, 'LAB | JS Functions & Arrays'));
+ labName.appendChild(createDom('span', {}, 'LAB | JS Challenges - Arrays & Functions'));
alert.appendChild(createDom('span', {className: 'jasmine-duration'}, 'finished in ' + timer.elapsed() / 1000 + 's'));
banner.appendChild(
diff --git a/src/challenges.js b/src/challenges.js
new file mode 100644
index 000000000..31e094b4f
--- /dev/null
+++ b/src/challenges.js
@@ -0,0 +1,155 @@
+// Iteration 1 | Count Repetition
+const repeatedWords = [
+ "machine",
+ "matter",
+ "subset",
+ "trouble",
+ "starting",
+ "matter",
+ "eating",
+ "matter",
+ "truth",
+ "disobedience",
+ "matter"
+];
+
+function howManyTimes(wordsArray, wordToSearch) {
+ if (wordsArray.length === 0) {
+ return 0; // Return 0 if the array is empty
+ }
+
+ let count = 0;
+ for (let i = 0; i < wordsArray.length; i++) {
+ if (wordsArray[i] === wordToSearch) {
+ count++; // Increment count if the word is found
+ }
+ }
+
+ return count;
+}
+
+
+// Iteration 2 | Number Sequence
+function createSequence(n) {
+ if (n === 0) {
+ return []; // Returns an empty array if 0 is passed as an argument
+ }
+
+ let sequence = [];
+ for (let i = 0; i <= n; i++) {
+ sequence.push(i);
+ }
+
+ return sequence;
+}
+
+
+// Iteration 3 | Multiply for Each
+const numbers = [1, 2, 5, 10, 13, 50];
+
+function multiplyBy(numbersArray, multiplier) {
+ let multipliedNumbers = [];
+
+ numbersArray.forEach(function(number) {
+ multipliedNumbers.push(number * multiplier);
+ });
+
+ return multipliedNumbers;
+}
+
+
+
+// Iteration 4 | Filter Out
+const original = ["cat", "dog", "fish", "bird", "cat", "fish"];
+const toRemove = ["cat", "dog"];
+
+function filterOut(original, toRemove) {
+ if (original.length === 0) {
+ return null; // Return null if the original array is empty
+ }
+ if (toRemove.length === 0) {
+ return original; // Return the original array if the toRemove array is empty
+ }
+
+ return original.filter(function(element) {
+ return !toRemove.includes(element);
+ });
+}
+
+
+// Iteration 5 | Unique Arrays
+const duplicateWords = [
+ "crab",
+ "poison",
+ "contagious",
+ "simple",
+ "bring",
+ "sharp",
+ "playground",
+ "poison",
+ "communion",
+ "simple",
+ "bring"
+];
+
+function uniquifyArray(wordsArray) {
+ if (wordsArray.length === 0) {
+ return null; // Return null if the array is empty
+ }
+
+ let uniqueWords = [];
+ for (let i = 0; i < wordsArray.length; i++) {
+ if (!uniqueWords.includes(wordsArray[i])) {
+ uniqueWords.push(wordsArray[i]);
+ }
+ }
+
+ return uniqueWords;
+}
+
+
+// Bonus: Iteration 6 | Product of Adjacent Numbers
+const matrix = [
+ [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
+ [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
+ [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
+ [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
+ [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
+ [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
+ [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
+ [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
+ [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
+ [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
+ [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
+ [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
+ [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
+ [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
+ [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
+ [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
+ [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
+ [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
+ [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
+ [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
+];
+
+function greatestProduct(matrix) {
+ let maxProduct = 0;
+
+
+ for (let i = 0; i < matrix.length; i++) {
+ for (let j = 0; j < matrix[i].length - 3; j++) {
+
+ let horizontalProduct = matrix[i][j] * matrix[i][j + 1] * matrix[i][j + 2] * matrix[i][j + 3];
+ maxProduct = Math.max(maxProduct, horizontalProduct);
+
+
+ if (i < matrix.length - 3) {
+ let verticalProduct = matrix[i][j] * matrix[i + 1][j] * matrix[i + 2][j] * matrix[i + 3][j];
+ maxProduct = Math.max(maxProduct, verticalProduct);
+ }
+ }
+ }
+
+ return maxProduct;
+}
+
diff --git a/src/functions-and-arrays.js b/src/functions-and-arrays.js
deleted file mode 100644
index 3a7dbec41..000000000
--- a/src/functions-and-arrays.js
+++ /dev/null
@@ -1,130 +0,0 @@
-// Iteration #1: Find the maximum
-function maxOfTwoNumbers() {}
-
-
-
-// Iteration #2: Find longest word
-const words = ['mystery', 'brother', 'aviator', 'crocodile', 'pearl', 'orchard', 'crackpot'];
-
-function findLongestWord() {}
-
-
-
-// Iteration #3: Calculate the sum
-const numbers = [6, 12, 1, 18, 13, 16, 2, 1, 8, 10];
-
-function sumNumbers() {}
-
-
-
-// Iteration #3.1 Bonus:
-function sum() {}
-
-
-
-// Iteration #4: Calculate the average
-// Level 1: Array of numbers
-const numbersAvg = [2, 6, 9, 10, 7, 4, 1, 9];
-
-function averageNumbers() {}
-
-
-// Level 2: Array of strings
-const wordsArr = ['seat', 'correspond', 'linen', 'motif', 'hole', 'smell', 'smart', 'chaos', 'fuel', 'palace'];
-
-function averageWordLength() { }
-
-// Bonus - Iteration #4.1
-function avg() {}
-
-// Iteration #5: Unique arrays
-const wordsUnique = [
- 'crab',
- 'poison',
- 'contagious',
- 'simple',
- 'bring',
- 'sharp',
- 'playground',
- 'poison',
- 'communion',
- 'simple',
- 'bring'
-];
-
-function uniquifyArray() {}
-
-
-
-// Iteration #6: Find elements
-const wordsFind = ['machine', 'subset', 'trouble', 'starting', 'matter', 'eating', 'truth', 'disobedience'];
-
-function doesWordExist() {}
-
-
-
-// Iteration #7: Count repetition
-const wordsCount = [
- 'machine',
- 'matter',
- 'subset',
- 'trouble',
- 'starting',
- 'matter',
- 'eating',
- 'matter',
- 'truth',
- 'disobedience',
- 'matter'
-];
-
-function howManyTimes() {}
-
-
-
-// Iteration #8: Bonus
-const matrix = [
- [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
- [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
- [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
- [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
- [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
- [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
- [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
- [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
- [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
- [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
- [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
- [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
- [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
- [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
- [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
- [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
- [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
- [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
- [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
- [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
-];
-
-function greatestProduct() {}
-
-
-
-
-// The following is required to make unit tests work.
-/* Environment setup. Do not modify the below code. */
-if (typeof module !== 'undefined') {
- module.exports = {
- maxOfTwoNumbers,
- findLongestWord,
- sumNumbers,
- sum,
- averageNumbers,
- averageWordLength,
- avg,
- uniquifyArray,
- doesWordExist,
- howManyTimes,
- greatestProduct
- };
-}
diff --git a/tests/challenges.spec.js b/tests/challenges.spec.js
new file mode 100644
index 000000000..dbe90c662
--- /dev/null
+++ b/tests/challenges.spec.js
@@ -0,0 +1,229 @@
+const shuffle = (currentArray) => {
+ const array = [...currentArray];
+ let counter = array.length;
+
+ while (counter > 0) {
+ let randomIndex = Math.floor(Math.random() * counter);
+ counter--;
+ let temp = array[counter];
+ array[counter] = array[randomIndex];
+ array[randomIndex] = temp;
+ }
+ return array;
+};
+
+describe("Iteration 1 | Count Repetition", () => {
+ describe("function howManyTimes()", () => {
+ it("should be defined as a function", () => {
+ expect(typeof howManyTimes).toBe("function");
+ });
+
+ it("should return 0 (zero) if receives an empty array when called", () => {
+ expect(howManyTimes([])).toBe(0);
+ });
+
+ it("should return 1 (one) when the word appears only one time in the array", () => {
+ expect(howManyTimes(["basketball", "football", "tennis"], "tennis")).toBe(
+ 1
+ );
+ });
+
+ it("should return 0 (zero) when the word doesn't appear in the array", () => {
+ expect(howManyTimes(["basketball", "football", "tennis"], "rugby")).toBe(
+ 0
+ );
+ });
+
+ it("should return 5 (five) when the word appears 5 times in the array", () => {
+ expect(
+ howManyTimes(
+ [
+ "basketball",
+ "football",
+ "tennis",
+ "rugby",
+ "rugby",
+ "ping pong",
+ "rugby",
+ "basketball",
+ "rugby",
+ "handball",
+ "rugby",
+ ],
+ "rugby"
+ )
+ ).toBe(5);
+ });
+ });
+});
+
+describe("Iteration 2 | Number Sequence", () => {
+ describe("function createSequence()", () => {
+ it("should be defined as a function", () => {
+ expect(typeof createSequence).toBe("function");
+ });
+
+ it("should return an empty array if receives 0 (zero) as argument", () => {
+ expect(createSequence(0)).toEqual([]);
+ });
+
+ it("should return an array with the numbers in range from 0 to n", () => {
+ expect(createSequence(5)).toEqual([0, 1, 2, 3, 4, 5]);
+ expect(createSequence(11)).toEqual([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+ ]);
+ });
+ });
+});
+
+describe("Iteration 3 | Multiply for Each", () => {
+ describe("function multiplyBy()", () => {
+ it("should be defined as a function", () => {
+ expect(typeof multiplyBy).toBe("function");
+ });
+
+ it("should call the forEach() method on the original array to iterate over it", () => {
+ const testArray = [1, 2, 5, 10, 13, 50];
+ const forEachSpy = spyOn(testArray, "forEach").and.callThrough();
+
+ multiplyBy(testArray, 3);
+ expect(forEachSpy).toHaveBeenCalled();
+ // Expect the forEach() method to be called correctly with a callback function as argument
+ expect(forEachSpy.calls.argsFor(0)[0]).toEqual(jasmine.any(Function));
+
+ forEachSpy.calls.reset();
+ });
+
+ it("should return an empty array if receives an empty array as argument", () => {
+ expect(multiplyBy([], 3)).toEqual([]);
+ });
+
+ it("should return an array with the numbers multiplied by the multiplier", () => {
+ expect(multiplyBy([1, 2, 13], 3)).toEqual([3, 6, 39]);
+ expect(multiplyBy([7, 23, 50], 4)).toEqual([28, 92, 200]);
+ });
+ });
+});
+
+describe("Iteration 4 | Filter Out", () => {
+ describe("function filterOut()", () => {
+ it("should be defined as a function", () => {
+ expect(typeof filterOut).toBe("function");
+ });
+
+ it("should return null if receives an empty array as the first argument", () => {
+ expect(filterOut([], ["a", "b"])).toEqual(null);
+ });
+
+ it("should return the original array if receives an empty array as the second argument", () => {
+ expect(filterOut(["a", "b"], [])).toEqual(["a", "b"]);
+ });
+
+ it("should correctly filter out the elements of the second array from the first array", () => {
+ expect(filterOut(["a", "b", "c", "a", "b"], ["a", "b"])).toEqual(["c"]);
+ expect(filterOut(["a", "b", "c", "a", "b"], ["a"])).toEqual(["b", "c", "b"]);
+ });
+ });
+});
+
+describe("Iteration 5 | Unique Arrays", () => {
+ describe("function uniquifyArray()", () => {
+ it("should be defined as a function", () => {
+ expect(typeof uniquifyArray).toBe("function");
+ });
+
+ it("should return null if receives an empty array when called", () => {
+ expect(uniquifyArray([])).toEqual(null);
+ });
+
+ it("should return the correct uniqified array when an array of the same elements passed as argument", () => {
+ expect(uniquifyArray(["Ironhack", "Ironhack", "Ironhack"])).toEqual([
+ "Ironhack",
+ ]);
+ });
+
+ it("should return the same array when no element is repeated", () => {
+ expect(uniquifyArray(["Cat", "Dog", "Cow"])).toEqual([
+ "Cat",
+ "Dog",
+ "Cow",
+ ]);
+ });
+
+ it("should return the uniquified array", () => {
+ expect(
+ uniquifyArray([
+ "iPhone",
+ "Samsung",
+ "Android",
+ "iOS",
+ "iPhone",
+ "Samsung",
+ "Nokia",
+ "Blackberry",
+ "Android",
+ ])
+ ).toEqual(["iPhone", "Samsung", "Android", "iOS", "Nokia", "Blackberry"]);
+ });
+ });
+});
+
+describe("Bonus: Iteration 6 | Product of Adjacent Numbers", () => {
+ describe("function ()", () => {
+ it("should be defined as a function", () => {
+ expect(typeof greatestProduct).toBe("function");
+ });
+
+ it("should return 1 (one) when all numbers of the arrays are 1", () => {
+ let matrix = [
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+ ];
+ expect(greatestProduct(matrix)).toBe(1);
+ });
+
+ it("should return 16 when all the numbers of the arrays are 2", () => {
+ let matrix = [
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
+ ];
+ expect(greatestProduct(matrix)).toBe(16);
+ });
+ });
+});
diff --git a/tests/functions-and-arrays.spec.js b/tests/functions-and-arrays.spec.js
deleted file mode 100644
index 21ec1130c..000000000
--- a/tests/functions-and-arrays.spec.js
+++ /dev/null
@@ -1,329 +0,0 @@
-const shuffle = (currentArray) => {
- const array = [...currentArray];
- let counter = array.length;
-
- while (counter > 0) {
- let randomIndex = Math.floor(Math.random() * counter);
- counter--;
- let temp = array[counter];
- array[counter] = array[randomIndex];
- array[randomIndex] = temp;
- }
- return array;
-};
-
-
-
-describe('Find the maximum', () => {
- it('should declare a function named maxOfTwoNumbers', () => {
- expect(typeof maxOfTwoNumbers).toBe('function');
- });
-
- it('should return greater of two arguments - if the first argument greater', () => {
- expect(maxOfTwoNumbers(2, 1)).toBe(2);
- expect(maxOfTwoNumbers(5, -7)).toBe(5);
- });
-
- it('should return greater of two arguments - if the second argument greater', () => {
- expect(maxOfTwoNumbers(1, 3)).toBe(3);
- expect(maxOfTwoNumbers(-5, 3)).toBe(3);
- });
-
- it('should return either arguments - if both arguments are equal', () => {
- expect(maxOfTwoNumbers(4, 4)).toBe(4);
- });
-});
-
-describe('Find the longest word', () => {
- it('should declare a function named findLongestWord', () => {
- expect(typeof findLongestWord).toBe('function');
- });
-
- it('should return null when called with an empty array', () => {
- expect(findLongestWord([])).toBe(null);
- });
-
- it('should return the word when called with a single-word array', () => {
- expect(findLongestWord(['foo'])).toBe('foo');
- });
-
- it('should return the first occurrence of the word when longest have multiple occurrences ', () => {
- expect(findLongestWord(['foo', 'bar'])).toBe('foo');
- expect(findLongestWord(['bar', 'foo'])).toBe('bar');
- });
-
- it('should return the longest occurrence when it has multiple words', () => {
- let words = ['a', 'zab', '12abc', '$$abcd', 'abcde', 'ironhack'];
- for (let i = 0; i < 10; i++) {
- words = shuffle(words);
- expect(findLongestWord(words)).toBe('ironhack');
- }
- });
-});
-
-describe('Calculate the sum of array of numbers', () => {
- it('should declare a function named sumNumbers', () => {
- expect(typeof sumNumbers).toBe('function');
- });
-
- it('should return zero if receives an empty array when called', () => {
- expect(sumNumbers([])).toBe(0);
- });
-
- it('should return the sum with one number array', () => {
- expect(sumNumbers([4])).toBe(4);
- });
-
- it('should return zero if all elements are zero', () => {
- expect(sumNumbers([0, 0, 0, 0, 0])).toBe(0);
- });
-
- it('should return the sum when passed array of numbers', () => {
- expect(sumNumbers([10, 5, 4, 32, 8])).toBe(59);
- });
-});
-
-describe('Bonus: Calculate the sum', () => {
- it('should declare a function named sum', () => {
- expect(typeof sum).toBe('function');
- });
-
- it('should return zero if receives an empty array when called', () => {
- expect(sum([])).toBe(0);
- });
-
- it('should return the sum with one number array', () => {
- expect(sum([4])).toBe(4);
- });
-
- it('should return zero if all elements are zero', () => {
- expect(sum([0, 0, 0, 0, 0])).toBe(0);
- });
-
- it('should return the sum when passed array of numbers', () => {
- expect(sum([10, 5, 4, 32, 8])).toBe(59);
- });
-
- it('should return the sum when passed array of strings', () => {
- expect(sum(['ana', 'marco', 'nicolas', 'tania', 'ptwd'])).toBe(24);
- });
-
- it('should return the sum when passed array of mixed strings and numbers - ', () => {
- expect(sum([6, 12, 'miami', 1, 'barca', '200', 'lisboa', 8, 10])).toBe(56);
- });
-
- it('should return the sum when passed array of mixed strings, numbers and booleans - ', () => {
- // false is counted as 0
- expect(sum([6, 12, 'miami', 1, 'barca', '200', 'lisboa', 8, false])).toBe(46);
- // true is counted as 1
- expect(sum([6, 12, 'miami', 1, 'barca', '200', 'lisboa', 8, true])).toBe(47);
- });
-
- it('should throw an error when unsupported data type (object or array) present in the array', () => {
- expect(() => sum([6, 12, 'miami', 1, 'barca', '200', 'lisboa', 8, [], {}])).toThrow();
- });
-
-});
-
-describe('Calculate the average of an array of numbers', () => {
- it('should declare a function named averageNumbers', () => {
- expect(typeof averageNumbers).toBe('function');
- });
-
- it('should return null if receives an empty array when called', () => {
- expect(averageNumbers([])).toBe(null);
- });
-
- it('should return the average of a one-element array', () => {
- expect(averageNumbers([9])).toBe(9);
- });
-
- it('should return the average even with negative values', () => {
- expect(averageNumbers([9, -3, -4, 6])).toBe(2);
- });
-
- it('should return the average of the array', () => {
- expect(averageNumbers([9, 10, 82, 92, 32, 102, 58])).toBe(55);
- });
-
-});
-
-describe('Calculate the average of an array of strings', () => {
- it('should declare a function named averageWordLength', () => {
- expect(typeof averageWordLength).toBe('function');
- });
-
- it('should return null if receives an empty array when called', () => {
- expect(averageWordLength([])).toBe(null);
- });
-
- it('should return the average of a one-element array', () => {
- expect(averageWordLength(['ironhack'])).toBe(8);
- });
-
- it('should return the average of a the array', () => {
- expect(
- averageWordLength(['Ironhack', 'Madrid', 'Barcelona', 'Paris', 'Miami', 'Mexico', 'Berlin', 'Programmers'])
- ).toBe(7);
- });
-});
-
-describe('Bonus: Calculate the average of a mixed elements array', () => {
- it('should declare a function named avg', () => {
- expect(typeof avg).toBe('function');
- });
-
- it('should return null if receives an empty array when called', () => {
- expect(avg([])).toBe(null);
- });
-
- it('should return the average of the array', () => {
- // false is counted as 0
- expect(avg([6, 12, 'miami', 1, 'barca', '200', 'lisboa', 8, false])).toBe(46/9);
- // true is counted as 1
- expect(avg([6, 12, 'miami', 1, 'barca', '200', 'lisboa', 8, true])).toBe(47/9);
- });
-});
-
-describe('Unique array', () => {
- it('should declare a function named uniquifyArray', () => {
- expect(typeof uniquifyArray).toBe('function');
- });
-
- it('should return null if receives an empty array when called', () => {
- expect(uniquifyArray([])).toEqual(null);
- });
-
- it('should return the correct uniqified array when an array of the same elements passed as argument', () => {
- expect(uniquifyArray(['Ironhack', 'Ironhack', 'Ironhack'])).toEqual(['Ironhack']);
- });
-
- it('should return the same array when no element is repeated', () => {
- expect(uniquifyArray(['Cat', 'Dog', 'Cow'])).toEqual(['Cat', 'Dog', 'Cow']);
- });
-
- it('should return the uniquified array', () => {
- expect(
- uniquifyArray(['iPhone', 'Samsung', 'Android', 'iOS', 'iPhone', 'Samsung', 'Nokia', 'Blackberry', 'Android'])
- ).toEqual(['iPhone', 'Samsung', 'Android', 'iOS', 'Nokia', 'Blackberry']);
- });
-});
-
-describe('Find elements', () => {
- it('should declare a function named doesWordExist', () => {
- expect(typeof doesWordExist).toBe('function');
- });
-
- it('should return null if receives an empty array when called', () => {
- expect(doesWordExist([])).toBe(null);
- });
-
- it('should return true if the word we are looking for is the only one in the array', () => {
- expect(doesWordExist(['machine'], 'machine')).toBe(true);
- });
-
- it('should return false if the word we are looking for is not in the array', () => {
- expect(doesWordExist(['machine', 'poison', 'eat', 'apple', 'horse'], 'ratatouille')).toBe(false);
- });
-
- it('should return true if the word we are looking for is in the array', () => {
- expect(doesWordExist(['pizza', 'sandwich', 'snack', 'soda', 'book', 'computer'], 'book')).toBe(true);
- });
-});
-
-describe('Count repetition', () => {
- it('should declare a function named howManyTimes', () => {
- expect(typeof howManyTimes).toBe('function');
- });
-
- it('should return 0 (zero) if receives an empty array when called', () => {
- expect(howManyTimes([])).toBe(0);
- });
-
- it('should return 1 (one) when the word appears only one time in the array', () => {
- expect(howManyTimes(['basketball', 'football', 'tennis'], 'tennis')).toBe(1);
- });
-
- it("should return 0 (zero) when the word doesn't appear in the array", () => {
- expect(howManyTimes(['basketball', 'football', 'tennis'], 'rugby')).toBe(0);
- });
-
- it('should return 5 (five) when the word appears 5 times in the array', () => {
- expect(
- howManyTimes(
- [
- 'basketball',
- 'football',
- 'tennis',
- 'rugby',
- 'rugby',
- 'ping pong',
- 'rugby',
- 'basketball',
- 'rugby',
- 'handball',
- 'rugby'
- ],
- 'rugby'
- )
- ).toBe(5);
- });
-});
-
-describe('Bonus Quest - greatestProduct', () => {
- it('should declare a function named greatestProduct', () => {
- expect(typeof greatestProduct).toBe('function');
- });
-
- it('should return 1 (one) when all numbers of the arrays are 1', () => {
- let matrix = [
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
- [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
- ];
- expect(greatestProduct(matrix)).toBe(1);
- });
-
- it('should return 16 when all the numbers of the arrays are 2', () => {
- let matrix = [
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
- [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
- ];
- expect(greatestProduct(matrix)).toBe(16);
- });
-});