Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

"Solved lab" #4167

Open
wants to merge 2 commits into
base: master
Choose a base branch
from
Open

"Solved lab" #4167

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
a448f45
LAB 1 One Last bonus to finish
AngelePerrot Sep 15, 2024
af31a57
Solved lab
AngelePerrot Sep 15, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
329 changes: 260 additions & 69 deletions src/functions-and-arrays.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,119 +1,310 @@
// Iteration #1: Find the maximum
function maxOfTwoNumbers() {}
// ------------------------------------------------ Iteration #1: Find the maximum - Done

function maxOfTwoNumbers(num1, num2) {
return num1 > num2 ? num1 : num2;
}

// ------------------------------------------------ Iteration #2: Find longest word - Done

const words = [
"mystery",
"brother",
"aviator",
"crocodile",
"pearl",
"orchard",
"crackpot",
];

function findLongestWord(words) {
if (words.length === 0) return null;

// Iteration #2: Find longest word
const words = ['mystery', 'brother', 'aviator', 'crocodile', 'pearl', 'orchard', 'crackpot'];
let longestWord = words[0];

function findLongestWord() {}
for (let i = 1; i < words.length; i++) {
if (words[i].length > longestWord.length) {
longestWord = words[i];
}
}

return longestWord;
}

console.log(findLongestWord(words));

// ------------------------------------------------ Iteration #3: Calculate the sum - Done

// Iteration #3: Calculate the sum
const numbers = [6, 12, 1, 18, 13, 16, 2, 1, 8, 10];

function sumNumbers() {}
function sumNumbers(arraysNumbers) {
if (arraysNumbers.length === 0) return 0;

let sum = 0;

for (let i = 0; i < arraysNumbers.length; i++) {
sum += arraysNumbers[i];
}
return sum;
}

// Iteration #3.1 Bonus:
function sum() {}
console.log(sumNumbers(numbers));

//Iteration #3.1 Bonus:

const mixedArr = [6, 12, "miami", 1, true, "barca", "200", "lisboa", 8, 10];

// Iteration #4: Calculate the average
// Level 1: Array of numbers
const numbersAvg = [2, 6, 9, 10, 7, 4, 1, 9];
function sum(arrayBonus3) {
if (arrayBonus3.some((item) => typeof item === "object")) {
throw new Error("Object can't be calculated in this function");
}

function averageNumbers() {}
let total = 0;

for (let item of arrayBonus3) {
if (typeof item === "number") {
total += item;
} else if (typeof item === "string") {
total += item.length;
} else if (typeof item === "boolean") {
total += item ? 1 : 0;
}
}

// Level 2: Array of strings
const wordsArr = ['seat', 'correspond', 'linen', 'motif', 'hole', 'smell', 'smart', 'chaos', 'fuel', 'palace'];
return total;
}

console.log(sum(mixedArr));

function averageWordLength() { }
// ------------------------------------------------ Iteration #4: Calculate the average - Done
// Level 1: Array of numbers - Done
const numbersAvg = [2, 6, 9, 10, 7, 4, 1, 9];

// Bonus - Iteration #4.1
function avg() {}
function averageNumbers(numbersAvgArray) {
if (numbersAvgArray.length === 0) return null;

// Iteration #5: Unique arrays
const wordsUnique = [
'crab',
'poison',
'contagious',
'simple',
'bring',
'sharp',
'playground',
'poison',
'communion',
'simple',
'bring'
let result = sumNumbers(numbersAvgArray) / numbersAvgArray.length;
return result;
}
console.log(averageNumbers(numbersAvg));

// Level 2: Array of strings - Done
const wordsArr = [
"seat",
"correspond",
"linen",
"motif",
"hole",
"smell",
"smart",
"chaos",
"fuel",
"palace",
];

function uniquifyArray() {}
function averageWordLength(array) {
if (array.length === 0) return null;

let sum = 0;
for (let i = 0; i < array.length; i++) {
sum += array[i].length;
}
return sum / array.length;
}
console.log(averageWordLength(wordsArr));

// ------------------------------------------------ Bonus - Iteration #4.1 - Done
function avg(arr) {
if (!arr.length) return null;

// Iteration #6: Find elements
const wordsFind = ['machine', 'subset', 'trouble', 'starting', 'matter', 'eating', 'truth', 'disobedience'];
let total = 0;

function doesWordExist() {}
for (let item of arr) {
if (typeof item === "number") {
total += item;
} else if (typeof item === "string") {
total += item.length;
} else if (typeof item === "boolean") {
total += item ? 1 : 0;
}
}

return total / arr.length;
}

console.log(avg(mixedArr));
// ------------------------------------------------ Iteration #5: Unique arrays - Done
const wordsUnique = [
"crab",
"poison",
"contagious",
"simple",
"bring",
"sharp",
"playground",
"poison",
"communion",
"simple",
"bring",
];

function uniquifyArray(array) {
if (!array.length) return null;

return [...new Set(array)];
}
console.log(uniquifyArray(wordsUnique));

// ------------------------------------------------ Iteration #6: Find elements
const wordsFind = [
"machine",
"subset",
"trouble",
"starting",
"matter",
"eating",
"truth",
"disobedience",
];

function doesWordExist(array, word) {
if (!array.length) return null;

// Iteration #7: Count repetition
return array.includes(word);
}
console.log(doesWordExist(wordsFind, "machine"));
console.log(doesWordExist(wordsFind, "subset"));
console.log(doesWordExist(wordsFind, "unknown"));
console.log(doesWordExist(wordsFind, "truth"));
console.log(doesWordExist(wordsFind, "nonexistent"));

// ------------------------------------------------ Iteration #7: Count repetition
const wordsCount = [
'machine',
'matter',
'subset',
'trouble',
'starting',
'matter',
'eating',
'matter',
'truth',
'disobedience',
'matter'
"machine",
"matter",
"subset",
"trouble",
"starting",
"matter",
"eating",
"matter",
"truth",
"disobedience",
"matter",
];

function howManyTimes() {}
function howManyTimes(array, word) {
let count = 0;

array.forEach((item) => {
if (item === word) {
count++;
}
});
return count;
}

console.log(howManyTimes(wordsCount, "truth"));

// Iteration #8: Bonus
// ------------------------------------------------ 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],
[
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],
[
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],
[
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],
[
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]
[
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() {}



function greatestProduct(array) {
if (!array.length) return null;

let maxProduct = 0;

const rows = matrix.length;
const cols = matrix[0].length;

// Check horizontal and vertical products
for (let i = 0; i < rows; i++) {
for (let j = 0; j < cols - 3; j++) {
// Horizontal product
const horizProduct =
matrix[i][j] * matrix[i][j + 1] * matrix[i][j + 2] * matrix[i][j + 3];
maxProduct = Math.max(maxProduct, horizProduct);
}
}

for (let i = 0; i < rows - 3; i++) {
for (let j = 0; j < cols; j++) {
// Vertical product
const vertProduct =
matrix[i][j] * matrix[i + 1][j] * matrix[i + 2][j] * matrix[i + 3][j];
maxProduct = Math.max(maxProduct, vertProduct);
}
}

return maxProduct;
}
console.log(greatestProduct(matrix));

// The following is required to make unit tests work.
/* Environment setup. Do not modify the below code. */
if (typeof module !== 'undefined') {
if (typeof module !== "undefined") {
module.exports = {
maxOfTwoNumbers,
findLongestWord,
Expand All @@ -125,6 +316,6 @@ if (typeof module !== 'undefined') {
uniquifyArray,
doesWordExist,
howManyTimes,
greatestProduct
greatestProduct,
};
}