├── Tutorial_traduzir_W3.js ├── .gitignore ├── imagens_tutorial ├── img1.png ├── img2.png └── img3.png ├── Desafios ├── Destructuring e HOFs │ ├── desafio-hofs-03.js │ ├── desafio-hofs-04.js │ ├── desafio-hofs-05.js │ ├── desafio-hofs-06.js │ ├── desafio-hofs-01.js │ ├── desafio-hofs-02.js │ ├── index.js │ ├── Gabaritos │ │ └── 1-6.js │ └── data.js ├── Desafiadores │ ├── desafiador-012.js │ ├── desafiador-014.js │ ├── desafiador-010.js │ ├── desafiador-013.js │ ├── desafiador-015.js │ ├── desafiador-07.js │ ├── desafiador-03.js │ ├── desafiador-01.js │ ├── desafiador-08.js │ ├── desafiador-02.js │ ├── desafiador-06.js │ ├── index.js │ ├── desafiador-09.js │ ├── desafiador-011.js │ ├── desafiador-05.js │ ├── desafiador-04.js │ ├── desafiador-016.js │ └── Gabaritos │ │ ├── 11-16.js │ │ └── 1-10.js ├── Operadores Aritméticos │ ├── desafio-operadores-aritmeticos-04.js │ ├── desafio-operadores-aritmeticos-09.js │ ├── desafio-operadores-aritmeticos-013.js │ ├── desafio-operadores-aritmeticos-016.js │ ├── desafio-operadores-aritmeticos-010.js │ ├── desafio-operadores-aritmeticos-018.js │ ├── desafio-operadores-aritmeticos-01.js │ ├── desafio-operadores-aritmeticos-05.js │ ├── desafio-operadores-aritmeticos-03.js │ ├── desafio-operadores-aritmeticos-014.js │ ├── desafio-operadores-aritmeticos-023.js │ ├── desafio-operadores-aritmeticos-06.js │ ├── desafio-operadores-aritmeticos-02.js │ ├── desafio-operadores-aritmeticos-07.js │ ├── desafio-operadores-aritmeticos-08.js │ ├── desafio-operadores-aritmeticos-020.js │ ├── desafio-operadores-aritmeticos-011.js │ ├── desafio-operadores-aritmeticos-012.js │ ├── desafio-operadores-aritmeticos-021.js │ ├── desafio-operadores-aritmeticos-015.js │ ├── desafio-operadores-aritmeticos-022.js │ ├── desafio-operadores-aritmeticos-019.js │ ├── desafio-operadores-aritmeticos-017.js │ ├── Gabaritos │ │ ├── 21-23.js │ │ ├── 1-10.js │ │ └── 11-20.js │ └── index.js ├── Arrays │ ├── desafio-arrays-01.js │ ├── desafio-arrays-02.js │ ├── index.js │ ├── desafio-arrays-04.js │ ├── desafio-arrays-03.js │ ├── desafio-arrays-05.js │ └── Gabaritos │ │ └── 1-5.js ├── Estruturas de Repetições │ ├── desafio-estrutura-repeticoes-08.js │ ├── desafio-estrutura-repeticoes-03.js │ ├── desafio-estrutura-repeticoes-01.js │ ├── desafio-estrutura-repeticoes-06.js │ ├── desafio-estrutura-repeticoes-04.js │ ├── desafio-estrutura-repeticoes-07.js │ ├── desafio-estrutura-repeticoes-02.js │ ├── desafio-estrutura-repeticoes-05.js │ ├── desafio-estrutura-repeticoes-09.js │ ├── index.js │ └── Gabaritos │ │ └── 1-9.js ├── Objetos │ ├── index.js │ ├── desafio-objetos-04.js │ ├── desafio-objetos-03.js │ ├── desafio-objetos-01.js │ ├── desafio-objetos-02.js │ ├── desafio-objetos-05.js │ └── Gabaritos │ │ └── 1-5.js ├── Strings │ ├── desafio-strings-02.js │ ├── desafio-strings-09.js │ ├── desafio-strings-01.js │ ├── desafio-strings-08.js │ ├── desafio-strings-05.js │ ├── desafio-strings-03.js │ ├── desafio-strings-04.js │ ├── desafio-strings-06.js │ ├── Gabaritos │ │ ├── 10.js │ │ └── 1-9.js │ ├── index.js │ ├── desafio-strings-10.js │ └── desafio-strings-07.js └── Estruturas Condicionais │ ├── desafio-condicionais-011.js │ ├── desafio-condicionais-016.js │ ├── desafio-condicionais-08.js │ ├── desafio-condicionais-015.js │ ├── desafio-condicionais-07.js │ ├── desafio-condicionais-01.js │ ├── desafio-condicionais-013.js │ ├── desafio-condicionais-06.js │ ├── desafio-condicionais-017.js │ ├── desafio-condicionais-03.js │ ├── desafio-condicionais-05.js │ ├── desafio-condicionais-02.js │ ├── desafio-condicionais-012.js │ ├── desafio-condicionais-04.js │ ├── desafio-condicionais-014.js │ ├── desafio-condicionais-09.js │ ├── index.js │ ├── desafio-condicionais-018.js │ ├── desafio-condicionais-010.js │ └── Gabaritos │ ├── 1-10.js │ └── 11-18.js ├── package.json ├── test ├── arrays.test.js ├── mocks.js ├── estruturasDeRepeticoes.test.js ├── objetos.test.js ├── destructuringEHofs.test.js ├── strings.test.js ├── desafiadores.test.js ├── operadoresAritmeticos.test.js └── estruturasCondicionais.test.js └── README.md /Tutorial_traduzir_W3.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | -------------------------------------------------------------------------------- /imagens_tutorial/img1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tryber/exercises-programming-logic-challenges/HEAD/imagens_tutorial/img1.png -------------------------------------------------------------------------------- /imagens_tutorial/img2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tryber/exercises-programming-logic-challenges/HEAD/imagens_tutorial/img2.png -------------------------------------------------------------------------------- /imagens_tutorial/img3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tryber/exercises-programming-logic-challenges/HEAD/imagens_tutorial/img3.png -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/desafio-hofs-03.js: -------------------------------------------------------------------------------- 1 | const data = require('./data'); 2 | 3 | // 3 - Retorne um array utilizando HOF's que contenha apenas o nome das bandas 4 | 5 | const getBandsName = () => { 6 | 7 | } 8 | 9 | module.exports = getBandsName; 10 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/desafio-hofs-04.js: -------------------------------------------------------------------------------- 1 | const data = require('./data'); 2 | 3 | // 4 - Filtre e retorne um array apenas com o nome das bandas que são dos Estados Unidos 4 | 5 | const usaFilter = () => { 6 | 7 | } 8 | 9 | module.exports = usaFilter; 10 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/desafio-hofs-05.js: -------------------------------------------------------------------------------- 1 | const data = require('./data'); 2 | 3 | // 5 - Filtre e retorne um array com os nomes das bandas que contenham 'Rock' no gênero musical 4 | 5 | const rockFilter = () => { 6 | 7 | } 8 | 9 | module.exports = rockFilter; 10 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/desafio-hofs-06.js: -------------------------------------------------------------------------------- 1 | const data = require('./data'); 2 | 3 | // 6 - Filtre e retorne um array com todos os álbuns que possuem nota igual a 100 4 | 5 | const highestRatingFilter = () => { 6 | 7 | } 8 | 9 | module.exports = highestRatingFilter; 10 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-012.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 12 - Fatorial 4 | 5 | Escreva um algoritmo que recebe um número n e calcule e retorne o seu fatorial. 6 | 7 | */ 8 | 9 | function factorial(n) { 10 | // Desenvolva seu código nessa função 11 | } 12 | 13 | module.exports = factorial; 14 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/desafio-hofs-01.js: -------------------------------------------------------------------------------- 1 | const data = require('./data'); 2 | 3 | /** 1 - Retorne e exiba um array com as informações da primeira e da segunda banda utilizando destructuring 4 | */ 5 | const getBandsInformation = () => { 6 | 7 | } 8 | 9 | module.exports = getBandsInformation; 10 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-014.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 14 - Soma de números primos 4 | 5 | Escreva um algoritmo que some números primos de 0 à 150 e retorne o resultado. 6 | 7 | */ 8 | 9 | function sumPrimesNumbers(){ 10 | // Desenvolva seu código nessa função 11 | } 12 | 13 | module.exports = sumPrimesNumbers; 14 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Potência de um número 4 | 5 | Escreva um algoritmo que recebe uma base e um expoente numéricos e retorne o resultando da exponenciação. 6 | 7 | */ 8 | 9 | function powerNumber(base, exponent){ 10 | // Desenvolva seu código nessa função 11 | } 12 | 13 | module.exports = powerNumber; 14 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-09.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 09 - Celsius 4 | 5 | Escreva um algoritmo que faça conversão de temperatura em graus Celsius para graus Fahrenheit e o retorne. 6 | 7 | */ 8 | 9 | function celsiusToFahrenheit(celsius){ 10 | // Desenvolva seu código nessa função 11 | } 12 | 13 | module.exports = celsiusToFahrenheit; 14 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-013.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 13 - Cor aleatória 4 | 5 | Elabore uma função que retorne uma cor RGB aleatória no formato: 6 | -------------- 7 | "rgb(r, g, b)" 8 | -------------- 9 | 10 | */ 11 | 12 | function generateColor(){ 13 | // Desenvolva seu código nessa função 14 | } 15 | 16 | module.exports = generateColor; 17 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-016.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 16 - Verdadeiro ou falso? 4 | 5 | Escreva um algoritmo que retorne de forma aleatória true ou false. 6 | 7 | Obs: O retorne deve ser do tipo boolean. 8 | 9 | */ 10 | 11 | function randomBoolean(){ 12 | // Desenvolva seu código nessa função 13 | } 14 | 15 | module.exports = randomBoolean; 16 | -------------------------------------------------------------------------------- /Desafios/Arrays/desafio-arrays-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Encontre o maior número de um array 4 | 5 | Escreva um algoritmo que recebe um array de números inteiros, procure o maior valor e o retorne. 6 | 7 | */ 8 | 9 | function getMaxNumber(numbers) { 10 | // Desenvolva seu código nessa função 11 | return // Retorne o resultado aqui 12 | } 13 | 14 | module.exports = getMaxNumber; 15 | -------------------------------------------------------------------------------- /Desafios/Arrays/desafio-arrays-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Encontre o menor número de um array 4 | 5 | Escreva um algoritmo que recebe um array de números inteiros, procure o menor valor e o retorne. 6 | 7 | */ 8 | 9 | function getMinNumber(numbers) { 10 | // Desenvolva seu código nessa função 11 | return // Retorne o resultado aqui 12 | } 13 | 14 | module.exports = getMinNumber; 15 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/desafio-hofs-02.js: -------------------------------------------------------------------------------- 1 | const data = require('./data'); 2 | 3 | /* 2 - Através do destructuring, acesse o nome e os melhores álbuns primeira banda, 4 | retornando uma string no seguinte formato: "os melhores álbuns do Radiohead: In Rainbows,Kid A,OK Computer,Pablo Honey" 5 | */ 6 | 7 | const getBestAlbuns = () => { 8 | 9 | } 10 | 11 | 12 | module.exports = getBestAlbuns; 13 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-010.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 10 - Fahrenheit 4 | 5 | Escreva um algoritmo que faça conversão de temperatura em graus Fahrenheit para graus Celsius e retorne 6 | a temperatura em celsius. 7 | 8 | */ 9 | 10 | function fahrenheitToCelsius(fahrenheit){ 11 | // Desenvolva seu código nessa função 12 | } 13 | 14 | module.exports = fahrenheitToCelsius; 15 | -------------------------------------------------------------------------------- /Desafios/Arrays/index.js: -------------------------------------------------------------------------------- 1 | const getMaxNumber = require('./desafio-arrays-01'); 2 | const getMinNumber = require('./desafio-arrays-02'); 3 | const findGuest = require('./desafio-arrays-03'); 4 | const dataType = require('./desafio-arrays-04'); 5 | const findOldestSon = require('./desafio-arrays-05'); 6 | 7 | module.exports = { 8 | getMaxNumber, 9 | getMinNumber, 10 | findGuest, 11 | dataType, 12 | findOldestSon, 13 | }; 14 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-018.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 18 - Simulação de dado RPG 4 | 5 | Escreva um algoritmo que faça a simulação de um dado de RPG que vai receber como parâmetro o número de lados do dado. 6 | 7 | Exemplo: um D-6 vai sortear um número entre 1 e 6. 8 | 9 | */ 10 | 11 | function rollDice(diceSide) { 12 | // Desenvolva seu código nessa função 13 | } 14 | 15 | module.exports = rollDice; 16 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-08.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 08 - Ordem decrescente 4 | 5 | Escreva um algoritmo que retorne uma string com os números inteiros do intervalo de 100 a 200 em ordem decrescente. 6 | 7 | Exemplo de saída: 8 | ------------- 9 | x, y, z ...n. 10 | ------------- 11 | 12 | */ 13 | 14 | function sortDec(){ 15 | // Desenvolva seu código nessa função 16 | } 17 | 18 | module.exports = sortDec; 19 | -------------------------------------------------------------------------------- /Desafios/Objetos/index.js: -------------------------------------------------------------------------------- 1 | const fantasyGame = require('./desafio-objetos-01'); 2 | const fantasyGame2 = require('./desafio-objetos-02'); 3 | const musicalScale = require('./desafio-objetos-03'); 4 | const getOldPerson = require('./desafio-objetos-04'); 5 | const fantasyGame3 = require('./desafio-objetos-05'); 6 | 7 | module.exports = { 8 | fantasyGame, 9 | fantasyGame2, 10 | musicalScale, 11 | getOldPerson, 12 | fantasyGame3, 13 | }; 14 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Calcular a média 4 | 5 | Escreva um algoritmo que recebe 3 valores, calcule e retorne o valor da média no formato abaixo: 6 | 7 | --------------------- 8 | "O Valor médio é: x." 9 | --------------------- 10 | 11 | */ 12 | 13 | function average(number1, number2, number3){ 14 | // Desenvolva seu código nessa função 15 | } 16 | 17 | module.exports = average; 18 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-010.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 10 - Nega Números 4 | 5 | Escreva uma algoritmo que recebe um array de números, retorne uma cópia do array com todos os números negados. 6 | 7 | Por exemplo: 8 | -------------- 9 | Entrada: 10 | [2 ,-3 ,4 ] 11 | 12 | Saída: 13 | [-2, 3 ,-4 ] 14 | -------------- 15 | 16 | */ 17 | 18 | function negateNumbers(numbers){ 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = negateNumbers; 23 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Converte para numero 4 | 5 | Escreva um algoritmo que recebe uma string que representa um número inteiro e retorne o valor convertido para o tipo number. 6 | 7 | Por exemplo: 8 | ------------ 9 | Entrada: 10 | "1" 11 | 12 | Saída: 13 | 1 14 | ------------ 15 | 16 | */ 17 | 18 | function converteType(string) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = converteType; 23 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Calcular a soma de 1 até 1000 4 | 5 | Escreva um algoritmo que calcule a soma de 1 a 1000 usando a estrutura "for" e retorne no formato: 6 | -------------------------- 7 | "A soma de 1 a 1000 é: x." 8 | -------------------------- 9 | 10 | */ 11 | 12 | function accumulatorThousand(){ 13 | // Desenvolva seu código nessa função 14 | } 15 | 16 | module.exports = accumulatorThousand; 17 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-09.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 09 - Brincando de espionagem 4 | 5 | Joana e Jonas estão brincando de espionagem e querem trocar mensagens codificadas. 6 | 7 | Escreva um algoritmo que recebe uma string troque as vogais no seguinte padrão e a retorne: 8 | a - 5 9 | e - b 10 | i - 9 11 | o - p 12 | u - 1 13 | 14 | */ 15 | 16 | function encodeMessage(string) { 17 | // Desenvolva seu código nessa função 18 | } 19 | 20 | module.exports = encodeMessage; 21 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Mensagem codificada 4 | 5 | Escreva um algoritmo que recebe uma string e retorne outra string com o index dos respectivos caracteres multiplicado por 3. 6 | 7 | Exemplo: 8 | --------- 9 | Entrada: 10 | "Trybe" 11 | 12 | Saída: 13 | "036912". 14 | --------- 15 | 16 | */ 17 | 18 | function encode(string){ 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = encode; 23 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-011.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 11 - Triplica vogais 4 | 5 | Escreva um algoritmo que recebe uma string (frase ou palavra) e retorne uma outra string com as vogais "triplicadas". 6 | 7 | Por exemplo: 8 | ------------ 9 | Entrada: 10 | "Camelo" 11 | 12 | Saída: 13 | "Caaameeelooo" 14 | -------------- 15 | 16 | */ 17 | 18 | function triVowels(word){ 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = triVowels; 23 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Inverte nomes 4 | 5 | Escreva um algoritmo que recebe uma string com o formato "Nome Sobrenome" e retorne 6 | uma outra string com os nomes invertidos. 7 | 8 | Por exemplo: 9 | --------------------- 10 | Entrada: 11 | "Xablau Xablauzinho" 12 | 13 | Saída: 14 | "Xablauzinho Xablau" 15 | --------------------- 16 | 17 | */ 18 | 19 | function reverseNames(fullName) { 20 | // Desenvolva seu código nessa função 21 | } 22 | 23 | module.exports = reverseNames; 24 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-08.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 08 - Descubra quantas letras tem 4 | 5 | Escreva um algoritmo que recebe 2 parâmetros: uma string (frase ou palavra) e uma letra. 6 | 7 | A função deve retornar quantas letras passadas como 2º parâmetro existem na string. 8 | 9 | Obs: Trate as vogais com acento como não tendo, por exemplo: 10 | a = á, ã, à. 11 | 12 | */ 13 | 14 | function countLetters(string, letter) { 15 | // Desenvolva seu código nessa função 16 | } 17 | 18 | module.exports = countLetters; 19 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-016.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 16 - Imprima a idade em ordem crescente 4 | 5 | Escreva um algoritmo que recebe a idade de Marina, Silvia e Iza e retorne uma string com as idades em ordem crescente. 6 | 7 | Por exemplo: 8 | ------------- 9 | Entrada: 10 | 21, 20, 19 11 | 12 | Saída: 13 | "19, 20, 21" 14 | ------------- 15 | 16 | */ 17 | 18 | function sortAgeAsc(mariaAge, silviaAge, izaAge){ 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = sortAgeAsc; 23 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Área de um triângulo 4 | 5 | Escreva um algoritmo que calcule a área de um triângulo. 6 | Área = (base*altura) / 2 e retorne no formato: 7 | 8 | ----------------------------------------------- 9 | "A área do triângulo de base x e altura y é: z." 10 | ----------------------------------------------- 11 | 12 | */ 13 | 14 | function triangleArea(base, height){ 15 | // Desenvolva seu código nessa função 16 | } 17 | 18 | module.exports = triangleArea; 19 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Antecessor e Sucessor 4 | 5 | Escreva um algoritmo que recebe um número inteiro e retorne o seu antecessor e sucessor no seguinte formato: 6 | 7 | -------------------------------------------------- 8 | "O antecessor de "number" é x e seu sucessor é y." 9 | -------------------------------------------------- 10 | 11 | */ 12 | 13 | function showNeighbors(number){ 14 | // Desenvolva seu código nessa função 15 | } 16 | 17 | module.exports = showNeighbors; 18 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Primeira e última letra 4 | 5 | Escreva um algoritmo que recebe uma palavra e retorne uma mensagem com a primeira e ultima letra. 6 | 7 | Por exemplo: 8 | --------------------------------------------- 9 | Entrada: 10 | "Sandy" 11 | 12 | Saída: 13 | "A primeira letra é: S, a última letra é: y." 14 | --------------------------------------------- 15 | 16 | */ 17 | 18 | function firstLastLetter(word) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = firstLastLetter; 23 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/index.js: -------------------------------------------------------------------------------- 1 | const getBandsInformation = require('./desafio-hofs-01.js'); 2 | const getBestAlbuns = require('./desafio-hofs-02.js'); 3 | const getBandsName = require('./desafio-hofs-03.js'); 4 | const usaFilter = require('./desafio-hofs-04.js'); 5 | const rockFilter = require('./desafio-hofs-05.js'); 6 | const highestRatingFilter = require('./desafio-hofs-06.js'); 7 | 8 | module.exports = { 9 | getBandsInformation, 10 | getBestAlbuns, 11 | getBandsName, 12 | usaFilter, 13 | rockFilter, 14 | highestRatingFilter 15 | }; 16 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-06.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 06 - Retorne os números ímpares 4 | 5 | A Dora aventureira gostaria de ter uma lista com todos o números ímpares entre 1 e 50. 6 | 7 | Crie um algoritmo que retorne uma string com todos os números inteiros ímpares desse intervalo. 8 | 9 | Use a seguinte estrutura no retorno: 10 | ---------------- 11 | "x, y, z, ...n." 12 | ---------------- 13 | 14 | */ 15 | 16 | function oddNumbers(){ 17 | // Desenvolva seu código nessa função 18 | } 19 | 20 | module.exports = oddNumbers; 21 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-014.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 14 - Tempo de viagem 4 | 5 | Escreva um algoritmo que recebe a duração total de uma viagem em minutos e retorne a duração em horas e minutos no seguinte formato: 6 | 7 | -------------------------------------------------- 8 | "A viagem terá duração de x hora(s) e y minuto(s)" 9 | -------------------------------------------------- 10 | 11 | */ 12 | 13 | function timeTravel(totalMinutes){ 14 | // Desenvolva seu código nessa função 15 | } 16 | 17 | module.exports = timeTravel; 18 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-023.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 23 - Divisões sucessivas 4 | 5 | Escreva um algoritmo que leia um número e divida-o por dois sucessivamente até que o seu resultado seja menor que 1. 6 | 7 | Retorne a quantidade de vezes que o número foi dividido no formato: 8 | -------------------------- 9 | 'Quantidade total de divisões: n' 10 | -------------------------- 11 | 12 | */ 13 | 14 | function successiveDivisions(number) { 15 | // Desenvolva seu código nessa função 16 | } 17 | 18 | module.exports = successiveDivisions; 19 | -------------------------------------------------------------------------------- /Desafios/Arrays/desafio-arrays-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Verifique se todos os dados de uma lista são do mesmo tipo 4 | 5 | Escreva uma algoritmo que recebe um array de dados quaisquer e verifique se todos são do mesmo tipo. 6 | 7 | Se todos forem retorne: 8 | ------ 9 | true 10 | ------ 11 | 12 | Caso contrário: 13 | ------- 14 | false 15 | ------- 16 | 17 | Obs: Os retornos tem que ser dados do tipo boolean. 18 | 19 | */ 20 | 21 | function dataType(types){ 22 | // Desenvolva seu código aqui. 23 | return // Retorne o resultado aqui 24 | } 25 | 26 | module.exports = dataType; 27 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Escreva um nome N vezes 4 | 5 | Escreva um algoritmo usando a estrutura "FOR" que irá receber um nome e a quantidade de vezes que o mesmo deve ser repetido e retorná-lo. 6 | 7 | Por exemplo: 8 | ------------------------------- 9 | Entradas: 10 | "João", 5 11 | 12 | Saída: 13 | "João, João, João, João, João." 14 | ------------------------------- 15 | 16 | */ 17 | 18 | function repeatName(name, quantity) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = repeatName; 23 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Apresentação pessoal 4 | 5 | Escreva um algoritmo que recebe o primeiro e o último nome de uma pessoa mais a idade, e retorne uma mensagem. 6 | 7 | Por exemplo: 8 | --------------------------------------------------- 9 | Entradas: 10 | "João","Carvalho', 25 11 | 12 | Saída: 13 | "Meu nome é João Carvalho e tenho 25 anos de vida." 14 | --------------------------------------------------- 15 | 16 | */ 17 | 18 | function personalPresentation(firstName, lastName, age) { 19 | 20 | } 21 | 22 | module.exports = personalPresentation; 23 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-08.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 08 - Descubra a idade mínima 4 | 5 | Escreva um algoritmo que recebe a idade de Marina, Silvia e Iza e retorne a mensagem informando a pessoa mais jovem no seguinte formato: 6 | --------------------------------------------------- 7 | "x é a pessoa mais jovem e possui y anos de idade." 8 | --------------------------------------------------- 9 | 10 | */ 11 | 12 | function findYoungerPerson(marinaAge, silviaAge, izaAge){ 13 | // Desenvolva seu código nessa função 14 | } 15 | 16 | module.exports = findYoungerPerson; 17 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-06.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 06 - Calcular IMC 4 | 5 | André resolveu criar seu próprio programa de cálculo de Índice de Massa Corporal (IMC). 6 | 7 | Considere que: 8 | * A fórmula para calcular o IMC é divisão do peso (em kg) pela altura ao quadrado (em metros); 9 | * André pesa 75 kg e sua altura é 1,80 m; 10 | 11 | Escreva o algoritmo usado por André para calcular seu próprio IMC e o retorne. 12 | 13 | */ 14 | 15 | function IMC(weight, height){ 16 | // Desenvolva seu código nessa função 17 | } 18 | 19 | module.exports = IMC; 20 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-07.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 07 - Onde está o elemento? 4 | 5 | Escreva uma algoritmo que recebe 2 parâmetros (um array e um elemento que está contido no array) e retorne a posição em que o elemento se encontra no array. 6 | 7 | Caso não encontre o elemento, retorne: 8 | ----------------------------------- 9 | "Elemento Não encontrado no array." 10 | ----------------------------------- 11 | 12 | */ 13 | 14 | function findIndexOf(array, element){ 15 | // Desenvolva seu código nessa função 16 | } 17 | 18 | module.exports = findIndexOf; 19 | 20 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-015.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 15 - Pedra, papel e tesoura 4 | 5 | Escreva um algoritmo que simula o jogo "pedra, papel e tesoura" levando em consideração que são apenas duas pessoas jogando e retorne o resultado no seguinte formato: 6 | --------------------------------------------- 7 | "Player 1 won" ou "A Ties" ou "Player 2 won". 8 | --------------------------------------------- 9 | 10 | */ 11 | 12 | function rockPaperScissors(signPerson1, signPerson2){ 13 | // Desenvolva seu código nessa função 14 | } 15 | 16 | module.exports = rockPaperScissors; 17 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Contar até 10 4 | 5 | Maria está aprendendo lógica de programação e recebeu o seguinte código: 6 | 7 | let limit = 10 8 | let accumulator = 1; 9 | while(contador <= limit){ 10 | accumulator = accumulator + 1; 11 | } 12 | 13 | Considerando a mesma lógica, escreva um algoritmo que irá somar todos números de 1 até o limite usando o For em vez de while e o retorne. 14 | 15 | */ 16 | 17 | function accumulator(limit){ 18 | // Desenvolva seu código nessa função 19 | } 20 | 21 | module.exports = accumulator; 22 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-013.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 13 - Fibonacci 4 | 5 | A sequência de números 0 1 1 2 3 5 8 13 21...n é conhecida como sequência de Fibonacci. 6 | 7 | Nessa sequência, cada número, depois dos 2 primeiros é igual à soma dos 2 anteriores. 8 | 9 | Escreva um algoritmo que recebe um valor n que corresponde ao enésimo número da sequência e retorne o enésimo número da sequência de Fibonnaci. 10 | 11 | Por exemplo: 12 | ------------ 13 | Entrada: 14 | 5 15 | 16 | Saída: 17 | 3 18 | ------------ 19 | 20 | */ 21 | 22 | function fibonnaci(n){ 23 | // Desenvolva seu código nessa função 24 | } 25 | 26 | module.exports = fibonnaci; 27 | -------------------------------------------------------------------------------- /Desafios/Arrays/desafio-arrays-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Encontre uma pessoa convidada em uma lista de nomes 4 | 5 | Escreva um algoritmo que recebe um array de nomes quaisquer e o nome da pessoa convida a ser encontrada. 6 | 7 | Se encontrar o nome na lista retorne: 8 | ----------------------- 9 | "O nome está na lista." 10 | ----------------------- 11 | 12 | Caso o contrário: 13 | --------------------------- 14 | "O nome não está na lista." 15 | --------------------------- 16 | 17 | */ 18 | 19 | function findGuest(names, guest){ 20 | // Desenvolva seu código nessa função 21 | return // Retorne o resultado aqui 22 | } 23 | 24 | module.exports = findGuest; 25 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-07.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 07 - Maior ou menor de idade 4 | 5 | Escreva um algoritmo que verifica se a pessoa é maior ou menor de idade. 6 | 7 | Caso a pessoa for maior idade retorna: 8 | ----------------------------- 9 | "A pessoa é maior de idade.". 10 | ----------------------------- 11 | 12 | Caso contrário: 13 | ----------------------------- 14 | "A pessoa é menor de idade." 15 | ----------------------------- 16 | 17 | Bônus: Crie a condição utilizando O Operador Ternário. 18 | 19 | */ 20 | 21 | function legalAge(age){ 22 | // Desenvolva seu código nessa função 23 | } 24 | 25 | module.exports = legalAge; 26 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Quatro operações matemáticas 4 | 5 | Escreva um algoritmo que recebe dois números inteiros, executa as quatro operação matemáticas básicas nestes números (soma, subtração, multiplicação e divisão) e retorne uma string no seguinte formato. 6 | 7 | Por exemplo: 8 | ------------------------------------------------ 9 | Entradas: 10 | 1, 2 11 | 12 | Saída: 13 | "1 + 2 = 3. 1 - 2 = -1. 1 x 2 = 2. 1 / 2 = 0.5." 14 | ------------------------------------------------ 15 | 16 | */ 17 | 18 | function mathOperations(number1, number2) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = mathOperations; 23 | -------------------------------------------------------------------------------- /Desafios/Objetos/desafio-objetos-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Quem é a pessoa mais velha? 4 | 5 | Dado um array de pessoas, escreva um algoritmo que identifique qual tem a maior idade e retorne o nome da pessoa e sua idade. 6 | 7 | O array terá o seguinte formato: 8 | people = [ 9 | { name: 'Ramon', age: 35 }, 10 | { name: 'José', age: 28 }, 11 | { name: 'Amanda', age: 19 } 12 | ]; 13 | 14 | O retorno deve ser no seguinte formato: 15 | --------------------------------- 16 | "x tem a maior idade com y anos." 17 | --------------------------------- 18 | 19 | */ 20 | 21 | function getOldPerson(arrPeople) { 22 | // Desenvolva seu código nessa função 23 | } 24 | 25 | module.exports = getOldPerson; 26 | -------------------------------------------------------------------------------- /Desafios/Objetos/desafio-objetos-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Escala musical 4 | 5 | Dada a escala maior natural de Dó, cada uma das 7 notas possui um grau, representado por um algarismo romano: 6 | 7 | | Dó | Ré | Mi | Fá | Sol | Lá | Si | 8 | | I | II | III | IV | V | VI | VII | 9 | 10 | Escreva um algoritmo que recebe uma nota e retorne o grau dessa nota na escala de Dó. 11 | 12 | Por exemplo: 13 | --------------- 14 | Entrada: 15 | "Dó" 16 | 17 | Saída: 18 | "I" 19 | --------------- 20 | 21 | Desafio: faça sem usar estruturas condicionais (ifs ou switches). 22 | 23 | */ 24 | 25 | function musicalScale(note) { 26 | // Desenvolva seu código nessa função 27 | } 28 | 29 | module.exports = musicalScale; 30 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Calcular o salário 4 | 5 | Na sapataria do Faraó todas as pessoas da área de vendas recebem um salário fixo acrescido de 4% de comissão sobre as vendas. 6 | 7 | Escreva um algoritmo que receba o salário fixo de vendedores da sapataria do Faraó 8 | e o valor de suas vendas, calcule e retorne a comissão e seu salário final no formato: 9 | 10 | --------------------------------------- 11 | "A comissão é: x e o ganho total é: y". 12 | --------------------------------------- 13 | 14 | */ 15 | 16 | function totalReceive(salary, sales){ 17 | // Desenvolva seu código nessa função 18 | } 19 | 20 | module.exports = totalReceive; 21 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-07.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 07 - Calcule o tempo de leitura 4 | 5 | Ana começou a ler o livro "O guia do mochileiro das galáxias", que tem 208 páginas. 6 | Após 2 minutos ela tinha lido 4 páginas. 7 | 8 | Escreva um algoritmo que calcula e retorne o tempo em minutos que Ana levará para ler todo o livro no total no seguinte formato: 9 | 10 | --------------------------------------------- 11 | "Ana levará x minutos para ler o livro todo." 12 | --------------------------------------------- 13 | 14 | */ 15 | 16 | function readingTime(totalPages, readPages, minutes){ 17 | // Desenvolva seu código nessa função 18 | } 19 | 20 | module.exports = readingTime; 21 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-06.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 06 - Nome do cachorro 4 | 5 | Joana adotou um cachorrinho e decidiu usar o nome de suas comidas favoritas para dar nome 6 | a ele, ela vai usar as 3 primeiras letras do seu salgadinho favorito e juntar com as 3 ultimas 7 | letras do seu doce favorito. 8 | 9 | Escreva um algoritmo que recebe o nome do salgadinho e o nome do doce e retorne o nome do cachorrinho de Joana. 10 | 11 | Por exemplo: 12 | -------------------- 13 | Entradas: 14 | "Chocolate", "Pudim" 15 | 16 | Saída: 17 | "Chodim" 18 | -------------------- 19 | 20 | */ 21 | 22 | function dogName(snack, sweet) { 23 | // Desenvolva seu código nessa função 24 | } 25 | 26 | module.exports = dogName; 27 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Números divisíveis por 3 4 | 5 | Escreva um algoritmo que recebe o inicio e o fim de uma sequência de números inteiros de razão 1. 6 | 7 | Conte a quantidade de números da sequência que são diviseis por 3 e considere: 8 | 9 | Se houver 50 ou mais retorne: 10 | --------------------------------------- 11 | "Há 50 ou mais números diviseis por 3." 12 | 13 | Caso o contrário: 14 | -------------------------- 15 | "Sequência muito pequena." 16 | -------------------------- 17 | 18 | */ 19 | 20 | function numbersDivisibleBy3(start, limit){ 21 | // Desenvolva seu código nessa função 22 | } 23 | 24 | module.exports = numbersDivisibleBy3; 25 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-08.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 08 - Conta do restaurante 4 | 5 | Escreva um algoritmo que recebe o valor de um prato, calcule e retorne o valor final dele acrescendo 10% de taxa por ser uma área turística e mais 5% de gorjeta para o garçon. 6 | 7 | Obs: Retornar um valor do tipo number com duas casa decimais. 8 | Obs2: Dependendo do método usado para arredondar o tipo da sua variável, o valor retornado pode mudar, e aqui o retorno DEVE ser do tipo NUMBER. Talvez seja preciso converter para number ao final. 9 | 10 | */ 11 | 12 | function restaurantExpenses(account){ 13 | // Desenvolva seu código nessa função 14 | } 15 | 16 | module.exports = restaurantExpenses; 17 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-020.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 20 - Aprovado ou reprovado? 4 | 5 | Escreva um algoritmo que recebe 3 notas com valores de 0 a 10 e calcule a media arredondada. 6 | 7 | Considere a seguintes premissas: 8 | * “Aprovação” caso a média seja igual ou superior a 6; 9 | * “Reprovação” caso a média das notas seja inferior a 6. 10 | 11 | Retorne uma mensagem no seguinte formato: 12 | ---------------------------------------------- 13 | 'Aprovação, média: 7' ou 'Reprovação, média: 5' 14 | ---------------------------------------------- 15 | 16 | */ 17 | 18 | function avaliador(score1, score2, score3) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = avaliador; 23 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-015.js: -------------------------------------------------------------------------------- 1 | /* Não entendi o que é para fazer no 15 */ 2 | 3 | // 15 - Fatorial e média 4 | 5 | /* 6 | 7 | Faça uma função que calcule o fatorial de um número recebido por parâmetro e em seguida, utilize-a para fazer a função que calcula a média dos fatoriais de A a B, 8 | sendo A e B números inteiros maiores ou iguais a 0. 9 | A média deve ter até 2 casas decimais de precisão. 10 | */ 11 | 12 | function factorial15(number) { 13 | // Desenvolva aqui a lógica para calcular o fatorial 14 | } 15 | 16 | function meanFactorialFromAToB(a, b) { 17 | // Desenvolva aqui a lógica para calcular a média dos fatoriais de 0 a 5 18 | } 19 | 20 | module.exports = { 21 | factorial15, 22 | meanFactorialFromAToB, 23 | }; 24 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-011.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 11 - Loja de ração 4 | 5 | Escreva uma algoritmo para uma loja de ração que recebe o preço de um produto e retorna as formas de pagamentos disponíveis. 6 | 7 | Considere as seguintes premissas: 8 | * À vista possui 10% de desconto e parcelado em 4x possui juros de 15%. 9 | 10 | Exemplo: 11 | ------------------------------- 12 | Entrada: 13 | 80 14 | 15 | Saída: 16 | "À Vista: R$72,00 ou 4x de: R$23,00" 17 | ------------------------------- 18 | 19 | Obs: seguir o mesmo formato de retorno da mensagem de saída. 20 | 21 | */ 22 | 23 | function paymentOptions(price) { 24 | // Desenvolva seu código nessa função 25 | } 26 | 27 | module.exports = paymentOptions; 28 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-07.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 07 - Calcule a média dos graus Celsius em Fahrenheit 4 | 5 | Escreva uma algoritmo que recebe uma lista com a média de temperatura em Fahrenheit registradas nos últimos 12 meses e retorne uma mensagem informando a médica em Celsius no formato da saída. 6 | 7 | Poor exemplo: 8 | ------------------------------------------------------- 9 | Entrada: 10 | [98, 95, 92, 88, 74, 106, 114, 90, 76, 65, 55, 80] 11 | 12 | Saída: 13 | "A média anual de temperatura em graus Celsius é 30.05." 14 | -------------------------------------------------------- 15 | 16 | */ 17 | 18 | function averageTemperature(anualRegister){ 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = averageTemperature; 23 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-012.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 12 - Peso e preço do prato 4 | 5 | Um restaurante comprou uma balança nova e precisa adicionar um programa que calcula o valor que a pessoa vai pagar pelo prato de comida. 6 | 7 | Escreva um algoritmo que recebe o valor por kilo e o peso do prato e 8 | calcule o valor da refeição, retornando uma mensagem no seguinte formato: 9 | 10 | ------------------------------------ 11 | "O prato de x gramas custa: R$x,yz" 12 | ------------------------------------ 13 | 14 | Obs: O valor do prato tem que ter duas casas decimais após a virgula. 15 | 16 | */ 17 | 18 | function weightAndValue(priceKg, plateWeight) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = weightAndValue; 23 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-021.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 21 - Média ponderada 4 | 5 | Escreva um algoritmo que recebe 3 notas com valores de 0 a 10 e calcule a media ponderada com pesos 3, 3 e 4 respectivamente. 6 | 7 | Considere a seguintes premissas: 8 | * “Aprovação” caso a média seja igual ou superior a 6; 9 | * “Reprovação” caso a média das notas seja inferior a 6. 10 | 11 | Retorne uma mensagem no seguinte formato: 12 | --------------------------------------------------- 13 | 'Aprovação, média: 7.7' ou 'Reprovação, média: 5.9' 14 | --------------------------------------------------- 15 | 16 | */ 17 | 18 | function weightedAverage(score1, score2, score3) { 19 | // Desenvolva seu código nessa função 20 | } 21 | 22 | module.exports = weightedAverage; 23 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/desafio-estrutura-repeticoes-09.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 09 - Incluído nos arrays 4 | 5 | Escreva um algoritmo que irá receber dois array a e b, retorne um novo array com os elementos que se repetem em a e b, se não houver elemento repetidos, retorne um array vazio. 6 | 7 | Por exemplo: 8 | -------------------------------------------------------------------------------- 9 | Entradas: 10 | a = [1, 2, 3 ], b = [4, 2, 4 ] 11 | 12 | Saída: 13 | [2] 14 | -------------------------------------------------------------------------------- 15 | 16 | Obs: Não utilize o includes, você deve encontrar os valores utilizando 2 for's. 17 | 18 | */ 19 | 20 | function includesArrays(a, b){ 21 | // Desenvolva seu código nessa função 22 | } 23 | 24 | module.exports = includesArrays; 25 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Array de notas musicais 4 | 5 | Uma música normalmente possui uma sequência de notas. 6 | 7 | Data a escala natural de Dó, cada uma das 7 notas possui um grau representado por um algarismo romano conforme abaixo: 8 | 9 | | Dó | Ré | Mi | Fá | Sol | Lá | Si | 10 | | I | II | III | IV | V | VI | VII | 11 | 12 | Escreva um algoritmo que recebe um array de notas e retorne um outro array com os respectivos graus da escala de Dó. 13 | 14 | Por exemplo: 15 | ---------------------------- 16 | Entrada: 17 | ['Ré', 'Sol', 'Dó'] 18 | 19 | Saída: 20 | ['II', 'V', 'I'] 21 | ---------------------------- 22 | 23 | */ 24 | 25 | function musicalNotes(notes) { 26 | // Desenvolva seu código nessa função 27 | } 28 | 29 | module.exports = musicalNotes; 30 | -------------------------------------------------------------------------------- /Desafios/Arrays/desafio-arrays-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Encontre o filho mais velho 4 | 5 | Dada a idade de Pedro e um array com as idades de três de seus filhos, escreva um algoritmo 6 | que irá receber esses dados para computar e retornar a idade do filho mais velho de Pedro. 7 | 8 | Considere as premissas abaixo: 9 | * Pedro é pai de 4 filhos que têm idades diferentes; 10 | * Esse ano ele notou que a soma da idade de seus filhos é igual à idade dele. 11 | 12 | A saída deve ter o seguinte formato: 13 | -------------------------------- 14 | "O filho mais velho tem x anos." 15 | -------------------------------- 16 | 17 | */ 18 | 19 | function findOldestSon(pedroAge, kidsAge){ 20 | // Desenvolva seu código aqui. 21 | return // Retorne o resultado aqui 22 | } 23 | 24 | module.exports = findOldestSon; 25 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Verifica se pessoa tem idade para dar entrada na CNH 4 | 5 | Escreva um algoritmo que recebe o nome e ano de nascimento de uma pessoa e verifique se ela pode dar entrada na CNH. 6 | 7 | Se a pessoa tiver menos de 18 anos retorne: 8 | ------------------------------------------------------ 9 | "x tem y anos de idade e não pode iniciar o processo." 10 | ------------------------------------------------------ 11 | 12 | Caso contrário: 13 | -------------------------------------------------- 14 | "x tem y anos de idade e pode iniciar o processo." 15 | -------------------------------------------------- 16 | 17 | */ 18 | 19 | function cnhProcess(name, birthYear){ 20 | // Desenvolva seu código nessa função 21 | } 22 | 23 | module.exports = cnhProcess; 24 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-015.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 15 - Área de uma circunferência 4 | 5 | Sabemos que a área de uma circunferência é calculada da seguinte forma: π * r ^ 2 (PI vezes R ao quadrado). 6 | 7 | Também sabemos que o raio (r) é a metade do diâmetro. 8 | 9 | Escreva um algoritmo que calcula a área de uma circunferência com **diâmetro** de 10cm e a retorne. 10 | 11 | Obs1: Exiba o resultado no seguinte formato 'A circunferência de raio R cm possui uma área de A cm quadrados', onde R é o valor do raio da circunferência e A é o valor da área da circunferência. 12 | 13 | Obs2: Exiba a área com apenas duas casas decimais. 14 | 15 | */ 16 | 17 | function areaCircle(diameter) { 18 | // Desenvolva seu código nessa função 19 | } 20 | 21 | module.exports = areaCircle; 22 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "revisao-trybe", 3 | "version": "1.0.0", 4 | "description": "Este repositório tem por finalidade apresentar alguns exercícios de logica de programação e alguns materiais de estudo complementares sobre os temas que são abordados nos exercícios.", 5 | "main": "index.js", 6 | "scripts": { 7 | "test": "jest" }, 8 | "repository": { 9 | "type": "git", 10 | "url": "git+https://github.com/tryber/exercises-programming-logic-challenges.git" 11 | }, 12 | "author": "", 13 | "license": "ISC", 14 | "bugs": { 15 | "url": "https://github.com/tryber/exercises-programming-logic-challenges/issues" 16 | }, 17 | "homepage": "https://github.com/tryber/exercises-programming-logic-challenges#readme", 18 | "dependencies": { 19 | "jest": "^27.1.1" 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Desafios/Strings/Gabaritos/10.js: -------------------------------------------------------------------------------- 1 | function telephoneFormat(string) { 2 | //se não for válido retorna a própria variável 3 | if (!string) return string; 4 | //converte para string 5 | if (typeof string === "number") string = string.toString(); 6 | //remove tudo que não for número 7 | string = string.replace(/[^0-9]/g, ""); 8 | if (string.length < 10 || string.length > 11){ 9 | //se tiver menos largura que 10 ou mais de 11, é inválido 10 | return string; 11 | } 12 | const regex = /^([0-9]{2})([0-9]?)([0-9]{4})([0-9]{4})$/gm; 13 | const subst = `($1) $2 $3-$4`; 14 | //aplica o regex de formatação e remove espaços duplicados causados 15 | //pela possível ausência do dígito 9 antes do número 16 | return string.replace(regex, subst).replace(' ',' '); 17 | } 18 | 19 | module.exports = telephoneFormat; 20 | -------------------------------------------------------------------------------- /Desafios/Strings/index.js: -------------------------------------------------------------------------------- 1 | const reverseNames = require("./desafio-strings-01") 2 | const converteType = require("./desafio-strings-02") 3 | const personalPresentation = require("./desafio-strings-03") 4 | const mathOperations = require("./desafio-strings-04") 5 | const firstLastLetter = require("./desafio-strings-05") 6 | const dogName = require("./desafio-strings-06") 7 | const includeA = require("./desafio-strings-07") 8 | const countLetters = require("./desafio-strings-08") 9 | const encodeMessage = require("./desafio-strings-09") 10 | const telephoneFormat = require("./desafio-strings-10") 11 | 12 | module.exports = { 13 | reverseNames, 14 | converteType, 15 | personalPresentation, 16 | mathOperations, 17 | firstLastLetter, 18 | dogName, 19 | includeA, 20 | countLetters, 21 | encodeMessage, 22 | telephoneFormat, 23 | } 24 | -------------------------------------------------------------------------------- /Desafios/Objetos/desafio-objetos-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Jogo de fantasia 4 | 5 | Você é responsável pelo sistema de um novo jogo de fantasia medieval. 6 | 7 | Escreva um algoritmo que recebe o nome da classe e retorne os pontos de vida do(a) personagem, com base na tabela a seguir: 8 | 9 | | Classe | Pontos de Vida | 10 | 11 | | Mago | 5PV | 12 | | Arqueiro | 10PV | 13 | | Guerreiro | 15PV | 14 | | Cavaleiro | 20PV | 15 | 16 | Por exemplo: 17 | ------------ 18 | Entrada: 19 | "Mago"' 20 | 21 | Saída: 22 | "Mago, 5PV" 23 | ------------ 24 | 25 | Desafio: faça sem usar estruturas condicionais (ifs ou switches) 26 | 27 | */ 28 | 29 | function fantasyGame(className) { 30 | // Desenvolva seu código nessa função 31 | } 32 | 33 | module.exports = fantasyGame; 34 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-08.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 08 - O número de empates na Copa das galáxias 4 | 5 | Uma Copa de futebol de botão está sendo realizada com equipes de toda a galáxia. 6 | 7 | A classificação dessa Copa é baseada no número de pontos ganhos pelas equipes, e a distribuição de pontos é feita da forma usual, por exemplo: 8 | 9 | * quando uma equipe ganha um jogo, ela recebe 3 pontos; 10 | * se o jogo termina empatado, ambas as equipes recebem 1 ponto; 11 | * a equipe perdedora não recebe nenhum ponto. 12 | 13 | Escreva um algoritmo que recebe a quantidade de partidas jogadas e um objeto no qual as chaves são os nomes dos times e os valores a pontuação alcançada por cada um e retorne a quantidade de partidas empatadas. 14 | 15 | */ 16 | 17 | function numberTies(matches, scores){ 18 | // Desenvolva seu código nessa função 19 | } 20 | 21 | module.exports = numberTies; 22 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/index.js: -------------------------------------------------------------------------------- 1 | const encode = require('./desafio-estrutura-repeticoes-01'); 2 | const accumulator = require('./desafio-estrutura-repeticoes-02'); 3 | const accumulatorThousand = require('./desafio-estrutura-repeticoes-03'); 4 | const repeatName = require('./desafio-estrutura-repeticoes-04'); 5 | const numbersDivisibleBy3 = require('./desafio-estrutura-repeticoes-05'); 6 | const oddNumbers = require('./desafio-estrutura-repeticoes-06'); 7 | const findIndexOf = require('./desafio-estrutura-repeticoes-07'); 8 | const sortDec = require('./desafio-estrutura-repeticoes-08'); 9 | const includesArrays = require('./desafio-estrutura-repeticoes-09'); 10 | 11 | module.exports ={ 12 | encode, 13 | accumulator, 14 | accumulatorThousand, 15 | repeatName, 16 | numbersDivisibleBy3, 17 | oddNumbers, 18 | findIndexOf, 19 | sortDec, 20 | includesArrays, 21 | } 22 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-022.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 22 - Jogo do arremesso de peso 4 | 5 | Você será responsável por desenvolver uma funcionalidade para calcular a pontuação de um jogo de arremesso de peso. 6 | 7 | Considere as regras de pontuação listadas abaixo: 8 | * A cada 1 metro de distância arremessado a pessoa jogadora recebe 1 ponto; 9 | * A cada 5 metros de distância arremessado a pessoa jogadora recebe 2 pontos extras. 10 | 11 | A partir da distância recebida por parâmetro, 12 | calcule a pontuação final da pessoa jogadora e a retorne no formato: 13 | 14 | ----------------------------------------- 15 | "A pontuação da pessoa jogadora foi de x" 16 | ----------------------------------------- 17 | 18 | */ 19 | 20 | function calculateScore(distance) { 21 | // Desenvolva seu código nessa função 22 | } 23 | 24 | module.exports = calculateScore; 25 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-01.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 01 - Lanchonete da Trybe 4 | 5 | A Trybe abriu uma lanchonete e precisa criar um menu de opções para que as pessoas consigam escolher qual lanche maravilhoso irão pedir. 6 | 7 | Para isso escreva um algoritmo que recebe o número da opção escolhida conforme tabela abaixo e retorne a string inteira do respectivo lanche: 8 | 9 | "1 - Trybe Lanche Feliz" 10 | "2 - McTrybe" 11 | "3 - TrybeWooper" 12 | "4 - X-Trybe" 13 | "5 - Triplo Trybe com JS" 14 | 15 | Caso a pessoa escolha uma opção que não existe na tabela acima, retorne: 16 | ------------------------------- 17 | "Não temos esta opção ainda :(" 18 | ------------------------------- 19 | 20 | Utilize Switch/Case para resolver este problema. 21 | 22 | */ 23 | 24 | function optionsMenu(number){ 25 | // Desenvolva seu código nessa função 26 | } 27 | 28 | module.exports = optionsMenu; 29 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Calcula a raiz quadrada de um número 4 | 5 | Escreva um algoritmo que recebe um número inteiro e calcule a sua raiz quadrada e considere os seguintes retornos: 6 | 7 | Se a raiz for exata, ou seja, um quadrado perfeito, por exemplo a raiz quadrada de 25 é 5, retorne: 8 | ----------------------------- 9 | "A raiz quadrada de 25 é: 5." 10 | ----------------------------- 11 | 12 | Se a raiz não for exata, por exemplo a raiz de 30, retorne: 13 | ------------------------------------------ 14 | "Não existe raiz exata para o número 30.". 15 | ------------------------------------------ 16 | 17 | Se o valor recebido for igual a zero ou não for do tipo number, retorne: 18 | ------------------- 19 | "Número inválido.". 20 | ------------------- 21 | 22 | */ 23 | 24 | function squareRoot(number){ 25 | // Desenvolva seu código nessa função 26 | } 27 | 28 | module.exports = squareRoot; 29 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-019.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 19 - Viagem de carro 4 | 5 | Você está planejando uma viagem até a praia com colegas. 6 | Uma das tarefas para a viagem acontecer é calcular quantos dias ela irá levar. 7 | 8 | Você está em São Paulo, o João está em Belo Horizonte e a Joana está em Salvador. 9 | 10 | Levando em conta que o destino do grupo é Natal, no Rio Grande do Norte, escreva um algoritmo que calcula a duração de dias de uma viagem levando em conta a quantidade total de horas e os retorne. 11 | 12 | O total de dias deve ter precisão de até 3 casas decimais. 13 | 14 | Informações: 15 | * São Paulo até Belo Horizonte = 7 horas e 23 minutos; 16 | * Belo Horizonte até Salvador = 19 horas e 57 minutos; 17 | * Salvador até Natal = 15 horas e 32 minutos. 18 | 19 | */ 20 | 21 | function carTrip(spBh, bhSal, salNat) { 22 | // Desenvolva seu código nessa função 23 | } 24 | 25 | module.exports = carTrip; 26 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-013.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 13 - Pontos no Xadrez 4 | 5 | Você está desenvolvendo o sistema de pontuação de um site de partidas de xadrez. 6 | Ele deve funcionar com base na diferença entre a pontuação das duas pessoas que jogam. 7 | 8 | Diferença | Ganhador(a) | Perdedor(a) 9 | > 200 +10 -10 10 | <= 200 +20 -20 11 | 12 | Escreva um algoritmo que recebe: 13 | * A pontuação das pessoas que jogam (antes da partida): número maior que zero; 14 | * A pessoa vencedora: 1 ou 2. 15 | 16 | E retorne uma mensagem com pontuação de cada enxadrista após a partida no seguinte formato: 17 | ----------------------------------------------------- 18 | "Enxadrista1: 1500 pontos. Enxadrista2: 1600 pontos." 19 | ----------------------------------------------------- 20 | 21 | */ 22 | 23 | function chessRating(ratingPlayOne,ratingPlayTwo){ 24 | // Desenvolva seu código nessa função 25 | } 26 | 27 | module.exports = chessRating; 28 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-06.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 06 - Taxa Metabólica Basal 4 | 5 | Renata é uma nutricionista e quer disponibilizar uma calculadora de BMR (Taxa Metabólica Basal) em seu site. 6 | 7 | Escreva um algoritmo que recebe os dados a seguir: 8 | * age: número maior que 0 9 | * sex: M ou F 10 | * weight: Em (kg) com número maior que 0 11 | * height: Em (cm) com número maior que 0 12 | 13 | Fórmula para homens: 14 | * (altura em centímetros x 6,25) + (peso em quilogramas x 9,99) – (idade x 4,92) + 5 15 | 16 | Fórmula para mulheres: 17 | * (altura em centímetros x 6,25) + (peso em quilogramas x 9,99) – (idade x 4,92) – 161 18 | 19 | O retorno deve ser no seguinte formato: 20 | --------------------------------------- 21 | "A taxa metabólica basal é: x Kcal" 22 | --------------------------------------- 23 | 24 | */ 25 | 26 | function basalMetabolicRate(age, sex, weight, height){ 27 | // Desenvolva seu código nessa função 28 | } 29 | 30 | module.exports = basalMetabolicRate; 31 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/desafio-operadores-aritmeticos-017.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 17 - Financiamento de veículo 4 | 5 | Escreva um algoritmo para gerenciar as contas de um financiamento de veículo. 6 | 7 | A pessoa que quer fazer o financiamento precisa informar: 8 | 9 | * o valor total do carro; 10 | * o valor da entrada a ser dada; 11 | * quantidade de parcelas que ela deseja pagar. 12 | 13 | A loja em questão usa uma taxa de juros fixa de 5% sobre o valor do financiamento. 14 | 15 | Desenvolva a solução e retorne conforme o exemplo (os valores monetários precisam ter 2 casas decimais após a virgula): 16 | 17 | -------------------------------- 18 | Valor Financiado: R$35000,00; 19 | Valor do Juros: R$1750,00; 20 | Quantidade de Parcelas: 36; 21 | Valor da Parcela: R$1020,83; 22 | Valor Total do Carro: R$46750,00. 23 | -------------------------------- 24 | 25 | */ 26 | 27 | function carFinancing(carPrice, entranceValue, quota) { 28 | // Desenvolva seu código nessa função 29 | } 30 | 31 | module.exports = carFinancing; 32 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-017.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 17 - Jogo do par ou ímpar 4 | 5 | Lúcio e Ana estão brincando de PAR ou ÍMPAR. 6 | 7 | O algoritmo irá receber os seguinte parâmetros: 8 | * lucioFingers = número de dedos que Lúcio mostrou; 9 | * anaFingers = número de dedos que Ana mostrou; 10 | * even = identificador de quem gritou PAR sendo: 1 para Lucio e 0 para Ana. 11 | 12 | Tendo a informação de quem gritou par e o número de dedos estendidos de cada pessoa. 13 | 14 | Exemplo: 15 | lucioFingers = 3, 16 | anaFingers = 2, 17 | even = 1 18 | 19 | Então: 20 | 3 + 2 = 5 (Ímpar) 21 | No caso acima, Ana venceu. 22 | 23 | Em caso de vitória de Ana retorne a mensagem no seguinte formato: 24 | ------------ 25 | "Ana venceu" 26 | ------------ 27 | 28 | Caso o contrário retorne: 29 | -------------- 30 | "Lúcio venceu" 31 | -------------- 32 | 33 | */ 34 | 35 | 36 | function oddOreEven(lucioFingers, anaFingers, even){ 37 | // Desenvolva seu código nessa função 38 | } 39 | 40 | module.exports = oddOreEven; 41 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/Gabaritos/21-23.js: -------------------------------------------------------------------------------- 1 | /* 21 - Média ponderada */ 2 | function weightedAverage(score1, score2, score3) { 3 | let averageScore = parseFloat((score1 * 0.3 + score2 * 0.3 + score3 * 0.4).toFixed(2)); 4 | 5 | if (averageScore >= 6) { 6 | return "Aprovação, média: " + averageScore; 7 | } else { 8 | return "Reprovação, média: " + averageScore; 9 | } 10 | } 11 | 12 | /* 22 - Jogo do arremesso de peso */ 13 | function calculateScore(distance) { 14 | let addScore = Math.trunc((distance / 5)) * 2; 15 | let totalScore = Math.trunc(distance + addScore); 16 | 17 | return `A pontuação da pessoa jogadora foi de ${totalScore}`; 18 | } 19 | 20 | /* 23 - Divisões sucessivas */ 21 | function successiveDivisions(number) { 22 | let count; 23 | for (count = 0; number >= 1; count = count + 1) { 24 | number = number / 2; 25 | } 26 | return "Quantidade total de divisões: " + count; 27 | } 28 | 29 | module.exports = { 30 | weightedAverage, 31 | calculateScore, 32 | successiveDivisions, 33 | } 34 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-03.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 03 - Mostre a classe do aventureiro 4 | 5 | A Trybe tem um grupo de aventureiros. 6 | 7 | Quando o nome de algum é invocado, a classe a qual essa pessoa faz parte é apresentada. 8 | 9 | Escreva um algoritmo que recebe o nome de um aventureiro e, de acordo com este nome, retorna o nome da sua classe conforme tabela baixo: 10 | 11 | | Aventureiro | Classe | 12 | 13 | | Tunico | Mestre dos Magos | 14 | | Cremoso | Cavaleiro Negro | 15 | | Gordinho | Pirata | 16 | | Lobo | Solitário Samurai | 17 | | Ousado | Mago | 18 | | Anjo | Loiro Clérigo | 19 | 20 | Caso o nome informado não faça parte do esquadrão, retorne: 21 | ---------------------------- 22 | "Aventureiro não encontrado" 23 | ---------------------------- 24 | 25 | */ 26 | 27 | function findAdventurous(adventurous){ 28 | // Desenvolva seu código nessa função 29 | } 30 | 31 | module.exports = findAdventurous; 32 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Robô amigo 4 | 5 | Você está programando um robô que ajuda nas tarefas de casa, e seus comportamentos deverão ser escritos em JavaScript. 6 | 7 | Escreva um algoritmo que recebe 5 booleanos: 8 | * mom 9 | * dad 10 | * me 11 | * brother 12 | * sister 13 | 14 | Eles devem representar se a pessoa pediu para que o robô executasse uma tarefa. 15 | 16 | Caso me (você), mom (mãe) ou dad (pai) pedirem, o robô deverá executar sem pensar duas vezes. 17 | 18 | Por outro lado, quando seu irmão ou irmã pedirem algo, o robô só deverá executar se ambos pedirem em conjunto. 19 | 20 | Caso o Robô for executar a tarefa retorne: 21 | ------------------------- 22 | "Things I do for love..." 23 | ------------------------- 24 | 25 | Caso contrário retorne: 26 | ----------------------- 27 | "Not today." 28 | ----------------------- 29 | 30 | */ 31 | 32 | function robotFriend(mon, dad, me, brother, sister){ 33 | // Desenvolva seu código nessa função 34 | } 35 | 36 | module.exports = robotFriend; 37 | -------------------------------------------------------------------------------- /Desafios/Objetos/desafio-objetos-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Jogo de fantasia- Parte 2 4 | 5 | Além dos pontos de vida (PV), será necessário estipular o equipamento inicial do(a) personagem. 6 | 7 | Tudo isso deve ser feito no mesmo código, seguindo a seguinte tabela: 8 | 9 | | Classe | Pontos de Vida | Equipamento Inicial | 10 | 11 | | Mago | 5PV | Varinha | 12 | | Arqueiro | 10PV | Arco Curto | 13 | | Guerreiro | 15PV | Espada | 14 | | Cavaleiro | 20PV | Armadura Completa | 15 | 16 | 17 | Escreva um algoritmo que recebe o nome de uma classe e retorne os pontos de vida e o equipamento inicial do(a) personagem. 18 | 19 | Por exemplo: 20 | --------------- 21 | Entrada: 22 | "Guerreiro" 23 | 24 | Saída: 25 | "15PV, Espada." 26 | --------------- 27 | 28 | Desafio: faça sem usar estruturas condicionais (ifs ou switches). 29 | 30 | */ 31 | 32 | function fantasyGame2(className) { 33 | // Desenvolva seu código nessa função 34 | } 35 | 36 | module.exports = fantasyGame2; 37 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-10.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 10 - Telefone desconfigurado 4 | 5 | Um banco de dados possui uma série de números de telefone, mas cada um com um padrão diferente. 6 | Alguns têm espaço, outros não, alguns sem traço, outros não, alguns com parênteses, outros não, 7 | e toda sorte de combinações possíveis e imagináveis. 8 | 9 | Crie uma função que receba um número de telefone desconfigurado 10 | e retorne o número de telefone formatado, com suporte ao dígito 9 11 | de prefixo nos celulares, mas funcionando normalmente sem esse prefixo. 12 | 13 | O que será avaliado? 14 | - Ao enviar como parâmetro 11 97878-7878 a função deve retornar (11) 9 7878-7878; 15 | - Se o parâmetro for (11)78787878 a função deve retornar (11) 7878-7878; 16 | - Se o parâmetro for 1178787878 a função deve retornar (11) 7878-7878; 17 | - E se não for um número de telefone válido a função deve retornar o parâmetro; logo: 18 | - Se o parâmetro for 234 a função deve retornar 237; 19 | 20 | */ 21 | 22 | function telephoneFormat(string) { 23 | // Desenvolva seu código nessa função 24 | } 25 | 26 | module.exports = telephoneFormat; 27 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-02.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 02 - Switch Case 4 | 5 | Refatore a função abaixo para utilizar if/else. 6 | 7 | NOTAS 8 | abaixo de 10: PÉSSIMO 9 | entre 11 e 30: RUIM 10 | entre 31 e 50: REGULAR 11 | entre 51 e 70: MEDIANO 12 | entre 71 e 90: ÓTIMO 13 | acima de 91: EXCELENTE 14 | 15 | function studentSituation(studentNote) { 16 | let status = ''; 17 | 18 | switch (true) { 19 | case (studentNote <= 10): 20 | status = 'PÉSSIMO'; 21 | break; 22 | case (studentNote >= 11 && studentNote <= 30): 23 | status = 'RUIM'; 24 | break; 25 | case (studentNote >= 31 && studentNote <= 50): 26 | status = 'REGULAR'; 27 | break; 28 | case (studentNote >= 51 && studentNote <= 70): 29 | status = 'MEDIANO'; 30 | break; 31 | case (studentNote >= 71 && studentNote <= 90): 32 | status = 'ÓTIMO'; 33 | break; 34 | default: 35 | status = 'EXCELENTE'; 36 | } 37 | return status; 38 | } 39 | 40 | */ 41 | 42 | function studentSituation(studentNote){ 43 | // Desenvolva seu código nessa função 44 | } 45 | 46 | module.exports = studentSituation; 47 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-06.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 6 - Analise de preços da lista de compras 4 | 5 | Escreva um algoritmo que irá receber um array de produtos e retorne uma string no formato da saída que contem: 6 | 7 | * O produto com maior preço; 8 | * O preço do produto; 9 | * A média do preços dos produtos. 10 | 11 | Por exemplo: 12 | --------------------------------------------------------------------------------------------------- 13 | Entrada: 14 | [ 15 | { name: 'lápis', price: 2 }, 16 | { name: 'borracha', price: 4 }, 17 | { name: 'caneta', price: 5 }, 18 | { name: 'régua', price: 6 }, 19 | { name: 'apontador', price: 3 }, 20 | { name: 'teclado gamer', price: 180 }, 21 | { name: 'mochila', price: 33 }, 22 | { name: 'fone de ouvido', price: 57 }, 23 | { name: 'mousepad', price: 35 }, 24 | ] 25 | 26 | Saída: 27 | "O produto mais caro é teclado gamer e custa: R$ 180, a média de preços dos produtos é de: R$36.11." 28 | ---------------------------------------------------------------------------------------------------- 29 | 30 | */ 31 | 32 | function productAnalysis(products){ // corrigir nome 33 | // Desenvolva seu código nessa função 34 | } 35 | 36 | module.exports = productAnalysis; 37 | 38 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/index.js: -------------------------------------------------------------------------------- 1 | const cnhProcess = require('./desafiador-01'); 2 | const squareRoot = require('./desafiador-02'); 3 | const musicalNotes = require('./desafiador-03'); 4 | const musicalNotes2 = require('./desafiador-04'); 5 | const magicWand = require('./desafiador-05'); 6 | const productAnalysis = require('./desafiador-06'); 7 | const averageTemperature = require('./desafiador-07'); 8 | const numberTies = require('./desafiador-08'); 9 | const viewerTvShows = require('./desafiador-09'); 10 | const negateNumbers = require('./desafiador-010'); 11 | const musicalNotes3 = require('./desafiador-011'); 12 | const factorial = require('./desafiador-012'); 13 | const fibonnaci = require('./desafiador-013'); 14 | const sumPrimesNumbers = require('./desafiador-014'); 15 | const { factorial15, meanFactorialFromAToB } = require('./desafiador-015'); 16 | const cpfValidator = require('./desafiador-016'); 17 | 18 | module.exports = { 19 | cnhProcess, 20 | squareRoot, 21 | musicalNotes, 22 | musicalNotes2, 23 | magicWand, 24 | productAnalysis, 25 | averageTemperature, 26 | numberTies, 27 | viewerTvShows, 28 | negateNumbers, 29 | musicalNotes3, 30 | factorial, 31 | fibonnaci, 32 | sumPrimesNumbers, 33 | factorial15, 34 | meanFactorialFromAToB, 35 | cpfValidator, 36 | }; 37 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-09.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 09 - Programas de TV 4 | 5 | Você foi a pessoa designada para escrever um algoritmo que classifica programas de TV para telespectadores. 6 | 7 | Você irá receber um objeto com 3 atributos: idade (int), país (string), gostaDeEsportes (bool). 8 | 9 | Caso a pessoa goste de Esportes, tem 16 anos ou mais e mora no Brasil, retorne: 10 | ------ 11 | "UFC." 12 | ------ 13 | 14 | Caso ela tenha o mesmo perfil do UFC, porém não gosta de Esportes, retorne: 15 | --------------- 16 | "The Simpsons." 17 | --------------- 18 | 19 | Caso a pessoa tenha menos de 16 anos, more no Chile e não goste de Esportes, retorne: 20 | ----------------------------- 21 | "The Penguins of Madagascar." 22 | ----------------------------- 23 | 24 | Caso a pessoa tenha menos de 16 anos, goste de Esportes e more em um país que não seja o Chile, retorne: 25 | ---------------- 26 | "Sport Fishing." 27 | ---------------- 28 | 29 | Caso a pessoa não se enquadre nessas categorias acima, retorne: 30 | ------------------------------------------------ 31 | "Não foi possível dizer o que ela deve assistir." 32 | ------------------------------------------------ 33 | 34 | */ 35 | 36 | function viewerTvShows(dataViewer){ 37 | // Desenvolva seu código nessa função 38 | } 39 | 40 | module.exports = viewerTvShows; 41 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-012.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 12 - IMC 4 | 5 | A classificação do Índice de Massa Corporal (IMC), pode ajudar a identificar obesidade ou desnutrição em crianças, adolescentes, adultos e idosos. 6 | 7 | O IMC é a relação entre peso e altura e o cálculo é feito de acordo com a fórmula: 8 | * IMC = peso/ (altura x altura) 9 | 10 | Onde o peso é dado em Kg (quilogramas), a altura em m (metros) e o IMC em kg/m2 (quilograma por metro quadrado). 11 | 12 | Depois de obter o resultado, é verificado em que faixa o resultado se encontra, podendo indicar: 13 | * Magreza, quando o resultado é menor que 18,5 kg/m2; 14 | * Normal, quando o resultado está entre 18,5 e 24,9 kg/m2; 15 | * Sobrepeso, quando o resultado está entre 24,9 e 30 kg/m2; 16 | * Obesidade, quando o resultado é maior que 30 kg/m2. 17 | 18 | Escreva um algoritmo para calcular o IMC e retorne a faixa do resultado. 19 | 20 | Obs: 21 | IMC precisa ter 1 casa decimal depois da vírgula; 22 | Retorne a resultado no seguinte formato: 23 | ------------------------------------------------ 24 | "Seu IMC é: 23.7 kg/m2. O resultado foi: Normal" 25 | ------------------------------------------------ 26 | 27 | */ 28 | 29 | function IMC(weight, height){ 30 | // Desenvolva seu código nessa função 31 | } 32 | 33 | module.exports = IMC;3 34 | 35 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Dinossauro poliglota 4 | 5 | Fernando tem um dinossauro muito esperto. 6 | 7 | Quando está com as duas pernas no chão, o dinossauro fala em português. 8 | 9 | Quando levanta a perna esquerda, fala em inglês. 10 | 11 | Por fim, quando levanta a perna direita fala em francês. 12 | 13 | Jackson, amigo de Fernando, ficou fascinado com o animal. 14 | 15 | Em sua emoção perguntou: “E quando ele levanta as duas?”. 16 | Antes que Fernando pudesse responder, o dinossauro gritou: “Ai eu caio, né tio Jack!!”. 17 | 18 | Escreva um algoritmo que recebe uma string por parâmetro, que contém a situação de levantamento das pernas do dinossauro, e retorne o idioma em que ele irá falar. 19 | 20 | Use a tabela abaixo para te auxiliar: 21 | 22 | | Exemplo de entrata | 'Exemplo de saída | 23 | 24 | | esquerda | 'english | 25 | | direita | 'français | 26 | | nenhuma | 'português | 27 | | as duas | 'Ai eu caio, né!! | 28 | 29 | Caso o comando não for reconhecido, retorne: 30 | ---------------------- 31 | "Comando desconhecido" 32 | ---------------------- 33 | 34 | */ 35 | 36 | function polyglotDinosaur(command){ 37 | // Desenvolva seu código nessa função 38 | } 39 | 40 | module.exports = polyglotDinosaur; 41 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-011.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 11 - Array de notas musicais - 3 4 | 5 | Relembrando, dada a escala natural de Dó, cada uma das 7 notas possui um grau representado por um algarismo romano conforme abaixo: 6 | 7 | | Dó | Ré | Mi | Fá | Sol | Lá | Si | 8 | | I | II | III | IV | V | VI | VII | 9 | 10 | Além disso, cada nota forma um acorde chamado tríade. 11 | 12 | A tríade é composta por uma sequência a partir dela com a "primeira" nota, a "terça" e a "quinta". 13 | 14 | Exemplos: 15 | 16 | Tríade de Dó: Dó (a primeira), Mi (a terça), Sol (a quinta). 17 | Tríade de Ré: Ré (a primeira), Fá (a terça), Lá (a quinta). 18 | 19 | Escreva um algoritmo que recebe um array de notas, e retorne um outro array de objetos com os graus das notas na escala de dó e as notas que formam sua tríade. 20 | 21 | Por exemplo: 22 | ------------------------------- 23 | Entrada: 24 | ['Ré', 'Sol', 'Dó'] 25 | 26 | Saída: 27 | [ 28 | { 29 | degree: 'II', 30 | triad: ['Ré', 'Fá', 'Lá'] 31 | }, 32 | { 33 | degree: 'V', 34 | triad: [ 'Sol', 'Si', 'Ré' ] 35 | }, 36 | { 37 | degree: 'I', 38 | triad: ['Dó', 'Mi', 'Sol'] 39 | }, 40 | ] 41 | -------------------------------- 42 | 43 | */ 44 | 45 | function musicalNotes3(arrNotes){ 46 | // Desenvolva seu código nessa função 47 | } 48 | 49 | module.exports = musicalNotes3; 50 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Varinhas mágicas 4 | 5 | Você foi a pessoa designada para escrever um novo sistema para Olivaras, o fabricante de varinhas mágicas. 6 | 7 | Como se sabe, a varinha escolhe o(a) bruxo(a), então você deverá criar um algoritmo que recebe o nome da pessoa aspirante e o nome da varinha a ser testada. 8 | 9 | Considere a seguinte tabela: 10 | 11 | | Bruxo(a) | Varinha | 12 | 13 | | Harry Potter | Azevinho e Pena de Fênix | 14 | | Rony Weasley | Salgueiro e Pelo de Unicórnio | 15 | | Hermione Granger | Videira e Fibra de Dragão | 16 | | Alvo Dumbledore | Salgueiro e Pelo de Testrálio | 17 | | Belatriz Lestrange | Nogueira e Fibra de Dragão | 18 | 19 | Se a varinha escolher a pessoa aspirante de acordo com a tabela, retorne: 20 | ----------------------------- 21 | "Curioso... muito curioso..." 22 | ----------------------------- 23 | 24 | Caso o contrário: 25 | -------------------------------- 26 | "Não, não! Decididamente, não.!" 27 | -------------------------------- 28 | 29 | Desafio: faça usando apenas um único IF acompanhado por um único Else. 30 | 31 | */ 32 | 33 | function magicWand(wizard, wand){ 34 | // Desenvolva seu código nessa função 35 | } 36 | 37 | module.exports = magicWand; 38 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-04.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 04 - Array de notas musicais - 2 4 | 5 | Relembrando que uma música normalmente possui uma sequência de notas. 6 | 7 | Dada a escala Natural de Dó, cada uma das 7 notas possui: 8 | * um grau representando po algarismo romano. 9 | * uma "terça" maior ou menor. 10 | * uma escala própria. 11 | 12 | Considerando a tabela abaixo: 13 | 14 | | Nota | Dó | Ré | Mi | Fá | Sol | Lá | Si | 15 | 16 | | Grau | I | II | III | IV | V | VI | VII | 17 | | Terça | Maior | Menor | Menor | Maior | Maior | Menor | Menor | 18 | | Escala | Jônia | Dórica | Frígia | Lídia | Mixolídia | Eólia | Lócrio | 19 | 20 | Escreva um algoritmo que recebe um array de notas e retorne um outro array de objetos com os respectivos graus, terças e escalas. 21 | 22 | Por exemplo: 23 | ----------------------------- 24 | Entrada: 25 | ['Ré', 'Sol', 'Dó'] 26 | 27 | Saída: 28 | [ 29 | { 30 | degree: 'II', 31 | third: 'Menor', 32 | scale: 'Dórica', 33 | }, 34 | { 35 | degree: 'V', 36 | third: 'Maior', 37 | scale: 'Mixolídia' 38 | }, 39 | { 40 | degree: 'I', 41 | third: 'Maior', 42 | scale: 'Jônia' 43 | } 44 | ] 45 | ----------------------------- 46 | 47 | */ 48 | function musicalNotes2(notes){ 49 | // Desenvolva seu código nessa função 50 | } 51 | 52 | module.exports = musicalNotes2; 53 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-014.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 14 - Caixa eletrônico 4 | 5 | Um grande banco lhe contratou para fazer um programa para gerenciar um caixa eletrônico. 6 | As máquinas deste banco só possuem notas de R$10, R$50 e R$100. 7 | 8 | Para fazer este programa funcionar você deve coletar o saldo da pessoa e qual o valor do saque que ela quer fazer. 9 | 10 | Se o valor passado no saque for zero ou não for um número, retorne a mensagem: 11 | ------------------------ 12 | Valor de saque inválido" 13 | ------------------------ 14 | 15 | Se o saque for maior que o saldo, retorne a mensagem: 16 | -------------------- 17 | "Saldo insuficiente" 18 | -------------------- 19 | 20 | É preciso levar em consideração o valor do saque com as possibilidades de notas do caixa eletrônico. 21 | 22 | Caso o valor não se encaixe nas possibilidades, retorne a mensagem: 23 | ------------------------------------------------------------- 24 | "Valor inválido para as notas disponíveis: R$10, R$50, R$100" 25 | ------------------------------------------------------------- 26 | 27 | Se estiver tudo certo com o valor do saque, subtraia o valor do saldo e retorne a mensagem: 28 | ---------------------------------- 29 | "Saque efetuado! Novo saldo: R$30" 30 | ---------------------------------- 31 | 32 | */ 33 | 34 | 35 | function ATM(balance, withdrew){ 36 | // Desenvolva seu código nessa função 37 | } 38 | 39 | module.exports = ATM; 40 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-09.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 09 - Aprovação nos projetos 4 | 5 | Aqui na Trybe você precisa entregar os projetos dentro de algumas regras para obter aprovação. 6 | 7 | Escreva um algoritmo que recebe um objeto com a seguinte estrutura: 8 | { 9 | rec: bool, 10 | reqs: number int, 11 | allReqs: number int, 12 | completed: number int, 13 | } 14 | 15 | Onde: 16 | * rec: informando se a pessoa estudante está ou não em recuperação; 17 | * reqs: são os requisitos obrigatórios; 18 | * allReqs: são os requisitos obrigatórios mais os bônus: 19 | * completed: quantidade de requisitos feitos, completados: 20 | 21 | Considere as seguintes premissas: 22 | * Se a pessoa não estiver em período de recuperação, é preciso entregar 80% ou mais dos requisitos obrigatórios para obter aprovação; 23 | * Se a pessoa estiver em período de recuperação, é preciso entregar 90% dos requisitos totais (obrigatórios + bônus) para obter aprovação; 24 | 25 | Caso a pessoa tenha conseguido entregar o projeto retorne: 26 | ---------------------------------- 27 | "Parabéns, você está aprovado(a)!" 28 | ---------------------------------- 29 | 30 | Caso a pessoa não tenha conseguido entregar o projeto retorne: 31 | ----------------------------------------------- 32 | "Você ainda precisa entregar mais requisitos;)" 33 | ----------------------------------------------- 34 | 35 | */ 36 | 37 | function evaluateProject(obj){ 38 | // Desenvolva seu código nessa função 39 | } 40 | 41 | module.exports = evaluateProject; 42 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/index.js: -------------------------------------------------------------------------------- 1 | 2 | const optionsMenu = require('./desafio-condicionais-01'); 3 | const studentSituation = require('./desafio-condicionais-02'); 4 | const findAdventurous = require('./desafio-condicionais-03'); 5 | const polyglotDinosaur = require('./desafio-condicionais-04'); 6 | const robotFriend = require('./desafio-condicionais-05'); 7 | const basalMetabolicRate = require('./desafio-condicionais-06'); 8 | const legalAge = require('./desafio-condicionais-07'); 9 | const findYoungerPerson = require('./desafio-condicionais-08'); 10 | const evaluateProject = require('./desafio-condicionais-09'); 11 | const droneDelivery = require('./desafio-condicionais-010'); 12 | const triVowels = require('./desafio-condicionais-011'); 13 | const IMC = require('./desafio-condicionais-012'); 14 | const chessRating = require('./desafio-condicionais-013'); 15 | const ATM = require('./desafio-condicionais-014'); 16 | const rockPaperScissors = require('./desafio-condicionais-015'); 17 | const sortAgeAsc = require('./desafio-condicionais-016'); 18 | const oddOreEven = require('./desafio-condicionais-017'); 19 | const cardsGame = require('./desafio-condicionais-018'); 20 | 21 | module.exports = { 22 | optionsMenu, 23 | studentSituation, 24 | findAdventurous, 25 | polyglotDinosaur, 26 | robotFriend, 27 | basalMetabolicRate, 28 | legalAge, 29 | findYoungerPerson, 30 | evaluateProject, 31 | droneDelivery, 32 | triVowels, 33 | IMC, 34 | chessRating, 35 | ATM, 36 | rockPaperScissors, 37 | sortAgeAsc, 38 | oddOreEven, 39 | cardsGame, 40 | }; 41 | -------------------------------------------------------------------------------- /Desafios/Strings/desafio-strings-07.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 07 - Contem "a" ? 4 | 5 | Escreva um algoritmo que recebe uma palavra e checa se ela possui a letra "a" considerando as seguintes premissas para cada tipo de retorno. 6 | 7 | Se apenas começa com letra "a", retorne: 8 | ------------------------------------------------------------ 9 | "A palavra x possui a letra 'a' apenas como primeira letra." 10 | ------------------------------------------------------------ 11 | 12 | Se apenas termina com a letra "a", retorne: 13 | ---------------------------------------------------------- 14 | "A palavra x possui a letra "a" apenas como última letra." 15 | ---------------------------------------------------------- 16 | 17 | Se apenas termina e começa com a letra "a", retorne: 18 | ---------------------------------------------------------------------- 19 | "A palavra x possui a letra 'a' apenas no começo e no fim da palavra." 20 | ---------------------------------------------------------------------- 21 | 22 | Se apenas possui o "a" sem a mesma ser a primeira ou a última letra da palavra, , retorne: 23 | ---------------------------------------------------------------------------- 24 | "A palavra x possui a letra 'a', porém não é a primeira nem a última letra." 25 | ---------------------------------------------------------------------------- 26 | 27 | Senão, retorne: 28 | ----------------------------- 29 | "A palavra x não contém "a"." 30 | ----------------------------- 31 | 32 | */ 33 | 34 | function includeA(word) { 35 | // Desenvolva seu código nessa função 36 | } 37 | 38 | module.exports = includeA; 39 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-018.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 18 - Jogo de cartas 4 | 5 | Mara e Sara estão jogando um novo jogo de cartas chamado Xablau. 6 | O jogo utiliza um baralho normal que possui Ás, Dama, Valete e Reis. 7 | 8 | Para jogar Xablau é necessário ter duas pessoas participantes, que devem receber 2 cartas cada. 9 | 10 | Ganha o jogo quem tiver a maior pontuação, e caso a pontuação das pessoas seja igual o jogo empata. 11 | 12 | A pontuação do Xablau é feita da seguinte forma: 13 | * Se as cartas forem iguais, a pessoa jogadora recebe a soma das duas cartas multiplicada por 2; 14 | * Se as cartas forem sequencias, por exemplo 1 e 2 ou 10 e 11, a pessoa jogadora recebe a soma das duas cartas multiplicada por 3; 15 | * Caso não satisfaça nenhum das duas condições anteriores, a pessoa jogadora recebe somente a soma das duas cartas. 16 | 17 | Para a pontuação vamos considerar apenas números inteiros de 1 a 13. 18 | 19 | Escreva um algoritmo que retorne quando houver empate no jogo ou quem foi a pessoa vencedora do Xablau e qual foi sua pontuação baseando-se nas informações dadas anteriormente. 20 | 21 | Possíveis retornos: 22 | -------------------------- 23 | "Mara venceu com x pontos" 24 | -------------------------- 25 | "Sara venceu com x pontos" 26 | -------------------------- 27 | "O jogo empatou" 28 | ---------------- 29 | 30 | Os seus retornos devem seguir o mesmo padrão dos exemplos acima. 31 | 32 | */ 33 | 34 | function cardsGame(maraCard1, maraCard2, saraCard1, saraCard2){ 35 | // Desenvolva seu código nessa função 36 | } 37 | 38 | module.exports = cardsGame; 39 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/desafiador-016.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 16 - Validação de CPF 4 | 5 | Escreva uma algoritmo que recebe uma string no formato de um CPF `xxx.xxx.xxx-xx` e verifica se o mesmo é válido. 6 | 7 | Considere um CPF com os seguintes dígitos: `abc.def.ghi-jk` 8 | 9 | Para descobrirmos o primeiro dígito verificador `j`, procedemos da seguinte maneira: multiplicamos o primeiro dígito por 1, 10 | o segundo por 2, o terceiro por 3, o quarto por 4 e vamos assim até multiplicarmos o nono por 9. Então, somamos tudo isso. 11 | Em seguida, devemos obter o resto da divisão dessa soma por 11. 12 | Caso o resto seja 10, o dígito `j` deve ser igual a 0. 13 | 14 | Para o segundo dígito verificador `k`, temos o seguinte: multiplicamos o segundo digito por 1, o terceiro por 2, o quarto por 3 15 | e vamos assim até multiplicarmos o décimo (primeiro dígito verificador) por 9. Então, somamos tudo isto. O dígito `k` será o 16 | resto da divisão dessa soma por 11. 17 | Caso o resto seja 10, o dígito `k` deve ser igual a 0. 18 | 19 | Sabendo que isso vale para 100% dos CPFs, sua missão é implementar uma função que, dado um CPF, diga se ele é válido ou não. 20 | 21 | 22 | ***Importante***: 23 | Uma sequência de números iguais, como por exemplo `'000.000.000-00'`, também é um CPF inválido 😉 24 | 25 | Exemplo De CPF Válido: 26 | ---------------------- 27 | Entrada: 28 | "397-606-448-34" 29 | 30 | Saída: 31 | "CPF inválido" 32 | ---------------------- 33 | 34 | Exemplo De CPF Inválido: 35 | ------------------------ 36 | Entrada: 37 | "166.354.840-43" 38 | 39 | Saída: "CPF válido" 40 | ------------------------ 41 | 42 | */ 43 | 44 | function cpfValidator(cpf){ 45 | // Desenvolva seu código nessa função 46 | } 47 | 48 | module.exports = cpfValidator; 49 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/desafio-condicionais-010.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 10 - Entrega do drone 4 | 5 | Uma empresa irá realizar a entrega de suas mercadorias por meio de um drone. 6 | 7 | Este drone possui uma inteligência artificial para chegar ao seu destino, porém ainda são necessários alguns ajustes para que ele possa realizar as entregas. 8 | 9 | O drone voará sozinho até a casa de cada cliente e realizará a entrega pela janela. 10 | A janela das pessoas clientes possui o formato retangular e sempre estará totalmente aberta. 11 | 12 | A caixa na qual estarão as mercadorias tem a forma de um paralelepípedo reto retângulo (formato de um tijolo). 13 | 14 | Para realizar a entrega o drone possui uma visão computacional, posicionando a caixa da mercadoria com alguma de suas faces paralela à janela, sendo possível a rotação. 15 | 16 | Escreva um algoritmo que realiza o cálculo para dizer se é possível ou não a entrada da caixa da mercadoria pela janela de cada cliente. 17 | 18 | As informações que o drone captura em centímetros na hora da análise da entrega são: 19 | 20 | Da caixa: 21 | * altura; 22 | * largura; 23 | * profundidade; 24 | 25 | Da Janela: 26 | * altura; 27 | * largura; 28 | * profundidade. 29 | Em caso de ser possível efetuar a entrega, retorne a mensagem: 30 | -------------------------------- 31 | "É possível realizar a entrega." 32 | -------------------------------- 33 | 34 | Caso o contrário, retorne: 35 | ------------------------------------ 36 | "Não é possível realizar a entrega." 37 | ------------------------------------ 38 | 39 | */ 40 | 41 | function droneDelivery(heightBox, widthBox, depthBox, heightWindow, widthWindow, depthWindow){ 42 | // Desenvolva seu código nessa função 43 | } 44 | 45 | module.exports = droneDelivery; 46 | -------------------------------------------------------------------------------- /Desafios/Objetos/desafio-objetos-05.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 05 - Jogo de fantasia- Parte 3 4 | 5 | Você está desenvolvendo um jogo que lida com personagens em diferentes níveis de experiência. 6 | 7 | Considere tabela: 8 | | Classe | PV Inicial | PV por Nível | Equipamento Inicial | 9 | 10 | | Mago | 5PV | +2PV | Varinha | 11 | | Arqueiro | 10PV | +3PV | Arco Curto | 12 | | Guerreiro | 15PV | +4PV | Espada | 13 | | Cavaleiro | 20PV | +5PV | Armadura Completa | 14 | 15 | Obs: PV = Pontos de Vida. 16 | 17 | Considere as regras: 18 | * Cada personagem receberá no nível 1 o PV inicial; 19 | * Cada personagem terá seu equipamento inicial relacionado à classe; 20 | * A cada nível após o primeiro, cada personagem ganha uma quantidade de PV de acordo com a classe. 21 | 22 | Escreva um algoritmo que receba o nome de uma classe e um nível (maior que 0), e retorne o total de Pontos de Vida (inicial + por nível) e o equipamento do(a) personagem. 23 | 24 | Reforme nos padrões dos exemplo baixo: 25 | 26 | Exemplo 1: 27 | ----------------------------------------------------------------- 28 | Entradas: 29 | "Mago", 2 30 | 31 | Saída: 32 | "Mago, nível 2: 7PV, varinha." 33 | 34 | 35 | Exemplo 2: 36 | ----------------------------------------------------------------- 37 | Entradas: 38 | "Cavaleiro", 4 39 | 40 | Saída: 41 | "Cavaleiro", nível 4: 35PV, Armadura Completa." 42 | 43 | Desafio: faça sem usar estruturas condicionais (ifs ou switches). 44 | ----------------------------------------------------------------- 45 | 46 | */ 47 | 48 | function fantasyGame3(className, level) { 49 | // Desenvolva seu código nessa função 50 | } 51 | 52 | module.exports = fantasyGame3; 53 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/Gabaritos/1-6.js: -------------------------------------------------------------------------------- 1 | const data = require('../data'); 2 | 3 | /** 1 - Retorne e exiba um array com as informações da primeira e da segunda banda utilizando destructuring 4 | */ 5 | const getBandsInformation = () => { 6 | const [banda1, banda2] = data.bands; 7 | const bandsInformation = [banda1, banda2]; 8 | 9 | return bandsInformation; 10 | } 11 | 12 | /* 2 - Através do destructuring, acesse o nome e os melhores álbuns primeira banda, 13 | retornando uma string no seguinte formato: "Os Melhores álbuns do Radiohead: In Rainbows,Kid A,OK Computer,Pablo Honey" 14 | */ 15 | 16 | const getBestAlbuns = () => { 17 | const { bandName, bestAlbuns } = data.bands[0]; 18 | const albuns = bestAlbuns.reduce((acc, { name }) => { 19 | acc.push(name); 20 | return acc; 21 | }, []); 22 | 23 | return `Os melhores álbuns do ${bandName}: ${albuns}` 24 | } 25 | 26 | // 3 - Retorne um array utilizando HOF's que contenha apenas o nome das bandas 27 | 28 | const getBandsName = () => { 29 | const allBandsName = data.bands.map((band) => band.bandName); 30 | 31 | return allBandsName; 32 | } 33 | 34 | // 4 - Filtre e retorne um array apenas com o nome das bandas que são dos Estados Unidos 35 | 36 | const usaFilter = () => { 37 | const usaBands = data.bands.filter((band) => band.country = 'United States') 38 | .map(({ bandName }) => bandName); 39 | 40 | return usaBands; 41 | } 42 | 43 | // 5 - Filtre e retorne um array com os nomes das bandas que contenham 'Rock' no gênero musical 44 | 45 | const rockFilter = () => { 46 | const bandsGenre = data.bands.filter((band) => band.genre.includes('Rock')).map(band => band.bandName) 47 | return bandsGenre; 48 | } 49 | 50 | // 6 - Filtre e retorne um array com todos os álbuns que possuem nota igual a 100 51 | 52 | const highestRatingFilter = () => { 53 | bandAlbum = data.bands.map((band) => band.bestAlbuns) 54 | .reduce((a, b) => [...a, ...b]) 55 | .filter((item) => item.rate === 100); 56 | 57 | return bandAlbum; 58 | } 59 | -------------------------------------------------------------------------------- /Desafios/Arrays/Gabaritos/1-5.js: -------------------------------------------------------------------------------- 1 | /* 01 - Encontre o maior número de uma array. */ 2 | function getMaxNumber(numbers) { 3 | let maxNumber = numbers[0]; 4 | 5 | for (let index = 1; index < numbers.length; index += 1) { 6 | if (numbers[index] > maxNumber) { 7 | maxNumber = numbers[index]; 8 | } 9 | } 10 | return maxNumber; 11 | } 12 | 13 | /* 02 - Encontre o menor número de uma array. */ 14 | function getMinNumber(numbers) { 15 | let minNumber = numbers[0]; 16 | 17 | for (let index = 1; index < numbers.length; index += 1) { 18 | if (numbers[index] < minNumber) { 19 | minNumber = numbers[index]; 20 | } 21 | } 22 | return minNumber; 23 | } 24 | 25 | /* 03 - Encontre uma pessoa convidada em uma lista de nomes. */ 26 | function findQuest(names, guest) { 27 | let findGuest = false; 28 | let message = ""; 29 | 30 | for (let index = 0; index < names.length; index += 1) { 31 | if (names[index].toUpperCase() == guest.toUpperCase()) { 32 | findGuest = true; 33 | } 34 | } 35 | 36 | if (findGuest == true) { 37 | message = "O nome está na lista."; 38 | } else { 39 | message = "O nome não está na lista."; 40 | } 41 | return message; 42 | } 43 | 44 | /* 04 - Verifique se todos os dados de uma lista são do mesmo tipo. */ 45 | function dataType(types) { 46 | const typeOfFirst = typeof types[0]; 47 | for (let elements of types) { 48 | if (typeOfFirst !== typeof elements) { 49 | return false; 50 | } 51 | } 52 | return true; 53 | } 54 | 55 | /* 05 - Encontre o filho mais velho. */ 56 | function findOldestSon(pedroAge, kidsAge) { 57 | let sumKidsAge = 0; 58 | 59 | kidsAge.forEach((kid) => { 60 | sumKidsAge += kid; 61 | }); 62 | 63 | let olderKidAge = pedroAge - sumKidsAge; 64 | kidsAge.push(olderKidAge); 65 | 66 | let olderKid = getMaxNumber(kidsAge); 67 | 68 | return `O filho mais velho tem ${olderKid} anos.`; 69 | } 70 | 71 | module.exports = { 72 | getMaxNumber, 73 | getMinNumber, 74 | findQuest, 75 | dataType, 76 | findOldestSon, 77 | }; 78 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/index.js: -------------------------------------------------------------------------------- 1 | const average = require('./desafio-operadores-aritmeticos-01') 2 | const totalReceive = require('./desafio-operadores-aritmeticos-02') 3 | const showNeighbors = require('./desafio-operadores-aritmeticos-03') 4 | const powerNumber = require('./desafio-operadores-aritmeticos-04') 5 | const triangleArea = require('./desafio-operadores-aritmeticos-05') 6 | const IMC = require('./desafio-operadores-aritmeticos-06') 7 | const readingTime = require('./desafio-operadores-aritmeticos-07') 8 | const restaurantExpenses = require('./desafio-operadores-aritmeticos-08') 9 | const celsiusToFahrenheit = require('./desafio-operadores-aritmeticos-09') 10 | const fahrenheitToCelsius = require('./desafio-operadores-aritmeticos-010') 11 | const paymentOptions = require('./desafio-operadores-aritmeticos-011') 12 | const weightAndValue = require('./desafio-operadores-aritmeticos-012') 13 | const randomRGBColor = require('./desafio-operadores-aritmeticos-013') 14 | const timeTravel = require('./desafio-operadores-aritmeticos-014') 15 | const areaCircle = require('./desafio-operadores-aritmeticos-015') 16 | const randomBoolean = require('./desafio-operadores-aritmeticos-016') 17 | const carFinancing = require('./desafio-operadores-aritmeticos-017') 18 | const rollDice = require('./desafio-operadores-aritmeticos-018') 19 | const carTrip = require('./desafio-operadores-aritmeticos-019') 20 | const avaliador = require('./desafio-operadores-aritmeticos-020') 21 | const weightedAverage = require('./desafio-operadores-aritmeticos-021') 22 | const calculateScore = require('./desafio-operadores-aritmeticos-022') 23 | const successiveDivisions = require('./desafio-operadores-aritmeticos-023') 24 | 25 | module.exports = { 26 | average, 27 | totalReceive, 28 | showNeighbors, 29 | powerNumber, 30 | triangleArea, 31 | IMC, 32 | readingTime, 33 | restaurantExpenses, 34 | celsiusToFahrenheit, 35 | fahrenheitToCelsius, 36 | paymentOptions, 37 | weightAndValue, 38 | randomRGBColor, 39 | timeTravel, 40 | areaCircle, 41 | randomBoolean, 42 | carFinancing, 43 | rollDice, 44 | carTrip, 45 | avaliador, 46 | weightedAverage, 47 | calculateScore, 48 | successiveDivisions, 49 | }; 50 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/Gabaritos/1-10.js: -------------------------------------------------------------------------------- 1 | /* 01 - Calcular a média */ 2 | function average(number1, number2, number3) { 3 | let average = (number1 + number2 + number3) / 3; 4 | return "O Valor médio é: " + average; 5 | } 6 | 7 | /* 02 - Calcular o salário */ 8 | function totalReceive(salary, sales) { 9 | let commissionPercentage = 0.04; 10 | let commission = sales * commissionPercentage; 11 | 12 | let total = commission + salary; 13 | 14 | return "A comissão é: " + commission + " e o ganho total é: " + total; 15 | } 16 | 17 | /* 03 - Antecessor e Sucessor */ 18 | function showNeighbors(number) { 19 | let previous = number - 1; 20 | let next = number + 1; 21 | return ( 22 | "O antecessor de " + number + " é " + previous + " e seu sucessor é " + next 23 | ); 24 | } 25 | 26 | /* 04 - Potência de um número */ 27 | function powerNumber(base, exponent) { 28 | return base ** exponent; 29 | } 30 | 31 | /* 05 - Área de um triângulo */ 32 | function triangleArea(base, height) { 33 | let area = (base * height) / 2; 34 | return ( 35 | "A área do triângulo de base " + 36 | base + 37 | " e altura " + 38 | height + 39 | " é: " + 40 | area 41 | ); 42 | } 43 | 44 | /* 06 - Calcular IMC */ 45 | function IMC(weight, height) { 46 | let imc = (height * height) / weight; 47 | return imc; 48 | } 49 | 50 | /* 07 - Calcule quanto tempo de leitura */ 51 | function readingTime(totalPages, readPages, minutes) { 52 | let totalMinutes = (totalPages * minutes) / readPages; 53 | return "Ana levará " + totalMinutes + " minutos para ler o livro todo"; 54 | } 55 | 56 | /* 08 - Conta do restaurante */ 57 | function restaurantExpenses(account){ 58 | let total = (account * 1.1) * 1.05; 59 | return +total.toFixed(2); 60 | } 61 | 62 | 63 | /* 09 - Celsius */ 64 | function celsiusToFahrenheit(celsius){ 65 | let fahrenheit = (celsius / 5) * 9 + 32; 66 | return fahrenheit; 67 | } 68 | 69 | /* 10 - Fahrenheit */ 70 | function fahrenheitToCelsius(fahrenheit){ 71 | let celsius = +((5 * (fahrenheit - 32)) / 9).toFixed(2); 72 | return celsius; 73 | } 74 | 75 | module.exports = { 76 | average, 77 | totalReceive, 78 | showNeighbors, 79 | powerNumber, 80 | triangleArea, 81 | IMC, 82 | readingTime, 83 | restaurantExpenses, 84 | celsiusToFahrenheit, 85 | fahrenheitToCelsius, 86 | } 87 | -------------------------------------------------------------------------------- /Desafios/Objetos/Gabaritos/1-5.js: -------------------------------------------------------------------------------- 1 | /* 01 - Jogo de fantasia */ 2 | function fantasyGame(className) { 3 | let roles = { 4 | Mago: "5PV", 5 | Arqueiro: "10PV", 6 | Guerreiro: "15PV", 7 | Cavaleiro: "20PV", 8 | }; 9 | return `${className}, ${roles[className]}.`; 10 | } 11 | 12 | /* 02 - Jogo de fantasia2 */ 13 | function fantasyGame2(className) { 14 | let roles = { 15 | Mago: { 16 | points: "5PV", 17 | equipment: "Varinha", 18 | }, 19 | Arqueiro: { 20 | points: "10PV", 21 | equipment: "Arco Curto", 22 | }, 23 | Guerreiro: { 24 | points: "15PV", 25 | equipment: "Espada", 26 | }, 27 | Cavaleiro: { 28 | points: "20PV", 29 | equipment: "Armadura Completa", 30 | }, 31 | }; 32 | 33 | return `${roles[className].points}, ${roles[className].equipment}.`; 34 | } 35 | 36 | /* 03 - Escala musical */ 37 | function musicalScale(note) { 38 | let degrees = { 39 | Dó: "I", 40 | Ré: "II", 41 | Mi: "III", 42 | Fá: "IV", 43 | Sol: "V", 44 | Lá: "VI", 45 | Si: "VII", 46 | }; 47 | return degrees[note]; 48 | } 49 | 50 | /* 04 - Quem é a pessoa mais velha? */ 51 | function getOldPerson(arrPeople) { 52 | let olderPerson = { name: "", age: 0 }; 53 | 54 | for (let index = 0; index < arrPeople.length; index++) { 55 | let currentPerson = arrPeople[index]; 56 | if (currentPerson.age > olderPerson.age) { 57 | olderPerson.name = currentPerson.name; 58 | olderPerson.age = currentPerson.age; 59 | } 60 | } 61 | return `${olderPerson.name} tem a maior idade com ${olderPerson.age} anos.`; 62 | } 63 | 64 | /* 05 - Jogo de fantasia- Parte 3 */ 65 | function fantasyGame3(className, level) { 66 | let role = className; 67 | /* let level = 1; */ 68 | let roles = { 69 | Mago: { 70 | lifePoints: 5, 71 | lifePointsPerLevel: 2, 72 | equipment: "Varinha", 73 | }, 74 | Arqueiro: { 75 | lifePoints: 10, 76 | lifePointsPerLevel: 3, 77 | equipment: "Arco Curto", 78 | }, 79 | Guerreiro: { 80 | lifePoints: 15, 81 | lifePointsPerLevel: 4, 82 | equipment: "Espada", 83 | }, 84 | Cavaleiro: { 85 | lifePoints: 20, 86 | lifePointsPerLevel: 5, 87 | equipment: "Armadura Completa", 88 | }, 89 | }; 90 | 91 | let { lifePoints, equipment, lifePointsPerLevel } = roles[role]; 92 | let levelsAfterFirst = level - 1; 93 | let additionalLifePoints = levelsAfterFirst * lifePointsPerLevel; 94 | let totalLifePoints = lifePoints + additionalLifePoints; 95 | 96 | return `${role}, nível ${level}: ${totalLifePoints}PV, ${equipment}.`; 97 | } 98 | 99 | module.exports = { 100 | fantasyGame, 101 | fantasyGame2, 102 | musicalScale, 103 | getOldPerson, 104 | fantasyGame3, 105 | }; 106 | -------------------------------------------------------------------------------- /Desafios/Estruturas de Repetições/Gabaritos/1-9.js: -------------------------------------------------------------------------------- 1 | /* 01 - Mensagem codificada */ 2 | function encode(string) { 3 | let stringDecoded = ""; 4 | for (let index = 0; index < string.length; index += 1) { 5 | stringDecoded += index * 3; 6 | } 7 | return stringDecoded; 8 | } 9 | 10 | /* 02 - Contar até o limite */ 11 | function accumulator(limit) { 12 | let accumulator = 1; 13 | for (let index = 2; index <= limit; index = index + 1) { 14 | accumulator = accumulator + index; 15 | } 16 | return accumulator; 17 | } 18 | 19 | /* 03 - Calcular a soma de 1 até 1000 */ 20 | function accumulatorThousand() { 21 | let accumulator = 1; 22 | for (let index = 2; index <= 1000; index = index + 1) { 23 | accumulator = accumulator + index; 24 | } 25 | return `A soma de 1 até 1000 é ${accumulator}.`; 26 | } 27 | 28 | /* 04 - Escreva um nome N vezes */ 29 | function repeatName(name, quantity) { 30 | let concatenator = name; 31 | for (let index = 2; index <= quantity; index = index + 1) { 32 | concatenator = `${concatenator}, ${name}`; 33 | } 34 | return concatenator + "."; 35 | } 36 | 37 | /* 05 - Números divisíveis por 3 */ 38 | function numbersDivisibleBy3(start, limit) { 39 | let counter = 0; 40 | for (let index = start; index <= limit; index = index + 1) { 41 | if (index % 3 === 0) { 42 | counter = counter + 1; 43 | } 44 | } 45 | if (counter >= 50) { 46 | return "Há 50 ou mais números diviseis por 3."; 47 | } 48 | return "Sequência muito pequena."; 49 | } 50 | 51 | /* 06 - Retorne os números ímpares */ 52 | function oddNumbers() { 53 | let concatenator = "1"; 54 | for (let index = 3; index <= 50; index = index + 1) { 55 | if (index % 2 !== 0) { 56 | concatenator = `${concatenator}, ${index}`; 57 | } 58 | } 59 | return `${concatenator}.`; 60 | } 61 | /* 07 - Onde está o elemento? */ 62 | function findIndexOf(array, element) { 63 | for (let elem of array) { 64 | if (elem === element) { 65 | return array.indexOf(element); 66 | } 67 | } 68 | return "Elemento não encontrado no array."; 69 | } 70 | 71 | /* 08 - Ordem decrescente */ 72 | function sortDec() { 73 | let concatenator = "200"; 74 | for (let count = 199; count >= 100; count = count - 1) { 75 | concatenator = `${concatenator}, ${count}`; 76 | } 77 | return `${concatenator}.`; 78 | } 79 | 80 | /* 09 - Incluído nos arrays */ 81 | function includesArrays(a, b) { 82 | let newArray = []; 83 | 84 | for (let index = 0; index < a.length; index += 1) { 85 | for (let newIndex = 0; newIndex < b.length; newIndex += 1) { 86 | if (a[index] === b[newIndex]) { 87 | newArray.push(a[index]); 88 | } 89 | } 90 | 91 | } 92 | return newArray; 93 | } 94 | 95 | module.exports = { 96 | encode, 97 | accumulator, 98 | accumulatorThousand, 99 | repeatName, 100 | numbersDivisibleBy3, 101 | oddNumbers, 102 | findIndexOf, 103 | sortDec, 104 | includesArrays, 105 | }; 106 | -------------------------------------------------------------------------------- /Desafios/Destructuring e HOFs/data.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | bands: [ 3 | { 4 | bandName: 'Radiohead', 5 | bestAlbuns: [ 6 | { 7 | name: "In Rainbows", 8 | rate: 100 9 | }, 10 | { 11 | name: "Kid A", 12 | rate: 95 13 | }, 14 | { 15 | name: "OK Computer", 16 | rate: 90 17 | }, 18 | { 19 | name: "Pablo Honey", 20 | rate: 80 21 | } 22 | ], 23 | genre: "Rock", 24 | country: "England", 25 | }, 26 | { 27 | bandName: 'Avenged Sevenfold', 28 | bestAlbuns: [ 29 | { 30 | name: "City of Evil", 31 | rate: 99 32 | }, 33 | { 34 | name: "Avenged Sevenfold", 35 | rate: 98 36 | }, 37 | { 38 | name: "Sounding the Seventh Trumpet", 39 | rate: 95 40 | }, 41 | { 42 | name: "Diamonds in the Rough", 43 | rate: 80 44 | } 45 | ], 46 | genre: 'Hard Rock', 47 | country: "United States", 48 | }, 49 | { 50 | bandName: 'Arctic Monkeys', 51 | bestAlbuns: [ 52 | { 53 | name: "Humbug", 54 | rate: 100 55 | }, 56 | { 57 | name: "AM", 58 | rate: 99 59 | }, 60 | { 61 | name: "Favourite Worst Nightmare", 62 | rate: 95 63 | }, 64 | { 65 | name: "Whatever People Say I Am, That's What I'm Not", 66 | rate: 90 67 | } 68 | ], 69 | genre: 'Indie Rock', 70 | country: "England", 71 | }, 72 | { 73 | bandName: 'Pink Floyd', 74 | bestAlbuns: [ 75 | { 76 | name: "Wish You Were Here", 77 | rate: 100 78 | }, 79 | { 80 | name: "Dark Side of the Moon", 81 | rate: 100 82 | }, 83 | { 84 | name: "Animals", 85 | rate: 100 86 | }, 87 | { 88 | name: "A Saucerful of Secrets", 89 | rate: 98 90 | } 91 | ], 92 | genre: 'Progressive Rock', 93 | country: "England", 94 | }, 95 | { 96 | bandName: 'Foo Fighters', 97 | bestAlbuns: [ 98 | { 99 | name: "Wasting Light", 100 | rate: 100 101 | }, 102 | { 103 | name: "Sonic Highways", 104 | rate: 90 105 | }, 106 | { 107 | name: "Concrete and Gold", 108 | rate: 90 109 | }, 110 | { 111 | name: "Echoes, Silence, Patience & Grace", 112 | rate: 85 113 | } 114 | ], 115 | genre: 'Rock', 116 | country: "United States", 117 | }, 118 | { 119 | bandName: 'Red Hot Chili Peppers', 120 | bestAlbuns: [ 121 | { 122 | name: "Stadium Arcadium", 123 | rate: 100 124 | }, 125 | { 126 | name: "Californication", 127 | rate: 99 128 | }, 129 | { 130 | name: "By the Way", 131 | rate: 97 132 | }, 133 | { 134 | name: "The Getaway", 135 | rate: 95 136 | } 137 | ], 138 | genre: 'Rock', 139 | country: "United States" 140 | } 141 | ] 142 | } 143 | -------------------------------------------------------------------------------- /Desafios/Operadores Aritméticos/Gabaritos/11-20.js: -------------------------------------------------------------------------------- 1 | /* 11 - Loja de ração */ 2 | function paymentOptions(price) { 3 | let inCash = price - price * 0.1; 4 | let creditCard = price + price * 0.15; 5 | return `À Vista: R$${inCash} ou 4x de: R$${Math.round((creditCard / 4 * 100)) / 100}`; 6 | } 7 | 8 | /* 12 - Peso e preço do prato */ 9 | function weightAndValue(priceKg, plateWeight) { 10 | let totalPrice = ((priceKg * plateWeight) / 1000).toFixed(2).replace('.', ','); 11 | return `O prato de ${plateWeight} gramas custa: R$ ${totalPrice}`; 12 | } 13 | 14 | /* 13 - Cor aleatória */ 15 | function generateOneColor() { 16 | let uniqueColor = Math.floor(Math.random() * 256); 17 | return uniqueColor; 18 | } 19 | 20 | function randomRGBColor() { 21 | let finalColor = `rgb(${generateOneColor()}, ${generateOneColor()}, ${generateOneColor()})`; 22 | return finalColor; 23 | } 24 | 25 | /* 14 - Tempo de viagem */ 26 | function timeTravel(totalMinutes) { 27 | let hours = Math.floor(totalMinutes / 60); 28 | let minutes = totalMinutes % 60; 29 | return ( 30 | "A viagem terá duração de " + 31 | hours + 32 | " hora(s) e " + 33 | minutes + 34 | " minuto(s)" 35 | ); 36 | } 37 | 38 | /* 15 - Área de uma circunferência */ 39 | function areaCircle(diameter) { 40 | let radius = diameter / 2; 41 | let area = Math.PI * Math.pow(radius, 2); 42 | return `A circunferência de raio ${radius} cm possui uma área de ${area.toFixed( 43 | 2 44 | )} cm quadrados`; 45 | } 46 | 47 | /* 16 - Verdadeiro ou falso? */ 48 | function randomBoolean() { 49 | return Math.random() >= 0.5; 50 | } 51 | 52 | /* 17 - Financiamento de veículo */ 53 | function formatBrazilianMoney(number) { 54 | const beforeComma = Math.floor(number); 55 | let afterComma = Math.round(number * 100 - beforeComma * 100); 56 | afterComma = afterComma !== 0 ? afterComma : `00`; 57 | return `${beforeComma},${afterComma}`; 58 | } 59 | 60 | function carFinancing(carPrice, entranceValue, quota) { 61 | let financing = carPrice - entranceValue; 62 | let tax = 0.05; 63 | return ( 64 | "Valor Financiado: R$" + 65 | formatBrazilianMoney(financing) + 66 | ";\nValor do Juros: R$" + 67 | formatBrazilianMoney(financing * tax) + 68 | ";\nQuantidade de Parcelas: " + 69 | quota + 70 | ";\nValor da Parcela: R$" + 71 | formatBrazilianMoney((financing * tax + financing) / quota) + 72 | ";\nValor Total do Carro: R$" + 73 | formatBrazilianMoney(financing * tax + financing + entranceValue) + '.' 74 | ); 75 | } 76 | 77 | /* 18 - Simulação de dado RPG */ 78 | function rollDice(diceSide) { 79 | let numberRolled = Math.floor(Math.random() * Number(diceSide) + 1); 80 | return numberRolled; 81 | } 82 | 83 | /* 19 - Viagem de carro */ 84 | function carTrip(spBh, bhSal, salNat) { 85 | let totalHours = spBh + bhSal + salNat; 86 | let days = totalHours / 24; 87 | 88 | return parseFloat(days.toFixed(3)); 89 | } 90 | 91 | /* 20 - Aprovado ou reprovado? */ 92 | function avaliador(score1, score2, score3) { 93 | let averageScore = Math.round((score1 + score2 + score3) / 3); 94 | 95 | if (averageScore >= 6) { 96 | return "Aprovação, média: " + averageScore; 97 | } 98 | return "Reprovação, média: " + averageScore; 99 | } 100 | 101 | module.exports = { 102 | paymentOptions, 103 | weightAndValue, 104 | randomRGBColor, 105 | timeTravel, 106 | areaCircle, 107 | randomBoolean, 108 | carFinancing, 109 | rollDice, 110 | carTrip, 111 | avaliador, 112 | }; 113 | -------------------------------------------------------------------------------- /test/arrays.test.js: -------------------------------------------------------------------------------- 1 | /* É importada nesse arquivo tanto as funções do gabarito quanto dos desafios */ 2 | 3 | /* Gabaritos */ 4 | /* const { 5 | getMaxNumber, 6 | getMinNumber, 7 | findGuest, 8 | dataType, 9 | findOldestSon, 10 | } = require("../Desafios/Arrays/Gabaritos/1-5"); */ 11 | 12 | /* Exercícios */ 13 | const { 14 | getMaxNumber, 15 | getMinNumber, 16 | findGuest, 17 | dataType, 18 | findOldestSon, 19 | } = require("../Desafios/Arrays/"); 20 | 21 | describe("Desafios de Arrays.", () => { 22 | describe("01 - Testando a Função getMaxNumber.", () => { 23 | it("Ao passar o argumento [3, 1, 8, 34, 13, 2, 5], deve retornar: 34", () => { 24 | expect(getMaxNumber([3, 1, 8, 34, 13, 2, 5])).toBe(34); 25 | }); 26 | it("Ao passar o argumento [-8, 12, 13, 84, -100, 45, 38], deve retornar: 84", () => { 27 | expect(getMaxNumber([-8, 12, 13, 84, -100, 45, 38])).toBe(84); 28 | }); 29 | }); 30 | 31 | describe("02 - Testando a Função getMinNumber.", () => { 32 | it("Ao passar o argumento [3, 1, 8, 34, 13, 2, 5], deve retornar: 1", () => { 33 | expect(getMinNumber([3, 1, 8, 34, 13, 2, 5])).toBe(1); 34 | }); 35 | it("Ao passar o argumento [-8, 12, 13, 84, -100, 45, 38], deve retornar: -100", () => { 36 | expect(getMinNumber([-8, 12, 13, 84, -100, 45, 38])).toBe(-100); 37 | }); 38 | }); 39 | 40 | describe("03 - Testando a Função findGuest.", () => { 41 | it("Ao passar os argumentos ['Silvia', 'Isa', 'Mica', 'Amanda'] e 'Mica', deve retornar: 'O nome está na lista.'", () => { 42 | expect(findGuest(['Silvia', 'Isa', 'Mica', 'Amanda'], 'Mica')).toBe( 43 | "O nome está na lista." 44 | ); 45 | }); 46 | it("Ao passar os argumentos ['Bruna', 'Joaquim', 'Julia', 'Amanda'] e 'Daniel', deve retornar: 'O nome não está na lista.'", () => { 47 | expect(findGuest(['Silvia', 'Isa', 'Mica', 'Amanda'], 'Daniel')).toBe( 48 | 'O nome não está na lista.' 49 | ); 50 | }); 51 | }); 52 | 53 | describe("04 - Testando a Função dataType.", () => { 54 | it("Ao passar o argumento ['Daniel', 'John', 'Marcos'], deve retornar: true", () => { 55 | expect(dataType(['Daniel', 'John', 'Marcos'])).toBe(true); 56 | }); 57 | it("Ao passar o argumento ['Daniel', 'John', 1], deve retornar: false", () => { 58 | expect(dataType(["Daniel", "John", 1])).toBe(false); 59 | }); 60 | it("Ao passar o argumento [ 40, 121, -14], deve retornar: true", () => { 61 | expect(dataType([40, 121, -14])).toBe(true); 62 | }); 63 | it("Ao passar o argumento [true, false, true], deve retornar: true", () => { 64 | expect(dataType([true, false, true])).toBe(true); 65 | }); 66 | it("Ao passar o argumento [true, false, 0], deve retornar: false", () => { 67 | expect(dataType([true, false, 0])).toBe(false); 68 | }); 69 | }); 70 | 71 | describe("05 - Testando a Função findOldestSon.", () => { 72 | it("Ao passar os argumentos 40 e [11, 8, 9], deve retornar: 'O filho mais velho tem 12 anos.'", () => { 73 | expect(findOldestSon(40, [11, 8, 9])).toBe( 74 | "O filho mais velho tem 12 anos." 75 | ); 76 | }); 77 | it("Ao passar os argumentos 60 e [12, 16, 20], deve retornar: 'O filho mais velho tem 21 anos.'", () => { 78 | expect(findOldestSon(60, [11, 16, 12])).toBe( 79 | "O filho mais velho tem 21 anos." 80 | ); 81 | }); 82 | it("Ao passar os argumentos 37 e [9, 6, 12], deve retornar: 'O filho mais velho tem 12 anos.'", () => { 83 | expect(findOldestSon(37, [9, 6, 12])).toBe( 84 | "O filho mais velho tem 12 anos." 85 | ); 86 | }); 87 | }); 88 | }); 89 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/Gabaritos/11-16.js: -------------------------------------------------------------------------------- 1 | /* 11 - Array de notas musicais - 3 */ 2 | function musicalNotes3(arrNotes) { 3 | let allDegrees = { 4 | Dó: "I", 5 | Ré: "II", 6 | Mi: "III", 7 | Fá: "IV", 8 | Sol: "V", 9 | Lá: "VI", 10 | Si: "VII", 11 | }; 12 | 13 | let allDegreesKeys = Object.keys(allDegrees); 14 | let arrNotesDetails = []; 15 | 16 | for (let index = 0; index < arrNotes.length; index += 1) { 17 | let thisNote = arrNotes[index]; 18 | let thisDegree = allDegrees[thisNote]; 19 | 20 | let noteIndex = allDegreesKeys.findIndex((key) => key === thisNote); 21 | 22 | let thirdIndex = noteIndex + 2; 23 | let fifthIndex = noteIndex + 4; 24 | 25 | let third = allDegreesKeys[thirdIndex] || allDegreesKeys[thirdIndex - 7]; 26 | let fifth = allDegreesKeys[fifthIndex] || allDegreesKeys[fifthIndex - 7]; 27 | 28 | arrNotesDetails.push({ 29 | degree: thisDegree, 30 | triad: [thisNote, third, fifth], 31 | }); 32 | } 33 | return arrNotesDetails; 34 | } 35 | 36 | /* 12 - Fatorial */ 37 | function factorial(n) { 38 | if (n <= 1) { 39 | return 1; 40 | } 41 | return n * factorial(n - 1); 42 | } 43 | 44 | /* 13 - Fibonacci */ 45 | function fibonnaci(n) { 46 | const fib = [0, 1]; 47 | for (let count = 2; count <= n; count += 1) { 48 | let n1 = fib[count - 1]; 49 | let n2 = fib[count - 2]; 50 | fib.push(n1 + n2); 51 | } 52 | return fib[n - 1]; 53 | } 54 | 55 | /* 14 - Soma de números primos */ 56 | function isPrimo(number) { 57 | if (number <= 1) return false; 58 | 59 | for (let index = 2; index < number; index += 1) { 60 | if (number % index === 0) return false; 61 | } 62 | 63 | return true; 64 | } 65 | 66 | function sumPrimesNumbers() { 67 | let sum = 0; 68 | for (let index = 1; index <= 150; index += 1) { 69 | if (isPrimo(index)) { 70 | sum = sum + index 71 | } 72 | } 73 | return sum; 74 | } 75 | 76 | /* 15 - Fatorial e média */ 77 | function factorial15(number) { 78 | if (number === 0 || number === 1) { 79 | return 1; 80 | } 81 | 82 | let fat = 1; 83 | for (let index = 2; index <= number; index += 1) { 84 | fat *= index; 85 | } 86 | 87 | return fat; 88 | } 89 | 90 | function meanFactorialFromAToB(a, b) { 91 | let sum = 0; 92 | for (let n = a; n <= b; n += 1) { 93 | sum += factorial(n); 94 | } 95 | return parseFloat((sum / (b - a + 1)).toFixed(2)); 96 | } 97 | 98 | /* 16 - Validação de CPF */ 99 | 100 | function calcCpfFirstDigit(cpfArray) { 101 | const sum = cpfArray 102 | .slice(0, 9) 103 | .reduce((sum, number, index) => sum + number * (index + 1), 0); 104 | const rest = sum % 11; 105 | if (rest === 10) { 106 | return 0; 107 | } 108 | return rest; 109 | } 110 | function calcCpfSecondDigit(cpfArray) { 111 | const sum = cpfArray 112 | .slice(0, 10) 113 | .reduce((sum, number, index) => sum + number * index, 0); 114 | const rest = sum % 11; 115 | if (rest === 10) { 116 | return 0; 117 | } 118 | return rest; 119 | } 120 | 121 | 122 | function cpfValidator(cpf) { 123 | const cpfArray = cpf 124 | .replace(/[^0-9]/g, "") 125 | .split("") 126 | .map((strDigit) => parseInt(strDigit)); 127 | 128 | if (!cpfArray.find((number) => number !== cpfArray[0])) { 129 | return "CPF inválido"; 130 | } 131 | if ( 132 | calcCpfFirstDigit(cpfArray) === cpfArray[9] && 133 | calcCpfSecondDigit(cpfArray) === cpfArray[10] 134 | ) { 135 | return "CPF válido"; 136 | } 137 | 138 | return "CPF inválido"; 139 | } 140 | 141 | module.exports = { 142 | musicalNotes3, 143 | factorial, 144 | fibonnaci, 145 | sumPrimesNumbers, 146 | factorial15, 147 | meanFactorialFromAToB, 148 | cpfValidator, 149 | }; 150 | -------------------------------------------------------------------------------- /test/mocks.js: -------------------------------------------------------------------------------- 1 | const stringMock = { 2 | test9: 3 | "Na minha vida tudo acontece Mas quanto mais a gente rala, mais a gente cresce Hoje estou feliz porque eu sonhei com você E amanhã posso chorar por não poder te ver Mas o seu sorriso vale mais que um diamante Se você vier comigo, aí nós vamos adiante Com a cabeça erguida e mantendo a fé em Deus O seu dia mais feliz vai ser o mesmo que o meu A vida me ensinou a nunca desistir Nem ganhar, nem perder mas procurar evoluir Podem me tirar tudo que tenho Só não podem me tirar as coisas boas que eu já fiz pra quem eu amo E eu sou feliz e canto e o universo é uma canção E eu vou que vou História, nossas histórias Dias de luta, dias de glória", 4 | resp9: 5 | "N5 m9nh5 v9d5 t1dp 5cpntbcb M5s q15ntp m59s 5 gbntb r5l5, m59s 5 gbntb crbscb Hpjb bstp1 fbl9z pprq1b b1 spnhb9 cpm vpcê E 5m5nhã ppssp chpr5r ppr nãp ppdbr tb vbr M5s p sb1 sprr9sp v5lb m59s q1b 1m d95m5ntb Sb vpcê v9br cpm9gp, 5í nós v5mps 5d95ntb Cpm 5 c5bbç5 brg19d5 b m5ntbndp 5 fé bm Db1s O sb1 d95 m59s fbl9z v59 sbr p mbsmp q1b p mb1 A v9d5 mb bns9np1 5 n1nc5 dbs9st9r Nbm g5nh5r, nbm pbrdbr m5s prpc1r5r bvpl19r Ppdbm mb t9r5r t1dp q1b tbnhp Só nãp ppdbm mb t9r5r 5s cp9s5s bp5s q1b b1 já f9z pr5 q1bm b1 5mp E b1 sp1 fbl9z b c5ntp b p 1n9vbrsp é 1m5 c5nçãp E b1 vp1 q1b vp1 H9stór95, npss5s h9stór95s D95s db l1t5, d95s db glór95", 6 | }; 7 | 8 | const desafiadoresMock = { 9 | test4: [ 10 | { 11 | degree: "II", 12 | third: "Menor", 13 | scale: "Dórica", 14 | }, 15 | { 16 | degree: "V", 17 | third: "Maior", 18 | scale: "Mixolídia", 19 | }, 20 | { 21 | degree: "I", 22 | third: "Maior", 23 | scale: "Jônia", 24 | }, 25 | ], 26 | test6: [ 27 | { name: "lápis", price: 2 }, 28 | { name: "borracha", price: 4 }, 29 | { name: "caneta", price: 5 }, 30 | { name: "régua", price: 6 }, 31 | { name: "apontador", price: 3 }, 32 | { name: "teclado gamer", price: 180 }, 33 | { name: "mochila", price: 33 }, 34 | { name: "fone de ouvido", price: 57 }, 35 | { name: "mousepad", price: 35 }, 36 | ], 37 | test8: { 38 | liverpool: 4, 39 | chelsea: 1, 40 | arsenal: 2, 41 | city: 2, 42 | }, 43 | result11: [ 44 | { 45 | degree: "II", 46 | triad: ["Ré", "Fá", "Lá"], 47 | }, 48 | { 49 | degree: "V", 50 | triad: ["Sol", "Si", "Ré"], 51 | }, 52 | { 53 | degree: "I", 54 | triad: ["Dó", "Mi", "Sol"], 55 | }, 56 | ], 57 | }; 58 | 59 | const objetosMock = { 60 | mock4A: [ 61 | { name: "Ramon", age: 35 }, 62 | { name: "José", age: 28 }, 63 | { name: "Amanda", age: 19 }, 64 | ], 65 | mock4B: [ 66 | { name: "Ramon", age: 35 }, 67 | { name: "José", age: 36 }, 68 | { name: "Amanda", age: 19 }, 69 | ], 70 | mock4C: [ 71 | { name: "Ramon", age: 35 }, 72 | { name: "José", age: 36 }, 73 | { name: "Amanda", age: 50 }, 74 | ], 75 | }; 76 | 77 | const estruturasDeRepeticoes = { 78 | mockRes6: 79 | "1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49.", 80 | mockRes8: 81 | "200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100.", 82 | }; 83 | 84 | function getRandomInt(min, max) { 85 | min = Math.ceil(min); 86 | max = Math.floor(max); 87 | return Math.floor(Math.random() * (max - min)) + min; 88 | /* https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/random */ 89 | } 90 | 91 | module.exports = { 92 | stringMock, 93 | desafiadoresMock, 94 | objetosMock, 95 | estruturasDeRepeticoes, 96 | getRandomInt 97 | }; 98 | -------------------------------------------------------------------------------- /test/estruturasDeRepeticoes.test.js: -------------------------------------------------------------------------------- 1 | const { 2 | estruturasDeRepeticoes: { mockRes6, mockRes8 }, 3 | } = require("./mocks"); 4 | /* 5 | É importada nesse arquivo tanto as funções do gabarito quanto dos desafios 6 | */ 7 | /* Gabaritos */ 8 | /* const { 9 | encode, 10 | accumulator, 11 | accumulatorThousand, 12 | repeatName, 13 | numbersDivisibleBy3, 14 | oddNumbers, 15 | findIndexOf, 16 | sortDec, 17 | includesArrays, 18 | } = require("../Desafios/Estruturas de Repetições/Gabaritos/1-9"); */ 19 | 20 | /* Exercícios */ 21 | const { 22 | encode, 23 | accumulator, 24 | accumulatorThousand, 25 | repeatName, 26 | numbersDivisibleBy3, 27 | oddNumbers, 28 | findIndexOf, 29 | sortDec, 30 | includesArrays, 31 | } = require("../Desafios/Estruturas de Repetições") 32 | 33 | describe("Desafios de Estruturas de Repetições.", () => { 34 | describe("01 - Testando a Função encode.", () => { 35 | it("Ao passar o argumento 'encode', deve retornar: '03691215'", () => { 36 | expect(encode("encode")).toBe("03691215"); 37 | }); 38 | it("Ao passar o argumento 'Trybe', deve retornar: '036912'", () => { 39 | expect(encode("Trybe")).toBe("036912"); 40 | }); 41 | }); 42 | describe("02 - Testando a Função accumulator.", () => { 43 | it("Ao passar o argumento 1, deve retornar: 1", () => { 44 | expect(accumulator(1)).toBe(1); 45 | }); 46 | it("Ao passar o argumento 2, deve retornar: 3", () => { 47 | expect(accumulator(2)).toBe(3); 48 | }); 49 | it("Ao passar o argumento 100, deve retornar: 5050", () => { 50 | expect(accumulator(100)).toBe(5050); 51 | }); 52 | }); 53 | 54 | describe("03 - Testando a Função accumulatorThousand.", () => { 55 | it("Deve retornar: 'A soma de 1 até 1000 é 500500.'", () => { 56 | expect(accumulatorThousand()).toBe("A soma de 1 até 1000 é 500500."); 57 | }); 58 | }); 59 | 60 | describe("04 - Testando a Função repeatName.", () => { 61 | it("Ao passar os argumentos 'Daniel e 1, deve retornar: 'Daniel.'", () => { 62 | expect(repeatName("Daniel", 1)).toBe("Daniel."); 63 | }); 64 | it("Ao passar os argumentos 'Fábio' e 2, deve retornar: 'Fábio, Fábio.'", () => { 65 | expect(repeatName("Fábio", 2)).toBe("Fábio, Fábio."); 66 | }); 67 | it("Ao passar os argumentos 'Zé' e 3, deve retornar: 'Zé, Zé, Zé.'", () => { 68 | expect(repeatName("Zé", 3)).toBe("Zé, Zé, Zé."); 69 | }); 70 | }); 71 | 72 | describe("05 - Testando a Função numbersDivisibleBy3.", () => { 73 | it("Ao passar os argumentos 1 e 10, deve retornar: 'Sequência muito pequena.'", () => { 74 | expect(numbersDivisibleBy3(1, 10)).toBe("Sequência muito pequena."); 75 | }); 76 | it("Ao passar os argumentos 1 e 150, deve retornar: 'Há 50 ou mais números diviseis por 3.'", () => { 77 | expect(numbersDivisibleBy3(1, 150)).toBe( 78 | "Há 50 ou mais números diviseis por 3." 79 | ); 80 | }); 81 | }); 82 | 83 | describe("06 - Testando a Função oddNumbers.", () => { 84 | it(`Deve retornar: 85 | ${mockRes6}`, () => { 86 | expect(oddNumbers()).toBe(mockRes6); 87 | }); 88 | }); 89 | 90 | describe("07 - Testando a Função findIndexOf.", () => { 91 | it("Ao passar o argumento [1, 2, 3, 4] e 1, deve retornar: 0 ", () => { 92 | expect(findIndexOf([1, 2, 3, 4], 1)).toBe(0); 93 | }); 94 | it("Ao passar o argumento [1, 2, 3, 4] e 2, deve retornar: 1 ", () => { 95 | expect(findIndexOf([1, 2, 3, 4], 2)).toBe(1); 96 | }); 97 | it("Ao passar o argumento [1, 2, 3, 4] e 4, deve retornar: 3 ", () => { 98 | expect(findIndexOf([1, 2, 3, 4], 4)).toBe(3); 99 | }); 100 | }); 101 | 102 | describe("08- Testando a Função sortDec.", () => { 103 | it(`Deve retornar: 104 | ${mockRes8}.`, () => { 105 | expect(sortDec()).toBe(mockRes8); 106 | }); 107 | }); 108 | 109 | describe("09 - Testando a Função includesArrays.", () => { 110 | it("Ao passar o argumento [] e [] deve retornar: []", () => { 111 | expect(includesArrays([], [])).toEqual([]); 112 | }); 113 | it("Ao passar o argumento [1, 2, 4, 5, 6] e [3, 9, 8, 5, 0, 2], deve retornar: [2, 5]", () => { 114 | expect(includesArrays([1, 2, 4, 5, 6], [3, 9, 8, 5, 0, 2])).toEqual([ 115 | 2, 5, 116 | ]); 117 | }); 118 | }); 119 | }); 120 | -------------------------------------------------------------------------------- /Desafios/Strings/Gabaritos/1-9.js: -------------------------------------------------------------------------------- 1 | /* 01 - Inverte nomes */ 2 | function reverseNames(fullName) { 3 | let invertName = fullName.split(" "); 4 | return invertName[1] + " " + invertName[0]; 5 | } 6 | 7 | /* 02 - Converte para numero */ 8 | function converteType(string) { 9 | let toNumber = Number(string); 10 | return toNumber; 11 | } 12 | 13 | /* 03 - Apresentação pessoal */ 14 | function personalPresentation(firstName, lastName, age) { 15 | return ( 16 | "Meu nome é " + 17 | firstName + 18 | " " + 19 | lastName + 20 | " e tenho " + 21 | age + 22 | " anos de vida." 23 | ); 24 | } 25 | 26 | /* 04 - Quatro operações matemáticas */ 27 | function mathOperations(number1, number2) { 28 | let sum = number1 + " + " + number2 + " = " + (number1 + number2) + ". "; 29 | let sub = number1 + " - " + number2 + " = " + (number1 - number2) + ". "; 30 | let mul = number1 + " x " + number2 + " = " + number1 * number2 + ". "; 31 | let div = number1 + " / " + number2 + " = " + number1 / number2 + "."; 32 | return sum + sub + mul + div; 33 | } 34 | 35 | /* 05 - Primeira e última letra */ 36 | function firstLastLetter(word) { 37 | let firstLetter = word.substr(0, 1); 38 | let lastLetter = word.substr(-1); 39 | 40 | return ( 41 | "A primeira letra é: " + 42 | firstLetter + 43 | " e a última letra é: " + 44 | lastLetter + 45 | "." 46 | ); 47 | } 48 | 49 | /* 06 - Nome do cachorro */ 50 | function dogName(snack, sweet) { 51 | let firstLetters = snack.slice(0, 3); 52 | let lastLetters = sweet.slice(-3); 53 | 54 | let dogName = firstLetters + lastLetters; 55 | 56 | return "O cachorrinho de Joana vai se chamar: " + dogName; 57 | } 58 | 59 | /* 07 - Contem "a" ? */ 60 | function includeA(word) { 61 | let newWord = word.toLowerCase(); 62 | let wordsBegin = newWord.startsWith("a"); 63 | let wordsEnd = newWord.endsWith("a"); 64 | let contain = newWord.substr(1, newWord.length - 2).includes("a"); 65 | 66 | if (wordsBegin && !wordsEnd && !contain) { 67 | return "A palavra " + word + " possui a letra 'a' apenas como primeira letra."; 68 | } 69 | if (!wordsBegin && wordsEnd && !contain) { 70 | return "A palavra " + word + " possui a letra 'a' apenas como última letra."; 71 | } 72 | 73 | if (wordsBegin && wordsEnd && !contain) { 74 | return ( 75 | "A palavra " + 76 | word + " possui a letra 'a' apenas no começo e no fim da palavra." 77 | ); 78 | } 79 | 80 | if (!wordsBegin && !wordsEnd && contain) { 81 | return ( 82 | "A palavra " + 83 | word + 84 | " possui a letra 'a', porém não é a primeira nem a última letra." 85 | ); 86 | } 87 | return "A palavra " + word + " não contém a letra 'a'."; 88 | } 89 | 90 | /* 08 - Descubra quantas letras tem */ 91 | function countLetters(string, letter) { 92 | let newString = string; 93 | newString = newString.replace(/[àáäâã]/g, "a"); 94 | newString = newString.replace(/[èéëê]/g, "e"); 95 | newString = newString.replace(/[ìíïî]/g, "i"); 96 | newString = newString.replace(/[òóöô]/g, "o"); 97 | newString = newString.replace(/[ùúüû]/g, "u"); 98 | newString = newString.toLowerCase(); 99 | 100 | let totalWords = 0; 101 | for (let index = 0; index < newString.length; index += 1) { 102 | if (newString[index] === letter) { 103 | totalWords += 1; 104 | } 105 | } 106 | return totalWords; 107 | } 108 | 109 | /* 09 - Brincando de espionagem */ 110 | function encodeMessage(string) { 111 | let newWord = ""; 112 | for (let index = 0; index < string.length; index += 1) { 113 | let word = string[index]; 114 | switch (word) { 115 | case "a": 116 | newWord += word.replace("a", "5"); 117 | break; 118 | case "e": 119 | newWord += word.replace("e", "b"); 120 | break; 121 | case "i": 122 | newWord += word.replace("i", "9"); 123 | break; 124 | case "o": 125 | newWord += word.replace("o", "p"); 126 | break; 127 | case "u": 128 | newWord += word.replace("u", "1"); 129 | break; 130 | default: 131 | newWord += word; 132 | break; 133 | } 134 | } 135 | return newWord; 136 | } 137 | 138 | module.exports = { 139 | reverseNames, 140 | converteType, 141 | personalPresentation, 142 | mathOperations, 143 | firstLastLetter, 144 | dogName, 145 | includeA, 146 | countLetters, 147 | encodeMessage, 148 | }; 149 | -------------------------------------------------------------------------------- /test/objetos.test.js: -------------------------------------------------------------------------------- 1 | /* É importada nesse arquivo tanto as funções do gabarito quanto dos desafios */ 2 | const { objetosMock : {mock4A,mock4B, mock4C }} = require('../test/mocks') 3 | /* Gabaritos */ 4 | /* const { 5 | fantasyGame, 6 | fantasyGame2, 7 | musicalScale, 8 | getOldPerson, 9 | fantasyGame3, 10 | } = require("../Desafios/Objetos/Gabaritos/1-5"); 11 | */ 12 | /* Exercícios */ 13 | const { 14 | fantasyGame, 15 | fantasyGame2, 16 | musicalScale, 17 | getOldPerson, 18 | fantasyGame3, 19 | } = require("../Desafios/Objetos"); 20 | 21 | describe("Desafios de Objetos.", () => { 22 | describe("01 - Testando a Função fantasyGame.", () => { 23 | it("Ao passar o argumento 'Mago', deve retornar: 'Mago, 5PV.'", () => { 24 | expect(fantasyGame("Mago")).toBe("Mago, 5PV."); 25 | }); 26 | it("Ao passar o argumento 'Arqueiro', deve retornar: 'Arqueiro, 10PV.'", () => { 27 | expect(fantasyGame("Arqueiro")).toBe("Arqueiro, 10PV."); 28 | }); 29 | it("Ao passar o argumento 'Guerreiro', deve retornar: Guerreiro, 15PV..", () => { 30 | expect(fantasyGame("Guerreiro")).toBe("Guerreiro, 15PV."); 31 | }); 32 | it("Ao passar o argumento 'Cavaleiro', deve retornar: 'Cavaleiro, 20PV.'", () => { 33 | expect(fantasyGame("Cavaleiro")).toBe("Cavaleiro, 20PV."); 34 | }); 35 | }); 36 | 37 | describe("02 - Testando a Função fantasyGame2", () => { 38 | it("Ao passar o argumento 'Mago', deve retornar: '5PV, Varinha.'", () => { 39 | expect(fantasyGame2("Mago")).toBe("5PV, Varinha."); 40 | }); 41 | it("Ao passar o argumento Arqueiro, deve retornar: '10PV, Arco Curto.'", () => { 42 | expect(fantasyGame2("Arqueiro")).toBe("10PV, Arco Curto."); 43 | }); 44 | it("Ao passar o argumento 'Guerreiro', deve retornar: '15PV, Espada.'", () => { 45 | expect(fantasyGame2("Guerreiro")).toBe("15PV, Espada."); 46 | }); 47 | it("Ao passar o argumento 'Cavaleiro', deve retornar: '20PV, Armadura Completa.'", () => { 48 | expect(fantasyGame2("Cavaleiro")).toBe("20PV, Armadura Completa."); 49 | }); 50 | }); 51 | 52 | describe("03 - Testando a Função musicalScale.", () => { 53 | it("Ao passar o argumento 'Dó', deve retornar: 'I'", () => { 54 | expect(musicalScale("Dó")).toBe("I"); 55 | }); 56 | it("Ao passar o argumento 'Ré', deve retornar: 'II'", () => { 57 | expect(musicalScale("Ré")).toBe("II"); 58 | }); 59 | it("Ao passar o argumento 'Mi', deve retornar: 'III'", () => { 60 | expect(musicalScale("Mi")).toBe("III"); 61 | }); 62 | it("Ao passar o argumento 'Fá', deve retornar: 'IV'", () => { 63 | expect(musicalScale("Fá")).toBe("IV"); 64 | }); 65 | it("Ao passar o argumento 'Sol', deve retornar: 'V'", () => { 66 | expect(musicalScale("Sol")).toBe("V"); 67 | }); 68 | it("Ao passar o argumento 'Lá', deve retornar: 'VI'", () => { 69 | expect(musicalScale("Lá")).toBe("VI"); 70 | }); 71 | it("Ao passar o argumento 'Si', deve retornar: 'VII'", () => { 72 | expect(musicalScale("Si")).toBe("VII"); 73 | }); 74 | }); 75 | 76 | describe("04 - Testando a Função getOldPerson.", () => { 77 | it(`Ao passar o argumento ${JSON.stringify(mock4A)}: 78 | deve retornar: 79 | 'Ramon tem a maior idade com 35 anos.'`, () => { 80 | expect(getOldPerson(mock4A)).toBe("Ramon tem a maior idade com 35 anos."); 81 | }); 82 | 83 | it(`Ao passar o argumento ${JSON.stringify(mock4B)}: 84 | deve retornar: 85 | 'José tem a maior idade com 36 anos.'`, () => { 86 | expect(getOldPerson(mock4B)).toBe("José tem a maior idade com 36 anos."); 87 | }); 88 | 89 | it(`Ao passar o argumento ${JSON.stringify(mock4C)}: 90 | deve retornar: 91 | 'Amanda tem a maior idade com 50 anos.'`, () => { 92 | expect(getOldPerson(mock4C)).toBe("Amanda tem a maior idade com 50 anos."); 93 | }); 94 | }); 95 | 96 | describe("05 - Testando a Função fantasyGame3.", () => { 97 | it("Ao passar os argumentos 'Mago' e 5, deve retornar: 'Mago, nível 5: 13PV, Varinha.'", () => { 98 | expect(fantasyGame3("Mago", 5)).toBe("Mago, nível 5: 13PV, Varinha."); 99 | }); 100 | it("Ao passar os argumentos 'Arqueiro' e 3, deve retornar: 'Arqueiro, nível 3: 16PV, Arco Curto.'", () => { 101 | expect(fantasyGame3("Arqueiro", 3)).toBe("Arqueiro, nível 3: 16PV, Arco Curto."); 102 | }); 103 | it("Ao passar os argumentos 'Guerreiro' e 7, deve retornar: 'Guerreiro, nível 7: 39PV, Espada.'", () => { 104 | expect(fantasyGame3("Guerreiro", 7)).toBe("Guerreiro, nível 7: 39PV, Espada."); 105 | }); 106 | it("Ao passar os argumentos 'Guerreiro' e 2 , deve retornar: 'Cavaleiro, nível 2: 25PV, Armadura Completa.'", () => { 107 | expect(fantasyGame3("Cavaleiro", 2)).toBe("Cavaleiro, nível 2: 25PV, Armadura Completa."); 108 | }); 109 | }); 110 | }); 111 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/Gabaritos/1-10.js: -------------------------------------------------------------------------------- 1 | /* 01 - Lanchonete da Trybe */ 2 | function optionsMenu(number) { 3 | switch (number) { 4 | case 1: 5 | return "1 - Trybe Lanche Feliz"; 6 | case 2: 7 | return "2 - McTrybe"; 8 | case 3: 9 | return "3 - TrybeWooper"; 10 | case 4: 11 | return "4 - X-Trybe"; 12 | case 5: 13 | return "5 - Triplo Trybe com JS"; 14 | default: 15 | return "Não temos esta opção ainda :("; 16 | } 17 | } 18 | 19 | /* 02 - Switch Case */ 20 | function studentSituation(studentNote) { 21 | if (studentNote <= 10) { 22 | return "PÉSSIMO"; 23 | } else if (studentNote >= 11 && studentNote <= 30) { 24 | return "RUIM"; 25 | } else if (studentNote >= 31 && studentNote <= 50) { 26 | return "REGULAR"; 27 | } else if (studentNote >= 51 && studentNote <= 70) { 28 | return "MEDIANO"; 29 | } else if (studentNote >= 71 && studentNote <= 90) { 30 | return "ÓTIMO"; 31 | } else { 32 | return "EXCELENTE"; 33 | } 34 | } 35 | 36 | /* 03 - Mostre a classe do aventureiro */ 37 | function findAdventurous(adventurous) { 38 | switch (adventurous) { 39 | case "Tunico": 40 | return "Mestre dos Magos"; 41 | 42 | case "Cremoso": 43 | return "Cavaleiro Negro"; 44 | 45 | case "Gordinho": 46 | return "Pirata"; 47 | 48 | case "Lobo Solitário": 49 | return "Samurai"; 50 | 51 | case "Ousado": 52 | return "Mago"; 53 | 54 | case "Anjo Loiro": 55 | return "Clérigo"; 56 | 57 | default: 58 | return "Aventureiro não encontrado"; 59 | } 60 | } 61 | 62 | /* 04 - Dinossauro poliglota */ 63 | function polyglotDinosaur(command) { 64 | switch (command) { 65 | case "esquerda": 66 | return "english"; 67 | case "direita": 68 | return "français"; 69 | case "nenhuma": 70 | return "português"; 71 | case "as duas": 72 | return "Ai eu caiu, né!!"; 73 | default: 74 | return "Comando desconhecido."; 75 | } 76 | } 77 | 78 | /* 05 - Robô amigo */ 79 | function robotFriend(mon, dad, me, brother, sister) { 80 | if (mon || dad || me || (brother && sister)) { 81 | return "Things I do for love..."; 82 | } 83 | return "Not today."; 84 | } 85 | 86 | /* 06 - Taxa Metabólica Basal */ 87 | function basalMetabolicRate(age, sex, weight, height) { 88 | let metabolicRate; 89 | 90 | if (sex === "M") { 91 | metabolicRate = height * 6.25 + weight * 9.99 - age * 4.92 + 5; 92 | } 93 | 94 | if (sex === "F") { 95 | metabolicRate = height * 6.25 + weight * 9.99 - age * 4.92 - 161; 96 | } 97 | 98 | return `A taxa metabólica basal é: ${metabolicRate} Kcal.`; 99 | } 100 | 101 | /* 07 - Maior ou menor de idade */ 102 | function legalAge(age) { 103 | let response = ""; 104 | if (age >= 18) { 105 | response = "A pessoa é maior de idade."; 106 | } else { 107 | response = "A pessoa é menor de idade."; 108 | } 109 | return response; 110 | 111 | /* Exemplo com ternário 112 | return age >=18 ? "A pessoa é maior de idade." :"A pessoa é menor de idade."; 113 | */ 114 | } 115 | 116 | /* 08 - Descubra a idade mínima */ 117 | function findYoungerPerson(marinaAge, silviaAge, izaAge) { 118 | if (marinaAge < silviaAge && marinaAge < izaAge) { 119 | return `Marina é a mais jovem e possui ${marinaAge} anos de idade.`; 120 | } else if (silviaAge < marinaAge && silviaAge < izaAge) { 121 | return `Silvia é a mais jovem e possui ${silviaAge} anos de idade.`; 122 | } else { 123 | return `Iza é a mais jovem e possui ${izaAge} anos de idade.`; 124 | } 125 | } 126 | 127 | /* 09 - Aprovação nos projetos */ 128 | function evaluateProject(obj) { 129 | let { rec, reqs, totalReqs, completed } = obj; 130 | 131 | let approved = { 132 | notRec: 0.8, 133 | rec: 0.9, 134 | }; 135 | 136 | let mensagem = { 137 | approved: "Parabéns, você está aprovado(a)!", 138 | notApproved: "Você ainda precisa entregar mais requisitos ;)", 139 | }; 140 | 141 | if (rec) { 142 | let isOk = completed / totalReqs >= approved.rec; 143 | if (isOk) return mensagem.approved; 144 | return mensagem.notApproved; 145 | } else { 146 | let isOk = completed / reqs >= approved.notRec; 147 | if (isOk) return mensagem.approved; 148 | return mensagem.notApproved; 149 | } 150 | } 151 | 152 | /* 10 - Entrega do drone */ 153 | function droneDelivery(heightBox, widthBox, depthBox, heightWindow, widthWindow, depthWindow) { 154 | if ((heightBox < heightWindow && widthBox < widthWindow) && depthBox < depthWindow) { 155 | return `É possível realizar a entrega.`; 156 | } else { 157 | return `Não é possível realizar a entrega.`; 158 | } 159 | } 160 | 161 | module.exports = { 162 | optionsMenu, 163 | studentSituation, 164 | findAdventurous, 165 | polyglotDinosaur, 166 | robotFriend, 167 | basalMetabolicRate, 168 | legalAge, 169 | findYoungerPerson, 170 | evaluateProject, 171 | droneDelivery, 172 | } 173 | -------------------------------------------------------------------------------- /test/destructuringEHofs.test.js: -------------------------------------------------------------------------------- 1 | const { 2 | getBandsInformation, 3 | getBestAlbuns, 4 | getBandsName, 5 | usaFilter, 6 | rockFilter, 7 | highestRatingFilter, 8 | } = require("../Desafios/Destructuring e Hofs/"); 9 | 10 | describe("Desafios de Destructuring e HOFs.", () => { 11 | describe("01 - Testando a Função getBandsInformation.", () => { 12 | it("Retorne true caso o retorno da função seja um array", () => { 13 | expect(Array.isArray(getBandsInformation())).toBeTruthy(); 14 | }); 15 | it("O retorno da função deve ser o array esperado", () => { 16 | const expectedArray = [ 17 | { 18 | bandName: 'Radiohead', 19 | bestAlbuns: [ 20 | { 21 | name: "In Rainbows", 22 | rate: 100 23 | }, 24 | { 25 | name: "Kid A", 26 | rate: 95 27 | }, 28 | { 29 | name: "OK Computer", 30 | rate: 90 31 | }, 32 | { 33 | name: "Pablo Honey", 34 | rate: 80 35 | } 36 | ], 37 | genre: 'Rock', 38 | country: 'England' 39 | }, 40 | { 41 | bandName: 'Avenged Sevenfold', 42 | bestAlbuns: [ 43 | { 44 | name: "City of Evil", 45 | rate: 99 46 | }, 47 | { 48 | name: "Avenged Sevenfold", 49 | rate: 98 50 | }, 51 | { 52 | name: "Sounding the Seventh Trumpet", 53 | rate: 95 54 | }, 55 | { 56 | name: "Diamonds in the Rough", 57 | rate: 80 58 | } 59 | ], 60 | genre: 'Hard Rock', 61 | country: 'United States' 62 | } 63 | ] 64 | expect(getBandsInformation()).toEqual(expectedArray); 65 | }); 66 | }); 67 | 68 | describe("02 - Testando a Função getBestAlbuns.", () => { 69 | it("O retorno da função deve ser uma string", () => { 70 | expect(typeof getBestAlbuns()).toBe('string'); 71 | }); 72 | it("O retorno da função deve ser a tring esperado", () => { 73 | const expectedString = 'Os melhores álbuns do Radiohead: In Rainbows,Kid A,OK Computer,Pablo Honey' 74 | expect(getBestAlbuns()).toEqual(expectedString); 75 | }); 76 | }); 77 | 78 | describe("03 - Testando a Função getBandsName.", () => { 79 | it("Retorne true caso o retorno da função seja um array", () => { 80 | expect(Array.isArray(getBandsName())).toBeTruthy(); 81 | }); 82 | it("O retorno da função deve ser o array esperado", () => { 83 | const expectedArray = [ 84 | 'Radiohead', 85 | 'Avenged Sevenfold', 86 | 'Arctic Monkeys', 87 | 'Pink Floyd', 88 | 'Foo Fighters', 89 | 'Red Hot Chili Peppers' 90 | ] 91 | expect(getBandsName()).toEqual(expectedArray); 92 | }); 93 | }); 94 | 95 | describe("04 - Testando a Função usaFilter.", () => { 96 | it("O retorno da função deve ser um array", () => { 97 | expect(typeof usaFilter()).toBe('object'); 98 | }); 99 | it("O retorno da função deve ser o array esperado", () => { 100 | const expectedArray = [ 101 | 'Radiohead', 102 | 'Avenged Sevenfold', 103 | 'Arctic Monkeys', 104 | 'Pink Floyd', 105 | 'Foo Fighters', 106 | 'Red Hot Chili Peppers' 107 | ] 108 | expect(usaFilter()).toEqual(expectedArray); 109 | }); 110 | }); 111 | 112 | describe("05 - Testando a Função rockFilter.", () => { 113 | it("O retorno da função deve ser um array", () => { 114 | expect(Array.isArray(rockFilter())).toBeTruthy(); 115 | }); 116 | it("O retorno da função deve ser o array com o nome de todas as bandas", () => { 117 | const expectedArray = [ 118 | 'Radiohead', 119 | 'Avenged Sevenfold', 120 | 'Arctic Monkeys', 121 | 'Pink Floyd', 122 | 'Foo Fighters', 123 | 'Red Hot Chili Peppers' 124 | ] 125 | expect(rockFilter()).toEqual(expectedArray); 126 | }); 127 | }); 128 | 129 | describe("06 - Testando a Função highestRatingFilter.", () => { 130 | it("Retorne true caso o retorno da função seja um array", () => { 131 | expect(Array.isArray(highestRatingFilter())).toBeTruthy(); 132 | }); 133 | it("O retorno da função deve ser o array esperado", () => { 134 | const expectedArray = [ 135 | { name: 'In Rainbows', rate: 100 }, 136 | { name: 'Humbug', rate: 100 }, 137 | { name: 'Wish You Were Here', rate: 100 }, 138 | { name: 'Dark Side of the Moon', rate: 100 }, 139 | { name: 'Animals', rate: 100 }, 140 | { name: 'Wasting Light', rate: 100 }, 141 | { name: 'Stadium Arcadium', rate: 100 } 142 | ] 143 | 144 | expect(highestRatingFilter()).toEqual(expectedArray); 145 | }); 146 | }); 147 | }); 148 | 149 | -------------------------------------------------------------------------------- /Desafios/Estruturas Condicionais/Gabaritos/11-18.js: -------------------------------------------------------------------------------- 1 | /* 11 - Triplica vogais */ 2 | function triVowels(word) { 3 | let finalWord = ""; 4 | for (let char of word) { 5 | switch (char) { 6 | case "a": 7 | case "e": 8 | case "i": 9 | case "o": 10 | case "u": 11 | finalWord += char.repeat(3); 12 | break; 13 | default: 14 | finalWord += char; 15 | } 16 | } 17 | return finalWord; 18 | } 19 | 20 | /* 12 - IMC */ 21 | function IMC(weight, height) { 22 | let imc = Number((weight / (height * height)).toFixed(1)); 23 | 24 | let result; 25 | 26 | if (imc < 18.5) { 27 | result = "Magreza"; 28 | } else if (imc < 24.9) { 29 | result = "Normal"; 30 | } else if (imc < 30) { 31 | result = "Sobrepeso"; 32 | } else { 33 | result = "Obesidade"; 34 | } 35 | 36 | return "Seu IMC é: " + imc + " kg/m2." + " O Resultado foi: " + result; 37 | } 38 | 39 | /* 13 - Pontos no Xadrez */ 40 | function chessRating(ratingPlayOne,ratingPlayTwo) { 41 | let winner = 1; 42 | 43 | let difference = Math.abs(ratingPlayOne -ratingPlayTwo); 44 | 45 | let smallDiff = 10; 46 | let bigDiff = 20; 47 | 48 | if (difference > 200) { 49 | if (winner === 1) { 50 | ratingPlayOne += smallDiff; 51 | ratingPlayTwo -= smallDiff; 52 | } else { 53 | ratingPlayOne -= smallDiff; 54 | ratingPlayTwo += smallDiff; 55 | } 56 | } else if (winner === 1) { 57 | ratingPlayOne += bigDiff; 58 | ratingPlayTwo -= bigDiff; 59 | } else { 60 | ratingPlayOne -= bigDiff; 61 | ratingPlayTwo += bigDiff; 62 | } 63 | 64 | return `Enxadrista1: ${ratingPlayOne} pontos. Enxadrista2: ${ratingPlayTwo} pontos.`; 65 | } 66 | 67 | /* 14 - Caixa eletrônico */ 68 | function ATM(balance, withdrew) { 69 | if (withdrew === 0 || typeof withdrew != "number") { 70 | return "Valor de saldo inválido"; 71 | } else if (withdrew > balance) { 72 | return "Saldo insuficiente"; 73 | } else if (withdrew % 10 != 0) { 74 | return "Valor inválido para as notas disponíveis: R$10, R$50, R$100"; 75 | } else { 76 | balance = balance - withdrew; 77 | return `Saque efetuado! Novo saldo: R$${balance}`; 78 | } 79 | } 80 | 81 | /* 15 - Pedra,papel e tesoura */ 82 | function rockPaperScissors(signPerson1, signPerson2) { 83 | if (signPerson1 == "paper" && signPerson2 == "rock") { 84 | return "Player 1 won"; 85 | } else if (signPerson1 == "rock" && signPerson2 == "scissors") { 86 | return "Player 1 won"; 87 | } else if (signPerson1 == "scissors" && signPerson2 == "paper") { 88 | return "Player 1 won"; 89 | } else if (signPerson1 == signPerson2) { 90 | return "A Ties"; 91 | } else { 92 | return "Player 2 won"; 93 | } 94 | } 95 | 96 | /* 16 - Imprima a idade em ordem crescente */ 97 | function sortAgeAsc(mariaAge, silviaAge, izaAge) { 98 | if (mariaAge <= silviaAge && silviaAge <= izaAge) { 99 | return `${mariaAge}, ${silviaAge}, ${izaAge}`; 100 | } else { 101 | if (mariaAge <= izaAge && izaAge <= silviaAge) { 102 | return `${mariaAge}, ${izaAge}${silviaAge}`; 103 | } else { 104 | if (silviaAge <= mariaAge && mariaAge <= izaAge) { 105 | return `${silviaAge}, ${mariaAge}, ${izaAge}`; 106 | } else { 107 | if (silviaAge <= izaAge && izaAge <= mariaAge) { 108 | return `${silviaAge}, ${izaAge}, ${mariaAge}`; 109 | } else { 110 | if (izaAge <= mariaAge && mariaAge <= silviaAge) { 111 | return `${izaAge}, ${mariaAge}, ${silviaAge}`; 112 | } else { 113 | if (mariaAge == silviaAge && silviaAge == izaAge) { 114 | return `${mariaAge}, ${silviaAge}, ${izaAge}`; 115 | } else { 116 | return `${izaAge}, ${silviaAge}, ${mariaAge}`; 117 | } 118 | } 119 | } 120 | } 121 | } 122 | } 123 | } 124 | 125 | // 17 - Jogo do par ou ímpar 126 | function oddOreEven(lucioFingers, anaFingers, even) { 127 | let result = (lucioFingers + anaFingers) % 2; 128 | 129 | if (result === 0 && even === 1) { 130 | return "Lúcio venceu"; 131 | } else if (result === 0 && even === 0) { 132 | return "Ana venceu"; 133 | } else if (result !== 0 && even === 1) { 134 | return "Ana venceu"; 135 | } else { 136 | return "Lúcio venceu"; 137 | } 138 | } 139 | 140 | /* 18 - Jogo de cartas */ 141 | function cardsGame(maraCard1, maraCard2, saraCard1, saraCard2) { 142 | let maraScore = 0; 143 | let saraScore= 0; 144 | 145 | function calc(a, b) { 146 | if (a === b) return (a + b) * 2; 147 | else if (a - b === 1 || a - b === -1) return (a + b) * 3; 148 | else return a + b; 149 | } 150 | 151 | maraScore = calc(maraCard1, maraCard2); 152 | saraScore = calc(saraCard1, saraCard2); 153 | 154 | if (maraScore === saraScore) return `O jogo empatou`; 155 | return maraScore > saraScore 156 | ? `Mara venceu com ${maraScore} pontos` 157 | : `Sara venceu com ${saraScore} pontos`; 158 | } 159 | 160 | module.exports = { 161 | triVowels, 162 | IMC, 163 | chessRating, 164 | ATM, 165 | rockPaperScissors, 166 | sortAgeAsc, 167 | oddOreEven, 168 | cardsGame, 169 | } 170 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Lógica de Programação 2 | "Eu acho que todas as pessoas neste país deveriam aprender como programar um computador porque isto te ensina como pensar." 3 | Steve Jobs – Inventor 4 | 5 | Lógica de Programação é a forma como nós, Pessoas Desenvolvedoras, pensamos e escrevemos algoritmos para resoluções de problemas ou execuções de tarefas processadas por uma máquina. 6 | 7 | Nesse [artigo](https://blog.betrybe.com/tecnologia/logica-de-programacao/) de nosso blog, você poderá ler mais acerca da importância da Lógica de Programação e como aprendê-la. 8 | 9 | # Desafios 10 | Este repositório tem por finalidade apresentar alguns exercícios de Lógica de Programação e materiais de estudo complementares sobre os temas que são abordados. 11 | 12 | Você verá que alguns links estão em inglês, mas disponibilizamos no final da página um tutorial para te ajudar a traduzir os sites. 13 | 14 | Dentro da pasta raiz do projeto, temos a pasta "tests". Ela contém os testes unitários correspondentes a cada bloco de desafios, por exemplo: os testes unitários do bloco Arrays estão no arquivo "arrays.test.js.", do bloco Desafiadores estão no "desafiadores.test.js.". 15 | 16 | Para executar os testes de todos os blocos, abra o terminal dentro da pasta raiz do projeto e execute o comando: ```"npm install"``` para instalar as dependências do projeto. 17 | 18 | Em seguida execute o comando para rodar todos os testes: ```"npm test"```. 19 | 20 | Caso você queira executar apenas um bloco específico, basta após o comando ```"npm test"``` escrever o nome do arquivo da pasta "test" que deseja executar, por exemplo: se deseja verificar apenas os testes do bloco de Strings, então vá até o terminal e execute o comando: ```"npm test strings.test.js"```. 21 | 22 | Atenção, nos exercícios, não troque os nomes das funções ou as retire do module.exports. 23 | 24 | Confira abaixo os links para estudo: 25 | ## Gerais 26 | * [Blog Trybe](https://blog.betrybe.com/javascript/) 27 | * [Laços e iterações MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Loops_and_iteration) 28 | 29 | ### Operadores 30 | * [Operadores de comparação MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_operators) 31 | * [Operadores de comparação W3](https://www.w3schools.com/js/js_comparisons.asp) 32 | 33 | ### Métodos de Strings 34 | * [String MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String) 35 | * [Métodos úteis de string MDN](https://developer.mozilla.org/pt-BR/docs/Learn/JavaScript/First_steps/Useful_string_methods) 36 | * [JavaScript String Methods W3](https://www.w3schools.com/js/js_string_methods.asp) 37 | * [JavaScript String Search W3](https://www.w3schools.com/js/js_string_search.asp) 38 | 39 | ### Método de números 40 | * [Números MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Number) 41 | * [Math MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math) 42 | * [JavaScript Number Methods W3](https://www.w3schools.com/js/js_number_methods.asp) 43 | * [JavaScript Math Reference W3](https://www.w3schools.com/jsref/jsref_obj_math.asp) 44 | * [JavaScript Math Object W3](https://www.w3schools.com/js/js_math.asp) 45 | 46 | ### Laços de repetição 47 | 48 | #### For 49 | * [For MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/for) 50 | * [For...in MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/for...in) 51 | * [For...of](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/for...of) 52 | * [JavaScript For Loop W3](https://www.w3schools.com/js/js_loop_for.asp) 53 | * [JavaScript For In W3](https://www.w3schools.com/js/js_loop_forin.asp) 54 | * [JavaScript For Of W3](https://www.w3schools.com/js/js_loop_forof.asp) 55 | 56 | #### While 57 | * [While MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/while) 58 | * [JavaScript While Loop W3](https://www.w3schools.com/js/js_loop_while.asp) 59 | 60 | ### Condicionais 61 | * [Operador Condicional Ternário MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) 62 | * [Tomando decisões no seu código — condicionais MDN](https://developer.mozilla.org/pt-BR/docs/Learn/JavaScript/Building_blocks/conditionals) 63 | 64 | #### Switch 65 | * [Switch MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/switch) 66 | * [JavaScript Switch Statement W3](https://www.w3schools.com/js/js_switch.asp) 67 | 68 | #### If/else 69 | * [If...else MDN](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/if...else) 70 | * [JavaScript if else and else if W3](https://www.w3schools.com/js/js_if_else.asp) 71 | * [JavaScript if/else Statement W3](https://www.w3schools.com/jsref/jsref_if.asp) 72 | 73 | 74 | ### Tutorial de como traduzir o W3 schools 75 | 76 | Quando o site for aberto, ao lado direito superior vai ter um “botão” com o formato do planeta : 77 |
78 | 79 | 80 | Clicando nele uma barra de busca vai ser aberta, onde devemos escolher em qual idionma queremos ver o site: 81 |
82 | 83 | 84 | Agora é só escolher o idioma: 85 |
86 | 87 | -------------------------------------------------------------------------------- /Desafios/Desafiadores/Gabaritos/1-10.js: -------------------------------------------------------------------------------- 1 | /* 01 - Verificar se pessoa tem idade para dar entrada na CNH. */ 2 | function cnhProcess(name, birthYear) { 3 | let currentYear = new Date().getFullYear(); 4 | 5 | let age = currentYear - birthYear; 6 | 7 | let check = ""; 8 | 9 | if (age >= 18) { 10 | check = "pode"; 11 | } else { 12 | check = "não pode"; 13 | } 14 | return `${name} tem ${age} anos de idade e ${check} iniciar o processo.`; 15 | } 16 | 17 | /* 02 - Calcula a raiz quadrada de um número */ 18 | function squareRoot(number) { 19 | const sqrt = Math.sqrt(number); 20 | 21 | if (number === 0 || typeof number != "number") { 22 | return "Número inválido."; 23 | } else if (sqrt === Math.floor(sqrt)) { 24 | return `A raiz quadrada de ${number} é: ${sqrt}.`; 25 | } else { 26 | return `Não existe raiz exata para o número ${number}.`; 27 | } 28 | } 29 | 30 | /* 03 - Array de notas musicais */ 31 | function musicalNotes(notes) { 32 | let firstAllDegrees = { 33 | Dó: "I", 34 | Ré: "II", 35 | Mi: "III", 36 | Fá: "IV", 37 | Sol: "V", 38 | Lá: "VI", 39 | Si: "VII", 40 | }; 41 | 42 | let firstMusicDegrees = []; 43 | 44 | for (let index = 0; index < notes.length; index += 1) { 45 | let thisNote = notes[index]; 46 | let thisDegree = firstAllDegrees[thisNote]; 47 | 48 | firstMusicDegrees.push(thisDegree); 49 | } 50 | 51 | return firstMusicDegrees; 52 | } 53 | 54 | /* 04 - Array de notas musicais - 2 */ 55 | function musicalNotes2(notes) { 56 | let allNotesDetails = { 57 | Dó: { 58 | degree: "I", 59 | third: "Maior", 60 | scale: "Jônia", 61 | }, 62 | Ré: { 63 | degree: "II", 64 | third: "Menor", 65 | scale: "Dórica", 66 | }, 67 | Mi: { 68 | degree: "III", 69 | third: "Menor", 70 | scale: "Frígia", 71 | }, 72 | Fá: { 73 | degree: "IV", 74 | third: "Maior", 75 | scale: "Lídia", 76 | }, 77 | Sol: { 78 | degree: "V", 79 | third: "Maior", 80 | scale: "Mixolídia", 81 | }, 82 | Lá: { 83 | degree: "VI", 84 | third: "Maior", 85 | scale: "Eólia", 86 | }, 87 | Si: { 88 | degree: "VII", 89 | third: "Maior", 90 | scale: "Lócria", 91 | }, 92 | }; 93 | 94 | let secondMusicNotesDetails = []; 95 | 96 | for (let index = 0; index < notes.length; index += 1) { 97 | let thisNote = notes[index]; 98 | let thisDetails = allNotesDetails[thisNote]; 99 | 100 | secondMusicNotesDetails.push(thisDetails); 101 | } 102 | 103 | return secondMusicNotesDetails; 104 | } 105 | 106 | /* 05 - Varinhas mágicas */ 107 | function magicWand(wizard, wand) { 108 | let wizardsWands = { 109 | "Harry Potter": "Azevinho e Pena de Fênix", 110 | "Rony Weasley": "Salgueiro e Pelo de Unicórnio", 111 | "Hermione Granger": "Videira e Fibra de Dragão", 112 | "Alvo Dumbledore": "Salgueiro e Pelo de Testrálio", 113 | "Belatriz Lestrange": "Nogueira e Fibra de Dragão", 114 | }; 115 | 116 | if (wizardsWands[wizard] === wand) { 117 | return "Curioso... muito curioso..."; 118 | } else { 119 | return "Não, não! Decididamente, não!"; 120 | } 121 | } 122 | 123 | /* 06 - Analise de preços da lista de compras */ 124 | function productAnalysis(products) { 125 | let maxPrice = products[0].price; 126 | let maxProduct = ""; 127 | 128 | let total = 0; 129 | 130 | for (let index = 0; index < products.length; index += 1) { 131 | total += products[index].price; 132 | if (products[index].price > maxPrice) { 133 | maxPrice = products[index].price; 134 | maxProduct = products[index].name; 135 | } 136 | } 137 | 138 | let averagePrice = (total / products.length).toFixed(2); 139 | 140 | return `O produto mais caro é ${maxProduct} e custa: R$ ${maxPrice}, a média de preços dos produtos é de: R$${averagePrice}.`; 141 | } 142 | 143 | /* 07 - Calcule a média dos graus Celsius e Fahrenheit */ 144 | function averageTemperature(anualRegister) { 145 | let total = 0; 146 | for (let index = 0; index < anualRegister.length; index += 1) { 147 | total += anualRegister[index]; 148 | } 149 | let average = total / anualRegister.length; 150 | 151 | const averageConverted = ((5 * (average - 32)) / 9).toFixed(2); 152 | 153 | return ( 154 | "A média anual de temperatura em graus Celsius é " + averageConverted + "." 155 | ); 156 | } 157 | 158 | /* 08 - O número de empates na Copa das galáxias */ 159 | function numberTies(matches, scores) { 160 | const sumPoints = Object.values(scores).reduce((sum, number) => sum + number); 161 | const winPoints = 3; 162 | return Math.abs(winPoints * matches - sumPoints); 163 | } 164 | 165 | /* 09 - Programas de TV */ 166 | function viewerTvShows(dataViewer) { 167 | let { age, country, likeSports } = dataViewer; 168 | 169 | let message = { 170 | ufc: "UFC.", 171 | simpsons: "The Simpsons.", 172 | madagascar: "The Penguins of Madagascar.", 173 | fishing: "Sport Fishing.", 174 | notFound: "Não foi possível dizer o que ela deve assistir.", 175 | }; 176 | 177 | let checkCountry = { 178 | brasil: country.toUpperCase() === "BRASIL", 179 | chile: country.toUpperCase() === "CHILE", 180 | }; 181 | 182 | if (age >= 16 && checkCountry.brasil) { 183 | if (likeSports) return message.ufc; 184 | return message.simpsons; 185 | } 186 | 187 | if (age < 16) { 188 | if (checkCountry.chile && !likeSports) return message.madagascar; 189 | if (!checkCountry.chile && likeSports) return message.fishing; 190 | } 191 | 192 | return message.notFound; 193 | } 194 | 195 | /* 10 - Nega Números */ 196 | function negateNumbers(numbers) { 197 | let newArr = []; 198 | for (let index = 0; index < numbers.length; index++) { 199 | newArr.push(numbers[index] * -1); 200 | } 201 | return newArr; 202 | } 203 | module.exports = { 204 | cnhProcess, 205 | squareRoot, 206 | musicalNotes, 207 | musicalNotes2, 208 | magicWand, 209 | productAnalysis, 210 | averageTemperature, 211 | numberTies, 212 | viewerTvShows, 213 | negateNumbers, 214 | }; 215 | -------------------------------------------------------------------------------- /test/strings.test.js: -------------------------------------------------------------------------------- 1 | const { 2 | stringMock: { test9, resp9 }, 3 | } = require("./mocks"); 4 | /* Gabaritos */ 5 | /* const { 6 | reverseNames, 7 | converteType, 8 | personalPresentation, 9 | mathOperations, 10 | firstLastLetter, 11 | dogName, 12 | includeA, 13 | countLetters, 14 | encodeMessage, 15 | } = require("../Desafios/Strings/Gabaritos/1-9"); 16 | telephoneFormat = require("../Desafios/Strings/Gabaritos/10"); 17 | */ 18 | 19 | const { 20 | reverseNames, 21 | converteType, 22 | personalPresentation, 23 | mathOperations, 24 | firstLastLetter, 25 | dogName, 26 | includeA, 27 | countLetters, 28 | encodeMessage, 29 | telephoneFormat, 30 | } = require("../Desafios/Strings"); 31 | 32 | describe("Desafios de Strings.", () => { 33 | describe("01 - Testando a Função reverseNames .", () => { 34 | it("Ao passar o argumento 'Caio Lewis', deve retornar: 'Lewis Caio'", () => { 35 | expect(reverseNames("Caio Lewis")).toBe("Lewis Caio"); 36 | }); 37 | }); 38 | 39 | describe("02 - Testando a Função converteType.", () => { 40 | it("Ao passar o argumento '1', deve retornar: 1", () => { 41 | expect(converteType("1")).toBe(1); 42 | }); 43 | }); 44 | 45 | describe("03 - Testando a Função personalPresentation.", () => { 46 | it(`Ao passar o argumento 'Márcio Daniel', deve retornar: 47 | 'Meu nome é Márcio Daniel e tenho 35 anos de vida.'`, () => { 48 | expect(personalPresentation("Márcio", "Daniel", 35)).toBe( 49 | "Meu nome é Márcio Daniel e tenho 35 anos de vida." 50 | ); 51 | }); 52 | }); 53 | 54 | describe("04 - Testando a Função mathOperations.", () => { 55 | it(`Ao passar os argumento 1 e 1, deve retornar: 56 | '1 + 1 = 2. 1 - 1 = 0. 1 x 1 = 1. 1 / 1 = 1.'`, () => { 57 | expect(mathOperations(1, 1)).toBe( 58 | "1 + 1 = 2. 1 - 1 = 0. 1 x 1 = 1. 1 / 1 = 1." 59 | ); 60 | }); 61 | }); 62 | 63 | describe("05 - Testando a Função firstLastLetter.", () => { 64 | it(`Ao passar o argumento 'Junior', deve retornar: 65 | 'A primeira letra é: J e a última letra é: r.'`, () => { 66 | expect(firstLastLetter("Junior")).toBe( 67 | "A primeira letra é: J e a última letra é: r." 68 | ); 69 | }); 70 | }); 71 | 72 | describe("06 - Testando a Função dogName.", () => { 73 | it(`Ao passar os argumento 'Chips' e 'Brigadeiro', deve retornar: 74 | 'O cachorrinho de Joana vai se chamar: Chiiro'`, () => { 75 | expect(dogName("Chips", "Brigadeiro")).toBe( 76 | "O cachorrinho de Joana vai se chamar: Chiiro" 77 | ); 78 | }); 79 | }); 80 | 81 | describe("07 - Testando a Função includeA.", () => { 82 | it(`Ao passar o argumento 'Coragem', deve retornar: 83 | 'A palavra Coragem possui a letra 'a', porém não é a primeira nem a última letra.'`, () => { 84 | expect(includeA("Coragem")).toBe( 85 | "A palavra Coragem possui a letra 'a', porém não é a primeira nem a última letra." 86 | ); 87 | }); 88 | it(`Ao passar o argumento 'ana', deve retornar: 89 | ''`, () => { 90 | expect(includeA("ana")).toBe( 91 | "A palavra ana possui a letra 'a' apenas no começo e no fim da palavra." 92 | ); 93 | }); 94 | it(`Ao passar o argumento 'Amém', deve retornar: 95 | 'A palavra Amém possui a letra 'a' apenas como primeira letra.'`, () => { 96 | expect(includeA("Amém")).toBe( 97 | "A palavra Amém possui a letra 'a' apenas como primeira letra." 98 | ); 99 | }); 100 | it(`Ao passar o argumento 'Lua', deve retornar: 101 | 'A palavra Lua possui a letra 'a' apenas como última letra.'`, () => { 102 | expect(includeA("Lua")).toBe( 103 | "A palavra Lua possui a letra 'a' apenas como última letra." 104 | ); 105 | }); 106 | it(`Ao passar o argumento 'Esquivo', deve retornar: 107 | 'A palavra esquivo não contém a letra 'a'.'`, () => { 108 | expect(includeA("Esquivo")).toBe( 109 | "A palavra Esquivo não contém a letra 'a'." 110 | ); 111 | }); 112 | }); 113 | 114 | describe("08 - Testando a Função countLetters.", () => { 115 | it("Ao passar o argumento 'Abacate', deve retornar: 3", () => { 116 | expect(countLetters("Abacate", "a")).toBe(3); 117 | }); 118 | it("Ao passar o argumento 'Ando de vagar porque já tive pressa', deve retornar: 5", () => { 119 | expect(countLetters("Ando de vagar porque já tive pressa", "a")).toBe(5); 120 | }); 121 | it("Ao passar o argumento 'àáäâã', deve retornar: 5", () => { 122 | expect(countLetters("àáäâã", "a")).toBe(5); 123 | }); 124 | it("Ao passar o argumento 'èéëê', deve retornar: 4", () => { 125 | expect(countLetters("èéëê", "e")).toBe(4); 126 | }); 127 | it("Ao passar o argumento 'ìíïî', deve retornar: 4", () => { 128 | expect(countLetters("ìíïî", "i")).toBe(4); 129 | }); 130 | it("Ao passar o argumento 'òóöô', deve retornar: 4", () => { 131 | expect(countLetters("òóöô", "o")).toBe(4); 132 | }); 133 | it("Ao passar o argumento 'ùúüû', deve retornar: 4", () => { 134 | expect(countLetters("ùúüû", "u")).toBe(4); 135 | }); 136 | }); 137 | 138 | describe("09 - Testando a Função encodeMessage.", () => { 139 | it("Ao passar o argumento 'aeiou', deve retornar: '5b9p1'", () => { 140 | expect(encodeMessage("aeiou")).toBe("5b9p1"); 141 | }); 142 | it("Verifica o retorno ao passar o trecho de uma música.", () => { 143 | expect(encodeMessage(test9)).toBe(resp9); 144 | }); 145 | }); 146 | 147 | describe("10 - Testando a Função telephoneFormat.", () => { 148 | it("Ao passar o argumento '11 97878-7878', deve retornar: '(11) 9 7878-7878'", () => { 149 | expect(telephoneFormat("11 97878-7878")).toBe("(11) 9 7878-7878"); 150 | }); 151 | it("Ao passar o argumento '(11)78787878', deve retornar: '(11) 7878-7878'", () => { 152 | expect(telephoneFormat("(11)7878-7878")).toBe("(11) 7878-7878"); 153 | }); 154 | it("Ao passar o argumento 1178787878, deve retornar: '(11) 7878-7878'", () => { 155 | expect(telephoneFormat(1178787878)).toBe("(11) 7878-7878"); 156 | }); 157 | it("Ao passar um argumento inválido o mesmo deve ser retornado", () => { 158 | expect(telephoneFormat("234")).toBe("234"); 159 | }); 160 | }); 161 | }); 162 | -------------------------------------------------------------------------------- /test/desafiadores.test.js: -------------------------------------------------------------------------------- 1 | const { 2 | desafiadoresMock: { test4, test6, test8, result11 }, 3 | } = require("../test/mocks"); 4 | 5 | /* 6 | É importada nesse arquivo tanto as funções do gabarito quanto dos desafios 7 | */ 8 | /* Gabaritos */ 9 | /* const { 10 | cnhProcess, 11 | squareRoot, 12 | musicalNotes, 13 | musicalNotes2, 14 | magicWand, 15 | productAnalysis, 16 | averageTemperature, 17 | numberTies, 18 | viewerTvShows, 19 | negateNumbers, 20 | } = require("../Desafios/Desafiadores/Gabaritos/1-10"); 21 | 22 | const { 23 | musicalNotes3, 24 | factorial, 25 | fibonnaci, 26 | sumPrimesNumbers, 27 | factorial15, 28 | meanFactorialFromAToB, 29 | cpfValidator, 30 | } = require("../Desafios/Desafiadores/Gabaritos/11-16"); */ 31 | 32 | /* 33 | Exercícios 34 | */ 35 | const { 36 | cnhProcess, 37 | squareRoot, 38 | musicalNotes, 39 | musicalNotes2, 40 | magicWand, 41 | productAnalysis, 42 | averageTemperature, 43 | numberTies, 44 | viewerTvShows, 45 | negateNumbers, 46 | musicalNotes3, 47 | factorial, 48 | fibonnaci, 49 | sumPrimesNumbers, 50 | factorial15, 51 | meanFactorialFromAToB, 52 | cpfValidator, 53 | } = require("../Desafios/Desafiadores"); 54 | 55 | describe("Desafios Desafiadores.", () => { 56 | describe("01 - Testando a Função cnhProcess.", () => { 57 | const currentYear = new Date().getFullYear(); 58 | const birthSuccess = 2000; 59 | const birthError = currentYear - 10; 60 | const ageSuccess = currentYear - birthSuccess; 61 | const ageError = currentYear - birthError; 62 | it(`Ao passar os argumentos "Daniel" e ${ageSuccess}, deve retornar: 63 | "Daniel tem ${ageSuccess} anos de idade e pode iniciar o processo."`, () => { 64 | expect(cnhProcess("Daniel", birthSuccess)).toBe( 65 | `Daniel tem ${ageSuccess} anos de idade e pode iniciar o processo.` 66 | ); 67 | }); 68 | it(`Ao passar os argumentos "João" e ${ageError}, deve retornar: 69 | "João tem ${ageError} anos de idade e não pode iniciar o processo."`, () => { 70 | expect(cnhProcess("João", birthError)).toBe( 71 | `João tem ${ageError} anos de idade e não pode iniciar o processo.` 72 | ); 73 | }); 74 | }); 75 | 76 | describe("02 - Testando a Função squareRoot.", () => { 77 | it("Ao passar o argumento 9, deve retornar: 'A raiz quadrada de 9 é: 3.'", () => { 78 | expect(squareRoot(9)).toBe("A raiz quadrada de 9 é: 3."); 79 | }); 80 | it("Ao passar o argumento 10, deve retornar: 'Não existe raiz exata para o número 10.'", () => { 81 | expect(squareRoot(10)).toBe("Não existe raiz exata para o número 10."); 82 | }); 83 | it("Ao passar o argumento 0 'Zero', deve retornar: 'Número inválido.'", () => { 84 | expect(squareRoot(0)).toBe("Número inválido."); 85 | }); 86 | it("Ao passar o argumento '25', deve retornar: 'Número inválido.'", () => { 87 | expect(squareRoot("25")).toBe("Número inválido."); 88 | }); 89 | it("Ao passar o argumento 'Xablauzinho', deve retornar: 'Número inválido.'", () => { 90 | expect(squareRoot("Xablauzinho")).toBe("Número inválido."); 91 | }); 92 | }); 93 | 94 | describe("03 - Testando a Função musicalNotes.", () => { 95 | it("Ao passar o argumento ['Ré', 'Sol', 'Dó'], deve retornar: ['II', 'V', 'I']", () => { 96 | expect(musicalNotes(["Ré", "Sol", "Dó"])).toEqual(["II", "V", "I"]); 97 | }); 98 | }); 99 | 100 | describe("04 - Testando a Função musicalNotes2.", () => { 101 | it(`Ao passar o argumento ["Ré", "Sol", "Dó"], deve retornar: 102 | ${JSON.stringify(test4)}`, () => { 103 | expect(musicalNotes2(["Ré", "Sol", "Dó"])).toEqual(test4); 104 | }); 105 | }); 106 | 107 | describe("05 - Testando a Função magicWand.", () => { 108 | it(`Ao passar os argumentos 'Belatriz Lestrange' e 'Azevinho e Pena de Fênix', deve retornar: 109 | 'Curioso... muito curioso...'`, () => { 110 | expect(magicWand("Harry Potter", "Azevinho e Pena de Fênix")).toBe( 111 | "Curioso... muito curioso..." 112 | ); 113 | }); 114 | it(`Ao passar os argumentos 'Rony Weasley' e 'Salgueiro e Pelo de Unicórnio', deve retornar: 115 | 'Curioso... muito curioso...'`, () => { 116 | expect(magicWand("Rony Weasley", "Salgueiro e Pelo de Unicórnio")).toBe( 117 | "Curioso... muito curioso..." 118 | ); 119 | }); 120 | it(`Ao passar os argumentos 'Hermione Granger' e 'Videira e Fibra de Dragão', deve retornar: 121 | 'Curioso... muito curioso...'`, () => { 122 | expect(magicWand("Hermione Granger", "Videira e Fibra de Dragão")).toBe( 123 | "Curioso... muito curioso..." 124 | ); 125 | }); 126 | it(`Ao passar os argumentos 'Alvo Dumbledore' e 'Salgueiro e Pelo de Testrálio', deve retornar: 127 | 'Curioso... muito curioso...'`, () => { 128 | expect(magicWand("Alvo Dumbledore", "Salgueiro e Pelo de Testrálio")).toBe( 129 | "Curioso... muito curioso..." 130 | ); 131 | }); 132 | it(`Ao passar os argumentos 'Belatriz Lestrange' e 'Nogueira e Fibra de Dragão', deve retornar: 133 | 'Curioso... muito curioso...'`, () => { 134 | expect(magicWand("Belatriz Lestrange", "Nogueira e Fibra de Dragão")).toBe( 135 | "Curioso... muito curioso..." 136 | ); 137 | }); 138 | 139 | it(`Ao passar os argumentos 'Belatriz Lestrange' e 'Azevinho e Pena de Fênix', deve retornar: 140 | 'Não, não! Decididamente, não!'`, () => { 141 | expect( 142 | magicWand("Alvo Dumbledore", "Nogueira e Fibra de Dragão") 143 | ).toBe("Não, não! Decididamente, não!"); 144 | }); 145 | }); 146 | 147 | describe("6 - Testando a Função productAnalysis.", () => { 148 | it(`Ao passar o argumento: 149 | ${JSON.stringify(test6)} 150 | deve retornar: 151 | "O produto mais caro é teclado gamer e custa: R$ 180, a média de preços dos produtos é de: R$36.11."`, () => { 152 | expect(productAnalysis(test6)).toBe( 153 | "O produto mais caro é teclado gamer e custa: R$ 180, a média de preços dos produtos é de: R$36.11."); 154 | }); 155 | }); 156 | 157 | describe("7 - Testando a Função averageTemperature.", () => { 158 | it(`Ao passar o argumento [98, 95, 92, 88, 74, 106, 114, 90, 76, 65, 55, 80], deve retornar: 159 | "A média anual de temperatura em graus Celsius é 30.05."`, () => 160 | expect( 161 | averageTemperature([98, 95, 92, 88, 74, 106, 114, 90, 76, 65, 55, 80]) 162 | ).toBe("A média anual de temperatura em graus Celsius é 30.05.")); 163 | }); 164 | 165 | describe("08 - Testando a Função numberTies .", () => { 166 | it(`Ao passar os argumentos 2 e ${JSON.stringify(test8)}, deve retornar: 8`, () => { 167 | expect(numberTies(2, test8)).toBe(3); 168 | }); 169 | }); 170 | 171 | describe("09 - Testando a Função viewerTvShows.", () => { 172 | it(`Ao passar o argumento { age: 17, country: 'Brasil', likeSports: true }, deve retornar: 173 | 'UFC'.`, () => { 174 | expect( 175 | viewerTvShows({ 176 | age: 17, 177 | country: "Brasil", 178 | likeSports: true, 179 | }) 180 | ).toBe("UFC."); 181 | }); 182 | it(`Ao passar o argumento { age: 17, country: 'Brasil', likeSports: false }, deve retornar: 183 | 'The Simpsons.'`, () => { 184 | expect( 185 | viewerTvShows({ 186 | age: 17, 187 | country: "Brasil", 188 | likeSports: false, 189 | }) 190 | ).toBe("The Simpsons."); 191 | }); 192 | it(`Ao passar o argumento { age: 15, country: 'Chile', likeSports: false }, deve retornar: 193 | 'The Penguins of Madagascar.'`, () => { 194 | expect( 195 | viewerTvShows({ 196 | age: 15, 197 | country: "Chile", 198 | likeSports: false, 199 | }) 200 | ).toBe("The Penguins of Madagascar."); 201 | }); 202 | it(`Ao passar o argumento { age: 15, country: 'Argentina', likeSports: true }, deve retornar: 203 | 'Sport Fishing.'.`, () => { 204 | expect( 205 | viewerTvShows({ 206 | age: 15, 207 | country: "Argentina", 208 | likeSports: true, 209 | }) 210 | ).toEqual("Sport Fishing."); 211 | }); 212 | it(`Ao passar o argumento { age: 17, country: 'Chile', likeSports: true }, deve retornar: 213 | 'Não foi possível dizer o que ela deve assistir'.`, () => { 214 | expect( 215 | viewerTvShows({ 216 | age: 20, 217 | country: "Chile", 218 | likeSports: true, 219 | }) 220 | ).toEqual("Não foi possível dizer o que ela deve assistir."); 221 | }); 222 | }); 223 | 224 | describe("10 - Testando a Função negateNumbers.", () => { 225 | it("Ao passar o argumento [1, 3, 4], deve retornar: [-1, -3, -4]", () => { 226 | expect(negateNumbers([1, 3, 4])).toEqual([-1, -3, -4]); 227 | }); 228 | it("Ao passar o argumento [-1, -3, -4], deve retornar: [1, 3, 4]", () => { 229 | expect(negateNumbers([-1, -3, -4])).toEqual([1, 3, 4]); 230 | }); 231 | it("Ao passar o argumento [-1, 3, 4], deve retornar: [1, -3, 4]", () => { 232 | expect(negateNumbers([-1, 3, 4])).toEqual([1, -3, -4]); 233 | }); 234 | }); 235 | 236 | describe("11 - Testando a Função musicalNotes3.", () => { 237 | it(`Ao passar o argumento["Ré", "Sol", "Dó"], deve retornar: 238 | ${JSON.stringify(result11)}`, () => { 239 | expect(musicalNotes3(["Ré", "Sol", "Dó"])).toEqual(result11); 240 | }); 241 | }); 242 | 243 | describe("12 - Testando a Função factorial.", () => { 244 | it("Ao passar o argumento 5, deve retornar: 120", () => { 245 | expect(factorial(5)).toBe(120); 246 | }); 247 | it("Ao passar o argumento 1, deve retornar: 1", () => { 248 | expect(factorial(1)).toBe(1); 249 | }); 250 | it("Ao passar o argumento 2, deve retornar: 2", () => { 251 | expect(factorial(2)).toBe(2); 252 | }); 253 | }); 254 | 255 | describe("13 - Testando a Função fibonnaci.", () => { 256 | it("Ao passar o argumento 1, deve retornar: 0", () => { 257 | expect(fibonnaci(1)).toBe(0); 258 | }); 259 | it("Ao passar o argumento 2, deve retornar: 1", () => { 260 | expect(fibonnaci(2)).toBe(1); 261 | }); 262 | it("Ao passar o argumento 3, deve retornar: 1", () => { 263 | expect(fibonnaci(3)).toBe(1); 264 | }); 265 | it("Ao passar o argumento 5, deve retornar: 3", () => { 266 | expect(fibonnaci(5)).toBe(3); 267 | }); 268 | it("Ao passar o argumento 22, deve retornar: 10946", () => { 269 | expect(fibonnaci(22)).toBe(10946); 270 | }); 271 | }); 272 | 273 | describe("14 - Testando a Função sumPrimesNumbers.", () => { 274 | it("Deve retornar: 2276", () => { 275 | expect(sumPrimesNumbers()).toBe(2276); 276 | }); 277 | }); 278 | 279 | describe("15 - Testando as funções 'factorial15' e 'meanFactorialFromAToB'", () => { 280 | describe('Função factorial15', () => { 281 | it("Ao receber 0 como parâmetro, deve retornar 1", () => { 282 | const expected = 1; 283 | const received = factorial15(0); 284 | expect(received).toEqual(expected); 285 | }); 286 | 287 | it("Ao receber 1 como parâmetro, deve retornar 1", () => { 288 | const expected = 1; 289 | const received = factorial15(1); 290 | expect(received).toEqual(expected); 291 | }); 292 | it("Ao receber 2 como parâmetro, deve retornar 2", () => { 293 | const expected = 2; 294 | const received = factorial15(2); 295 | expect(received).toEqual(expected); 296 | }); 297 | it("Ao receber 3 como parâmetro, deve retornar 6", () => { 298 | const expected = 6; 299 | const received = factorial15(3); 300 | expect(received).toEqual(expected); 301 | }); 302 | it("Ao receber 10 como parâmetro, deve retornar 3628800", () => { 303 | const expected = 3628800; 304 | const received = factorial15(10); 305 | expect(received).toEqual(expected); 306 | }); 307 | }); 308 | 309 | describe('Função meanFactorialFromAToB', () => { 310 | it("Ao receber 0 e 0 como parâmetro, deve retornar 1", () => { 311 | const expected = 1; 312 | const received = meanFactorialFromAToB(0, 0); 313 | expect(received).toEqual(expected); 314 | }); 315 | 316 | it("Ao receber 0 e 1 como parâmetro, deve retornar 1", () => { 317 | const expected = 1; 318 | const received = meanFactorialFromAToB(0, 1); 319 | expect(received).toEqual(expected); 320 | }); 321 | 322 | it("Ao receber 0 e 5 como parâmetro, deve retornar 25.67", () => { 323 | const expected = 25.67; 324 | const received = meanFactorialFromAToB(0, 5); 325 | expect(received).toEqual(expected); 326 | }); 327 | it("Ao receber 5 e 8 como parâmetro, deve retornar 11550", () => { 328 | const expected = 11550; 329 | const received = meanFactorialFromAToB(5, 8); 330 | expect(received).toEqual(expected); 331 | }); 332 | it("Ao receber 10 e 15 como parâmetro, deve retornar 233600371200", () => { 333 | const expected = 233600371200; 334 | const received = meanFactorialFromAToB(10, 15); 335 | expect(received).toEqual(expected); 336 | }); 337 | 338 | }); 339 | }); 340 | 341 | describe("16 - Testando a Função cpfValidator.", () => { 342 | it("Ao passar o argumento 000.000.000-00, deve retornar: 'CPF inválido'", () => { 343 | expect(cpfValidator("000.000.000-00")).toBe("CPF inválido"); 344 | }); 345 | it("Ao passar o argumento 397-606-448-34, deve retornar: 'CPF inválido'", () => { 346 | expect(cpfValidator("397.606.448-34")).toBe("CPF inválido"); 347 | }); 348 | it("Ao passar o argumento 166.354.840-43, deve retornar: 'CPF válido'", () => { 349 | expect(cpfValidator("166.354.840-43")).toBe("CPF válido"); 350 | }); 351 | }); 352 | }); 353 | -------------------------------------------------------------------------------- /test/operadoresAritmeticos.test.js: -------------------------------------------------------------------------------- 1 | 2 | const { getRandomInt } = require('../test/mocks') 3 | 4 | /* É importada nesse arquivo tanto as funções do gabarito quanto dos desafios */ 5 | /* Gabaritos */ 6 | /* const { 7 | average, 8 | totalReceive, 9 | showNeighbors, 10 | powerNumber, 11 | triangleArea, 12 | IMC, 13 | readingTime, 14 | restaurantExpenses, 15 | celsiusToFahrenheit, 16 | fahrenheitToCelsius, 17 | } = require("../Desafios/Operadores Aritméticos/Gabaritos/1-10"); 18 | const { 19 | paymentOptions, 20 | weightAndValue, 21 | randomRGBColor, 22 | timeTravel, 23 | areaCircle, 24 | randomBoolean, 25 | carFinancing, 26 | rollDice, 27 | carTrip, 28 | avaliador, 29 | } = require("../Desafios/Operadores Aritméticos/Gabaritos/11-20") 30 | 31 | const { 32 | weightedAverage, 33 | calculateScore, 34 | successiveDivisions, 35 | } = require("../Desafios/Operadores Aritméticos/Gabaritos/21-23"); */ 36 | 37 | /* Exercícios */ 38 | const { 39 | average, 40 | totalReceive, 41 | showNeighbors, 42 | powerNumber, 43 | triangleArea, 44 | IMC, 45 | readingTime, 46 | restaurantExpenses, 47 | celsiusToFahrenheit, 48 | fahrenheitToCelsius, 49 | paymentOptions, 50 | weightAndValue, 51 | randomRGBColor, 52 | timeTravel, 53 | areaCircle, 54 | randomBoolean, 55 | carFinancing, 56 | rollDice, 57 | carTrip, 58 | avaliador, 59 | weightedAverage, 60 | calculateScore, 61 | successiveDivisions, 62 | } = require("../Desafios/Operadores Aritméticos"); 63 | 64 | describe("Desafios de Operadores Aritméticos.", () => { 65 | describe(" 01 - Testando a Função average.", () => { 66 | it(`Ao passar os argumentos -2,-5 e -7, deve retornar: 67 | 'O Valor médio é: -4.666666666666667'`, () => { 68 | expect(average(-2, -5, -7)).toBe("O Valor médio é: -4.666666666666667"); 69 | }); 70 | it(`Ao passar os argumentos 12,50.85 e -1212, deve retornar: 71 | 'O Valor médio é: -383.05'`, () => { 72 | expect(average(12, 50.85, -1212)).toBe("O Valor médio é: -383.05"); 73 | }); 74 | }); 75 | 76 | describe(" 02 - Testando a Função totalReceive.", () => { 77 | it(`Ao passar os argumentos 2000 e 1759, deve retornar: 78 | 'A comissão é: 70.36 e o ganho total é: 2070.36'`, () => { 79 | expect(totalReceive(2000, 1759)).toBe("A comissão é: 70.36 e o ganho total é: 2070.36"); 80 | }); 81 | }); 82 | 83 | describe(" 03 - Testando a Função showNeighbors.", () => { 84 | it(`Ao passar o argumento 10, deve retornar: 85 | 'O antecessor de 10 é 9 e seu sucessor é 11'`, () => { 86 | expect(showNeighbors(10)).toBe("O antecessor de 10 é 9 e seu sucessor é 11"); 87 | }); 88 | }); 89 | 90 | describe(" 04 - Testando a Função powerNumber.", () => { 91 | const base = getRandomInt(1, 20);; 92 | const exponent = getRandomInt(1, 10); 93 | const result = base ** exponent; 94 | it("Ao passar os argumentos 4 e 5, deve retornar: 1024", () => { 95 | expect(powerNumber(4, 5)).toBe(1024); 96 | }); 97 | it(`Ao passar os argumentos ${base} e ${exponent}, deve retornar: ${result}`, () => { 98 | expect(powerNumber(base, exponent)).toBe(result); 99 | }); 100 | }); 101 | 102 | describe(" 05 - Testando a Função triangleArea.", () => { 103 | const base = getRandomInt(1, 10); 104 | const height = getRandomInt(1, 5) 105 | const result = (base * height) / 2; 106 | it(`Ao passar o argumento 10 e 10, deve retornar: 107 | 'A área do triângulo de base 10 e altura 10 é: 50'`, () => { 108 | expect(triangleArea(10, 10)).toBe("A área do triângulo de base 10 e altura 10 é: 50"); 109 | }); 110 | it(`Ao passar o argumento ${base} e ${height}, deve retornar: 111 | A área do triângulo de base ${base} e altura ${height} é: ${result}`, () => { 112 | expect(triangleArea(base, height)).toBe(`A área do triângulo de base ${base} e altura ${height} é: ${result}`); 113 | }); 114 | }); 115 | 116 | describe(" 06 - Testando a Função IMC.", () => { 117 | const height = +`1.${getRandomInt(40, 99)}` 118 | const weight = getRandomInt(40, 120); 119 | const imc = (height * height) / weight; 120 | it("Ao passar os argumentos 70 e 1.8 , deve retornar: 0.04628571428571429", () => { 121 | expect(IMC(70, 1.8)).toBe(0.04628571428571429); 122 | }); 123 | it(`Ao passar os argumentos ${weight} e ${height}, deve retornar: ${imc}`, () => { 124 | expect(IMC(weight, height)).toBe(imc); 125 | }); 126 | }); 127 | 128 | describe(" 07 - Testando a Função readingTime.", () => { 129 | it(`Ao passar os argumentos 100, 1 e 1, deve retornar: 130 | 'Ana levará 100 minutos para ler o livro todo'`, () => { 131 | expect(readingTime(100, 1, 1)).toBe("Ana levará 100 minutos para ler o livro todo"); 132 | }); 133 | }); 134 | 135 | describe(" 08 - Testando a Função restaurantExpenses.", () => { 136 | it("Ao passar o argumento 100, deve retornar: 115.50", () => { 137 | expect(restaurantExpenses(100)).toBe(115.50); 138 | }); 139 | }); 140 | describe(" 09 - Testando a Função celsiusToFahrenheit.", () => { 141 | it("Ao passar o argumento 1, deve retornar: 33.8", () => { 142 | expect(celsiusToFahrenheit(1)).toBe(33.8); 143 | }); 144 | }); 145 | 146 | describe(" 10 - Testando a Função fahrenheitToCelsius.", () => { 147 | it("Ao passar o argumento 100, deve retornar: 37.78", () => { 148 | expect(fahrenheitToCelsius(100)).toBe(37.78); 149 | }); 150 | it("Ao passar o argumento 32, deve retornar: 0", () => { 151 | expect(fahrenheitToCelsius(32)).toBe(0); 152 | }); 153 | it("Ao passar o argumento 0, deve retornar: -17.78", () => { 154 | expect(fahrenheitToCelsius(0)).toBe(-17.78); 155 | }); 156 | }); 157 | 158 | 159 | describe(" 11 - Testando a Função paymentOptions.", () => { 160 | it("Se o preço do produto for 10, deve retornar 'À Vista: R$9 ou 4x de: R$2.88'", () => { 161 | const expected = 'À Vista: R$9 ou 4x de: R$2.88'; 162 | expect(paymentOptions(10)) 163 | .toBe(expected); 164 | }); 165 | it("Se o preço for 80, deve retornar 'À Vista: R$72 ou 4x de: R$23'", () => { 166 | const expected = 'À Vista: R$72 ou 4x de: R$23'; 167 | expect(paymentOptions(80)) 168 | .toBe(expected); 169 | }); 170 | }); 171 | 172 | describe(" 12 - Testando a Função weightAndValue.", () => { 173 | 174 | it("Com o preço do kg sendo 37,90 reais e o peso sem 735 gramas, deve retornar 'O prato de 735 gramas custa: R$ 27,86'", () => { 175 | const expected = 'O prato de 735 gramas custa: R$ 27,86'; 176 | const received = weightAndValue(37.90, 735) 177 | expect(received).toEqual(expected); 178 | }); 179 | 180 | it("Com o preço do kg sendo 30 reais e o peso sem 1000 gramas, deve retornar 'O prato de 1000 gramas custa: R$ 30,00'", () => { 181 | const expected = 'O prato de 1000 gramas custa: R$ 30,00'; 182 | const received = weightAndValue(30, 1000) 183 | expect(received).toEqual(expected); 184 | }); 185 | 186 | it("Com o preço do kg sendo 49,90 reais e o peso sem 1234 gramas, deve retornar 'O prato de 1234 gramas custa: R$ 61,58'", () => { 187 | const expected = 'O prato de 1234 gramas custa: R$ 61,58'; 188 | const received = weightAndValue(49.9, 1234) 189 | expect(received).toEqual(expected); 190 | }); 191 | }); 192 | 193 | describe(" 13 - Testando a Função randomRGBColor.", () => { 194 | // rgb(x, y, z) 195 | it(`Deve retornar uma string no formato 'rgb(x, y, z)', sendo x, y e z números inteiros`, () => { 196 | const received = randomRGBColor(); 197 | expect(received).toMatch(/rgb\(\d+, \d+, \d+\)/); 198 | }); 199 | 200 | it("Deve gerar valores maiores ou iguais a 0 e menores que 256", () => { 201 | const received = randomRGBColor(); 202 | const values = received.replace(/[^\d,]/g, '').split(','); 203 | Array(...values).map((v) => parseFloat(v)).forEach((value) => { 204 | expect(value).toBeGreaterThanOrEqual(0); 205 | expect(value).toBeLessThan(256); 206 | }) 207 | }); 208 | }); 209 | 210 | describe(" 14 - Testando a Função timeTravel.", () => { 211 | // A viagem terá duração de x hora(s) e y minuto(s) 212 | it("Ao receber 60 como parâmetro, deve retornar 'A viagem terá duração de 1 hora(s) e 0 minuto(s)'", () => { 213 | const expected = 'A viagem terá duração de 1 hora(s) e 0 minuto(s)'; 214 | const received = timeTravel(60); 215 | expect(received).toEqual(expected); 216 | }); 217 | 218 | it("Ao receber 73 como parâmetro, deve retornar 'A viagem terá duração de 1 hora(s) e 13 minuto(s)'", () => { 219 | const expected = 'A viagem terá duração de 1 hora(s) e 13 minuto(s)'; 220 | const received = timeTravel(73); 221 | expect(received).toEqual(expected); 222 | }); 223 | 224 | it("Ao receber 1734 como parâmetro, deve retornar 'A viagem terá duração de 28 hora(s) e 54 minuto(s)'", () => { 225 | const expected = 'A viagem terá duração de 28 hora(s) e 54 minuto(s)'; 226 | const received = timeTravel(1734); 227 | expect(received).toEqual(expected); 228 | }); 229 | }); 230 | 231 | describe(" 15 - Testando a Função areaCircle.", () => { 232 | // 'A circunferência de raio R cm possui uma área de A cm quadrados' 233 | it("Ao receber 256 como parâmetro deve retornar 'A circunferência de raio 128 cm possui uma área de 51471.85 cm quadrados'", () => { 234 | const expected = 'A circunferência de raio 128 cm possui uma área de 51471.85 cm quadrados'; 235 | const received = areaCircle(256); 236 | expect(received).toEqual(expected); 237 | }); 238 | 239 | it("Ao receber 16 como parâmetro deve retornar 'A circunferência de raio 8 cm possui uma área de 201.06 cm quadrados'", () => { 240 | const expected = 'A circunferência de raio 8 cm possui uma área de 201.06 cm quadrados'; 241 | const received = areaCircle(16); 242 | expect(received).toEqual(expected); 243 | }); 244 | }); 245 | 246 | describe(" 16 - Testando a Função randomBoolean.", () => { 247 | it("Deve retornar sempre um valor booleano de forma aleatória", () => { 248 | let countTrue = 0, countFalse = 0; 249 | 250 | for (let index = 0; index < 123; index += 1) { 251 | const received = randomBoolean(); 252 | expect(typeof received).toEqual('boolean'); 253 | received ? countTrue += 1 : countFalse += 1; 254 | } 255 | 256 | expect(countFalse).toBeGreaterThan(0); 257 | expect(countTrue).toBeGreaterThan(0); 258 | }); 259 | }); 260 | 261 | describe(" 17 - Testando a Função carFinancing.", () => { 262 | it("Deve retornar a saída correta para os parâmetros 50000, 10000, 48", () => { 263 | const expected = `Valor Financiado: R$40000,00; 264 | Valor do Juros: R$2000,00; 265 | Quantidade de Parcelas: 48; 266 | Valor da Parcela: R$875,00; 267 | Valor Total do Carro: R$52000,00.`; 268 | const received = carFinancing(50000, 10000, 48); 269 | expect(received).toEqual(expected); 270 | }); 271 | it("Deve retornar a saída correta para os parâmetros 10000, 0, 32", () => { 272 | const expected = `Valor Financiado: R$10000,00; 273 | Valor do Juros: R$500,00; 274 | Quantidade de Parcelas: 32; 275 | Valor da Parcela: R$328,13; 276 | Valor Total do Carro: R$10500,00.`; 277 | const received = carFinancing(10000, 0, 32); 278 | expect(received).toEqual(expected); 279 | }); 280 | }); 281 | 282 | describe(" 18 - Testando a Função rollDice.", () => { 283 | it("Deve sortear valores de 1 a N sendo N o valor recebido por parâmetro", () => { 284 | for (let index = 0; index < 100; index += 1) { 285 | const d = Math.floor(Math.random() * 10) + 6; // números de 6 a 15 286 | const received = rollDice(d); 287 | expect(received).toBeGreaterThan(0); 288 | expect(received).toBeLessThanOrEqual(d); 289 | } 290 | }); 291 | }); 292 | 293 | describe(" 19 - Testando a Função carTrip.", () => { 294 | it("Ao receber como parâmetro 7.3, 19.9 e 15.51, deve retornar 1.78", () => { 295 | const received = carTrip(7.3, 19.9, 15.51); 296 | expect(received).toEqual(1.78); 297 | }); 298 | 299 | it("Ao receber como parâmetro 7, 19 e 15, deve retornar 1.71", () => { 300 | const received = carTrip(7, 19, 15); 301 | expect(received).toEqual(1.708); 302 | }); 303 | 304 | it("Ao receber como parâmetro 13, 17 e 40, deve retornar 2.92", () => { 305 | const received = carTrip(13, 17, 40); 306 | expect(received).toEqual(2.917); 307 | }); 308 | }); 309 | 310 | describe(" 20 - Testando a Função avaliador.", () => { 311 | it("Ao receber as notas 0, 0 e 0 deve retornar 'Reprovação, média: 0'", () => { 312 | const expected = 'Reprovação, média: 0'; 313 | const received = avaliador(0, 0, 0); 314 | expect(received).toBe(expected); 315 | }); 316 | 317 | it("Ao receber as notas 10, 10 e 10 deve retornar 'Aprovação, média: 10'", () => { 318 | const expected = 'Aprovação, média: 10'; 319 | const received = avaliador(10, 10, 10); 320 | expect(received).toBe(expected); 321 | }); 322 | 323 | it("Ao receber as notas 8, 4 e 7 deve retornar 'Aprovação, média: 6'", () => { 324 | const expected = 'Aprovação, média: 6'; 325 | const received = avaliador(8, 4, 7); 326 | expect(received).toBe(expected); 327 | }); 328 | 329 | it("Ao receber as notas 10, 6 e 0 deve retornar 'Reprovação, média: 5'", () => { 330 | const expected = 'Reprovação, média: 5'; 331 | const received = avaliador(10, 6, 0); 332 | expect(received).toBe(expected); 333 | }); 334 | }); 335 | 336 | describe(" 21 - Testando a Função weightedAverage.", () => { 337 | it("Ao receber as notas 2, 5 e 10 deve retornar 'Aprovação, média: 6.1'", () => { 338 | const expected = 'Aprovação, média: 6.1'; 339 | const received = weightedAverage(2, 5, 10); 340 | expect(received).toBe(expected); 341 | }); 342 | 343 | it("Ao receber as notas 9, 8 e 2 deve retornar 'Reprovação, média: 5.9'", () => { 344 | const expected = 'Reprovação, média: 5.9'; 345 | const received = weightedAverage(9, 8, 2); 346 | expect(received).toBe(expected); 347 | }); 348 | 349 | it("Ao receber as notas 8, 9 e 3 deve retornar 'Aprovação, média: 6.3'", () => { 350 | const expected = 'Aprovação, média: 6.3'; 351 | const received = weightedAverage(8, 9, 3); 352 | expect(received).toBe(expected); 353 | }); 354 | 355 | it("Ao receber as notas 9, 2 e 6 deve retornar 'Reprovação, média: 5.7'", () => { 356 | const expected = 'Reprovação, média: 5.7'; 357 | const received = weightedAverage(9, 2, 6); 358 | expect(received).toBe(expected); 359 | }); 360 | }); 361 | 362 | describe(" 22 - Testando a Função calculateScore.", () => { 363 | it("Ao receber 1 como parâmetro, deve retornar 'A pontuação da pessoa jogadora foi de 1'", () => { 364 | const expected = 'A pontuação da pessoa jogadora foi de 1'; 365 | const received = calculateScore(1) 366 | expect(received).toEqual(expected); 367 | }); 368 | it("Ao receber 5 como parâmetro, deve retornar 'A pontuação da pessoa jogadora foi de 7'", () => { 369 | const expected = 'A pontuação da pessoa jogadora foi de 7'; 370 | const received = calculateScore(5) 371 | expect(received).toEqual(expected); 372 | }); 373 | it("Ao receber 15 como parâmetro, deve retornar 'A pontuação da pessoa jogadora foi de 21'", () => { 374 | const expected = 'A pontuação da pessoa jogadora foi de 21'; 375 | const received = calculateScore(15) 376 | expect(received).toEqual(expected); 377 | }); 378 | it("Ao receber 555 como parâmetro, deve retornar 'A pontuação da pessoa jogadora foi de 555'", () => { 379 | const expected = 'A pontuação da pessoa jogadora foi de 777'; 380 | const received = calculateScore(555) 381 | expect(received).toEqual(expected); 382 | }); 383 | }); 384 | 385 | describe(" 23 - Testando a Função successiveDivisions.", () => { 386 | it("Ao receber 0 como parâmetro deve retornar 'Quantidade total de divisões: 0'", () => { 387 | const expected = 'Quantidade total de divisões: 0'; 388 | const received = successiveDivisions(0); 389 | expect(received).toEqual(expected); 390 | }); 391 | it("Ao receber 1 como parâmetro deve retornar 'Quantidade total de divisões: 1'", () => { 392 | const expected = 'Quantidade total de divisões: 1'; 393 | const received = successiveDivisions(1); 394 | expect(received).toEqual(expected); 395 | }); 396 | it("Ao receber 2 como parâmetro deve retornar 'Quantidade total de divisões: 2'", () => { 397 | const expected = 'Quantidade total de divisões: 2'; 398 | const received = successiveDivisions(2); 399 | expect(received).toEqual(expected); 400 | }); 401 | it("Ao receber 512 como parâmetro deve retornar 'Quantidade total de divisões: 10'", () => { 402 | const expected = 'Quantidade total de divisões: 10'; 403 | const received = successiveDivisions(512); 404 | expect(received).toEqual(expected); 405 | }); 406 | }); 407 | }); 408 | -------------------------------------------------------------------------------- /test/estruturasCondicionais.test.js: -------------------------------------------------------------------------------- 1 | /* 2 | É importada nesse arquivo tanto as funções do gabarito quanto dos desafios 3 | */ 4 | /* Gabaritos */ 5 | /* const { 6 | optionsMenu, 7 | studentSituation, 8 | findAdventurous, 9 | polyglotDinosaur, 10 | robotFriend, 11 | basalMetabolicRate, 12 | legalAge, 13 | findYoungerPerson, 14 | evaluateProject, 15 | droneDelivery, 16 | } = require("../Desafios/Estruturas Condicionais/Gabaritos/1-10"); 17 | 18 | const { 19 | triVowels, 20 | IMC, 21 | chessRating, 22 | ATM, 23 | rockPaperScissors, 24 | sortAgeAsc, 25 | oddOreEven, 26 | cardsGame, 27 | } = require("../Desafios/Estruturas Condicionais/Gabaritos/11-18"); */ 28 | 29 | /* Exercícios */ 30 | const { 31 | triVowels, 32 | IMC, 33 | chessRating, 34 | ATM, 35 | rockPaperScissors, 36 | sortAgeAsc, 37 | oddOreEven, 38 | cardsGame, 39 | optionsMenu, 40 | studentSituation, 41 | findAdventurous, 42 | polyglotDinosaur, 43 | robotFriend, 44 | basalMetabolicRate, 45 | legalAge, 46 | findYoungerPerson, 47 | evaluateProject, 48 | droneDelivery, 49 | } = require("../Desafios/Estruturas Condicionais"); 50 | 51 | describe("Desafios de Estruturas Condicionais.", () => { 52 | describe("01 - Testando a Função optionsMenu.", () => { 53 | it("Ao passar o argumento 1, deve retornar: '1 - Trybe Lanche Feliz'", () => { 54 | expect(optionsMenu(1)).toBe("1 - Trybe Lanche Feliz"); 55 | }); 56 | it("Ao passar o argumento 2, deve retornar: '2 - McTrybe'", () => { 57 | expect(optionsMenu(2)).toBe("2 - McTrybe"); 58 | }); 59 | it("Ao passar o argumento 3, deve retornar: '3 - TrybeWooper'", () => { 60 | expect(optionsMenu(3)).toBe("3 - TrybeWooper"); 61 | }); 62 | it("Ao passar o argumento 4, deve retornar: '4 - X-Trybe'", () => { 63 | expect(optionsMenu(4)).toBe("4 - X-Trybe"); 64 | }); 65 | it("Ao passar o argumento 5, deve retornar: '5 - Triplo Trybe com JS'", () => { 66 | expect(optionsMenu(5)).toBe("5 - Triplo Trybe com JS"); 67 | }); 68 | it("Ao passar o argumento 6, deve retornar: 'Não temos esta opção ainda :('", () => { 69 | expect(optionsMenu(6)).toBe("Não temos esta opção ainda :("); 70 | }); 71 | }); 72 | 73 | describe("02 - Testando a Função studentSituation.", () => { 74 | it("Ao passar o argumento 10, deve retornar: 'PÉSSIMO'", () => { 75 | expect(studentSituation(10)).toBe("PÉSSIMO"); 76 | }); 77 | it("Ao passar o argumento 10, deve retornar: 'RUIM'", () => { 78 | expect(studentSituation(30)).toBe("RUIM"); 79 | }); 80 | it("Ao passar o argumento 50, deve retornar: 'REGULAR'", () => { 81 | expect(studentSituation(50)).toBe("REGULAR"); 82 | }); 83 | it("Ao passar o argumento 70, deve retornar: 'MEDIANO'", () => { 84 | expect(studentSituation(70)).toBe("MEDIANO"); 85 | }); 86 | it("Ao passar o argumento 90, deve retornar: 'ÓTIMO'", () => { 87 | expect(studentSituation(90)).toBe("ÓTIMO"); 88 | }); 89 | it("Ao passar o argumento 91, deve retornar: 'EXCELENTE'", () => { 90 | expect(studentSituation(91)).toBe("EXCELENTE"); 91 | }); 92 | }); 93 | 94 | describe("03 - Testando a Função findAdventurous.", () => { 95 | it("Ao passar o argumento 'Tunico', deve retornar: 'Mestre dos Magos'", () => { 96 | expect(findAdventurous("Tunico")).toBe("Mestre dos Magos"); 97 | }); 98 | it("Ao passar o argumento 'Cremoso', deve retornar: 'Cavaleiro Negro'", () => { 99 | expect(findAdventurous("Cremoso")).toBe("Cavaleiro Negro"); 100 | }); 101 | it("Ao passar o argumento 'Gordinho', deve retornar: 'Pirata'", () => { 102 | expect(findAdventurous("Gordinho")).toBe("Pirata"); 103 | }); 104 | it("Ao passar o argumento 'Lobo Solitário', deve retornar: 'Samurai'", () => { 105 | expect(findAdventurous("Lobo Solitário")).toBe("Samurai"); 106 | }); 107 | it("Ao passar o argumento Ousado, deve retornar: 'Mago'", () => { 108 | expect(findAdventurous("Ousado")).toBe("Mago"); 109 | }); 110 | it("Ao passar o argumento 'Anjo Loiro', deve retornar: 'Clérigo'", () => { 111 | expect(findAdventurous("Anjo Loiro")).toBe("Clérigo"); 112 | }); 113 | it("Ao passar um argumento incorreto, deve retornar: 'Aventureiro não encontrado'", () => { 114 | expect(findAdventurous("Xablau")).toBe( 115 | "Aventureiro não encontrado" 116 | ); 117 | }); 118 | }); 119 | 120 | describe("04 - Testando a Função polyglotDinosaur.", () => { 121 | it("Ao passar o argumento 'esquerda', deve retornar: 'english'", () => { 122 | expect(polyglotDinosaur("esquerda")).toBe("english"); 123 | }); 124 | it("Ao passar o argumento 'direita', deve retornar: 'français'", () => { 125 | expect(polyglotDinosaur("direita")).toBe("français"); 126 | }); 127 | it("Ao passar o argumento 'nenhuma', deve retornar: 'português'", () => { 128 | expect(polyglotDinosaur("nenhuma")).toBe("português"); 129 | }); 130 | it("Ao passar o argumento 'as duas', deve retornar: 'Ai eu caiu, né!!'", () => { 131 | expect(polyglotDinosaur("as duas")).toBe("Ai eu caiu, né!!"); 132 | }); 133 | it("Ao passar o argumento 'Xablau', deve retornar: 'Comando desconhecido'", () => { 134 | expect(polyglotDinosaur("Xablau")).toBe("Comando desconhecido."); 135 | }); 136 | }); 137 | 138 | describe("05 - Testando a Função robotFriend.", () => { 139 | it(`Ao passar os argumento true, false, false, false, false, deve retornar: 140 | 'Things I do for love...'.`, () => { 141 | expect(robotFriend(true, false, false, false, false)).toBe( 142 | "Things I do for love..." 143 | ); 144 | }); 145 | it(`Ao passar os argumentos false, true, false, false, false, deve retornar: 146 | 'Things I do for love...'.`, () => { 147 | expect(robotFriend(false, true, false, false, false)).toBe( 148 | "Things I do for love..." 149 | ); 150 | }); 151 | it(`Ao passar os argumentos false, false, true, false, false, deve retornar: 152 | 'Things I do for love...'.`, () => { 153 | expect(robotFriend(false, false, true, false, false)).toBe( 154 | "Things I do for love..." 155 | ); 156 | }); 157 | it(`Ao passar od argumentos false, false, false, true, false, deve retornar: 158 | 'Not today.'.`, () => { 159 | expect(robotFriend(false, false, false, true, false)).toBe("Not today."); 160 | }); 161 | it(`Ao passar os argumentos false, false, false, false, true, deve retornar: 162 | 'Not today.'.`, () => { 163 | expect(robotFriend(false, false, false, false, true)).toBe("Not today."); 164 | }); 165 | it(`Ao passar os argumentos false, false, false, true, true, deve retornar: 166 | 'Things I do for love...'.`, () => { 167 | expect(robotFriend(false, false, false, true, true)).toBe( 168 | "Things I do for love..." 169 | ); 170 | }); 171 | }); 172 | 173 | describe("06 - Testando a Função basalMetabolicRate.", () => { 174 | it(`Ao passar os argumentos 35, 'M', 78, 175, deve retornar: 175 | 'A taxa metabólica basal é: 1705.77 Kcal'.`, () => { 176 | expect(basalMetabolicRate(35, "M", 78, 175)).toBe( 177 | "A taxa metabólica basal é: 1705.77 Kcal." 178 | ); 179 | }); 180 | it(`Ao passar os argumentos 18, 'F', 61, 167, deve retornar: 181 | 'A taxa metabólica basal é: 1403.58 Kcal.'.`, () => { 182 | expect(basalMetabolicRate(18, "F", 61, 167)).toBe( 183 | "A taxa metabólica basal é: 1403.58 Kcal." 184 | ); 185 | }); 186 | }); 187 | 188 | describe("07 - Testando a Função legalAge.", () => { 189 | it("Ao passar o argumento 17, deve retornar: 'A pessoa é menor de idade'", () => { 190 | expect(legalAge(17)).toBe("A pessoa é menor de idade."); 191 | }); 192 | it("Ao passar o argumento 18, deve retornar: 'A pessoa é maior de idade'", () => { 193 | expect(legalAge(18)).toBe("A pessoa é maior de idade."); 194 | }); 195 | }); 196 | 197 | describe("08 - Testando a Função findYoungerPerson", () => { 198 | it(`Ao passar os argumentos 18, 19, 20, deve retornar: 199 | 'Marina é a mais jovem e possui 18 anos de idade'.`, () => { 200 | expect(findYoungerPerson(18, 19, 20)).toBe( 201 | "Marina é a mais jovem e possui 18 anos de idade." 202 | ); 203 | }); 204 | it(`Ao passar os argumentos 20, 18, 19, deve retornar: 205 | 'Silvia é a mais jovem e possui 18 anos de idade.'.`, () => { 206 | expect(findYoungerPerson(20, 18, 19)).toBe( 207 | "Silvia é a mais jovem e possui 18 anos de idade." 208 | ); 209 | }); 210 | it(`Ao passar os argumentos 20, 19, 18, deve retornar: 211 | 'Iza é a mais jovem e possui 18 anos de idade'.`, () => { 212 | expect(findYoungerPerson(20, 19, 18)).toBe( 213 | "Iza é a mais jovem e possui 18 anos de idade." 214 | ); 215 | }); 216 | }); 217 | 218 | describe("09- Testando a Função evaluateProject.", () => { 219 | it(`Ao passar o argumento { 220 | rec: false, 221 | reqs: 100, 222 | totalReqs: 120, 223 | completed: 80, 224 | }, 225 | deve retornar: 'Parabéns, você está aprovado(a)!'.`, () => { 226 | expect( 227 | evaluateProject({ 228 | rec: false, 229 | reqs: 100, 230 | totalReqs: 120, 231 | completed: 80, 232 | }) 233 | ).toBe("Parabéns, você está aprovado(a)!"); 234 | }); 235 | it(`Ao passar o argumento { 236 | rec: false, 237 | reqs: 100, 238 | totalReqs: 120, 239 | completed: 79, 240 | }, deve retornar: 'Você ainda precisa entregar mais requisitos ;)'.`, () => { 241 | expect( 242 | evaluateProject({ 243 | rec: false, 244 | reqs: 100, 245 | totalReqs: 120, 246 | completed: 79, 247 | }) 248 | ).toBe("Você ainda precisa entregar mais requisitos ;)"); 249 | }); 250 | it(`Ao passar o argumento { 251 | rec: true, 252 | reqs: 80, 253 | totalReqs: 100, 254 | completed: 90, 255 | }, deve retornar: 'Parabéns, você está aprovado(a)!'.`, () => { 256 | expect( 257 | evaluateProject({ 258 | rec: true, 259 | reqs: 80, 260 | totalReqs: 100, 261 | completed: 90, 262 | }) 263 | ).toBe("Parabéns, você está aprovado(a)!"); 264 | }); 265 | it(`Ao passar o argumento { 266 | rec: true, 267 | reqs: 80, 268 | totalReqs: 100, 269 | completed: 89, 270 | }, deve retornar: 'Você ainda precisa entregar mais requisitos ;)'.`, () => { 271 | expect( 272 | evaluateProject({ 273 | rec: true, 274 | reqs: 80, 275 | totalReqs: 100, 276 | completed: 89, 277 | }) 278 | ).toBe("Você ainda precisa entregar mais requisitos ;)"); 279 | }); 280 | }); 281 | 282 | describe(" 10 - Testando a Função droneDelivery.", () => { 283 | it(`Ao passar os argumentos 48, 87, 74, 50, 99 e 99,, deve retornar: 284 | É possível realizar a entrega.`, () => { 285 | expect(droneDelivery(48, 87, 74, 50, 99, 99)).toBe("É possível realizar a entrega."); 286 | }); 287 | it(`Ao passar os argumentos 90, 134, 99, 76, 150 e 78, deve retorna: 288 | Não é possível realizar a entrega.`, () => { 289 | expect(droneDelivery(90, 134, 99, 76, 150, 78)).toBe("Não é possível realizar a entrega."); 290 | }); 291 | }); 292 | 293 | describe("11- Testando a Função triVowels.", () => { 294 | it("Ao passar o argumento Daniel, deve retornar: 'Daaaniiieeel'", () => { 295 | expect(triVowels("Daniel")).toBe("Daaaniiieeel"); 296 | }); 297 | it("Ao passar o argumento JC, deve retornar: 'JC'", () => { 298 | expect(triVowels("JC")).toBe("JC"); 299 | }); 300 | }); 301 | 302 | describe(" 12 - Testando a Função IMC.", () => { 303 | it(`Ao passar os argumentos 50, 1.75, deve retornar: 304 | 'Seu IMC é: 16.3 kg/m2. O Resultado foi: Magreza'.`, () => { 305 | expect(IMC(50, 1.75)).toBe( 306 | "Seu IMC é: 16.3 kg/m2. O Resultado foi: Magreza" 307 | ); 308 | }); 309 | it(`Ao passar os argumentos 70, 1.75, deve retornar: 310 | 'Seu IMC é: 22.9 kg/m2. O Resultado foi: Normal'.`, () => { 311 | expect(IMC(70, 1.75)).toBe( 312 | "Seu IMC é: 22.9 kg/m2. O Resultado foi: Normal" 313 | ); 314 | }); 315 | it(`Ao passar o argumento 90, 1.75, deve retornar: 316 | 'Seu IMC é: 29.4 kg/m2. O Resultado foi: Sobrepeso'.`, () => { 317 | expect(IMC(90, 1.75)).toBe( 318 | "Seu IMC é: 29.4 kg/m2. O Resultado foi: Sobrepeso" 319 | ); 320 | }); 321 | it(`Ao passar o argumento 100, 1.75, deve retornar: 322 | 'Seu IMC é: 32.7 kg/m2. O Resultado foi: Obesidade'.`, () => { 323 | expect(IMC(100, 1.75)).toBe( 324 | "Seu IMC é: 32.7 kg/m2. O Resultado foi: Obesidade" 325 | ); 326 | }); 327 | }); 328 | 329 | describe(" 13 - Testando a Função chessRating.", () => { 330 | it(`Ao passar os argumentos 1500 e 2000, deve retornar: 331 | 'Enxadrista1: 1510 pontos. Enxadrista2: 1990 pontos.'.`, () => { 332 | expect(chessRating(1500, 2000)).toBe( 333 | "Enxadrista1: 1510 pontos. Enxadrista2: 1990 pontos." 334 | ); 335 | }); 336 | it(`Ao passar os argumentos 1500, 1600, deve retornar: 337 | 'Enxadrista1: 1520 pontos. Enxadrista2: 1580 pontos.'.`, () => { 338 | expect(chessRating(1500, 1600)).toBe( 339 | "Enxadrista1: 1520 pontos. Enxadrista2: 1580 pontos." 340 | ); 341 | }); 342 | }); 343 | 344 | describe(" 14 - Testando a Função ATM.", () => { 345 | it("Ao passar os argumento 10 e xablau, deve retornar: 'Valor de saldo inválido'", () => { 346 | expect(ATM(10, "xablau")).toBe("Valor de saldo inválido"); 347 | }); 348 | it("Ao passar os argumentos 10 e 0, deve retornar: 'Valor de saldo inválido'", () => { 349 | expect(ATM(10, 0)).toBe("Valor de saldo inválido"); 350 | }); 351 | it("Ao passar os argumentos 0, 10, deve retornar: 'Saldo insuficiente'", () => { 352 | expect(ATM(0, 10)).toBe("Saldo insuficiente"); 353 | }); 354 | it(`Ao passar os argumentos 50, 32, deve retornar: 355 | 'Valor inválido para as notas disponíveis: R$10, R$50, R$100'`, () => { 356 | expect(ATM(50, 32)).toBe( 357 | "Valor inválido para as notas disponíveis: R$10, R$50, R$100" 358 | ); 359 | }); 360 | it("Ao passar os argumentos 20, 10 , deve retornar: 'Saque efetuado! Novo saldo: R$10'", () => { 361 | expect(ATM(20, 10)).toBe("Saque efetuado! Novo saldo: R$10"); 362 | }); 363 | }); 364 | 365 | describe(" 15 - Testando a Função rockPaperScissors.", () => { 366 | it("Ao passar os argumentos 'paper' e 'rock', deve retornar: 'Player 1 won'", () => { 367 | expect(rockPaperScissors("paper", "rock")).toBe("Player 1 won"); 368 | }); 369 | it("Ao passar os argumentos 'rock' e 'scissors', deve retornar: 'Player 1 won'", () => { 370 | expect(rockPaperScissors("rock", "scissors")).toBe("Player 1 won"); 371 | }); 372 | it("Ao passar os argumentos 'scissors' e 'paper', deve retornar: 'Player 1 won'", () => { 373 | expect(rockPaperScissors("scissors", "paper")).toBe("Player 1 won"); 374 | }); 375 | it("Ao passar os argumentos 'paper' e 'paper', deve retornar: 'A Ties'", () => { 376 | expect(rockPaperScissors('paper', 'paper')).toBe("A Ties"); 377 | }); 378 | it("Ao passar os argumentos 'rock', 'paper', deve retornar: 'Player 2 won'", () => { 379 | expect(rockPaperScissors("rock", "paper")).toBe("Player 2 won"); 380 | }); 381 | }); 382 | 383 | describe(" 16 - Testando a Função sortAgeAsc.", () => { 384 | it("Ao passar os argumentos 18, 19 e 20 , deve retornar: '18, 19, 20'", () => { 385 | expect(sortAgeAsc(18, 19, 20)).toBe("18, 19, 20"); 386 | }); 387 | it("Ao passar os argumentos 20, 19, 18, deve retornar: '18, 19, 20'", () => { 388 | expect(sortAgeAsc(20, 19, 18)).toBe("18, 19, 20"); 389 | }); 390 | it("Ao passar o argumento 19, 18, 20, deve retornar: '18, 19, 20'", () => { 391 | expect(sortAgeAsc(19, 18, 20)).toBe("18, 19, 20"); 392 | }); 393 | }); 394 | 395 | describe(" 17 - Testando a Função oddOreEven.", () => { 396 | it("Ao passar os argumentos 2, 2, 0, deve retornar: 'Ana venceu'", () => { 397 | expect(oddOreEven(2, 2, 0)).toBe("Ana venceu"); 398 | }); 399 | it("Ao passar os argumentos 2, 2, 1, deve retornar: 'Lúcio venceu'", () => { 400 | expect(oddOreEven(2, 2, 1)).toBe("Lúcio venceu"); 401 | }); 402 | it("Ao passar os argumentos 2, 1, 1, deve retornar: 'Ana venceu'", () => { 403 | expect(oddOreEven(2, 1, 1)).toBe("Ana venceu"); 404 | }); 405 | it("Ao passar os argumentos 2, 1, 0, deve retornar: 'Lúcio venceu'", () => { 406 | expect(oddOreEven(2, 1, 0)).toBe("Lúcio venceu"); 407 | }); 408 | }); 409 | 410 | describe(" 18 - Testando a Função cardsGame.", () => { 411 | it("Ao passar os argumentos 10, 10, 5, 5, deve retornar: 'Mara venceu com 40 pontos'", () => { 412 | expect(cardsGame(10, 10, 5, 5)).toBe("Mara venceu com 40 pontos"); 413 | }); 414 | it("Ao passar os argumentos 10, 11, 11, 115, deve retornar: 'Mara venceu com 63 pontos'", () => { 415 | expect(cardsGame(10, 11, 11, 11)).toBe("Mara venceu com 63 pontos"); 416 | }); 417 | it("Ao passar os argumentos 5, 5, 10, 10, deve retornar: 'Sara venceu com 40 pontos'", () => { 418 | expect(cardsGame(5, 5, 10, 10)).toBe("Sara venceu com 40 pontos"); 419 | }); 420 | it("Ao passar os argumentos 2, 12, 11, 12, deve retornar: 'Sara venceu com 69 pontos'", () => { 421 | expect(cardsGame(12, 12, 11, 12)).toBe("Sara venceu com 69 pontos"); 422 | }); 423 | it("Ao passar os argumentos 12, 12, 12, 12, deve retornar: 'O jogo empatou'", () => { 424 | expect(cardsGame(12, 12, 12, 12)).toBe("O jogo empatou"); 425 | }); 426 | it("Ao passar os argumentos 11, 12, 11, 12, deve retornar: 'O jogo empatou'", () => { 427 | expect(cardsGame(11, 12, 11, 12)).toBe("O jogo empatou"); 428 | }); 429 | }); 430 | }); 431 | --------------------------------------------------------------------------------