├── index.js
├── Desafios
├── produto.js
├── fatorial.js
├── escada.js
├── arvoreUtopica.js
├── professoraFuriosa.js
├── maisMenos.js
└── professoraFuriosa2.js
├── Lógica básica
├── variables.js
├── functions.js
├── loops.js
├── array_vectors.js
└── conditionals.js
└── README.md
/index.js:
--------------------------------------------------------------------------------
1 | alert ("Hello world!");
--------------------------------------------------------------------------------
/Desafios/produto.js:
--------------------------------------------------------------------------------
1 | // Desafio 02: Produto
2 | // Necessitamos uma função produto que receba um array de números e retorne o produto: o resultado de multiplicar todos os elementos entre si.
3 | // Por exemplo, produto([1, 4, 7]) deve retornar 28, que é 1 * 4 * 7.
4 | // Resolução:
5 | function produto(arrDeNumeros) {
6 | var resultado = 1; //Recebe 1 que será o multiplicador da primeira posição do array;
7 | for (var i = 0; i < arrDeNumeros.length; i++) { //Enquanto iteração for menor que o tamanho do array, faça mais um loop;
8 | resultado *= arrDeNumeros[i]; //resultado = 1 * primeira posição do array;
9 | }
10 | return resultado; //retorna a soma total de todas as posições do array;
11 | }
12 |
13 | console.log(produto([2, 4, 7]));
14 | console.log(produto([4, 2, 5]));
15 |
16 |
--------------------------------------------------------------------------------
/Desafios/fatorial.js:
--------------------------------------------------------------------------------
1 | // Desafio 03: Fatorial
2 | // Escreva uma função fatorial, que calcule o fatorial de um número.
3 | // Resolução:
4 | function fatorial(numero) {
5 | if (numero < 0) { //Se for menor que zero:
6 | return "O valor não pode ser negativo!"
7 | } else if (numero == 0 || numero == 1) { //Se for zero ou 1;
8 | return 1; //O Fatorial é igual 1;
9 | } else {
10 | resultado = 1; // Variável de multiplicação inicial;
11 | for (var i = numero; i > 1; i--) { //Enquanto o número for maior que 1, faça numero - 1 e repita o loop;
12 | resultado *= i; //resultado é igual a o número vezes o valor já alocado na variável;
13 | }
14 | }
15 | return resultado; //retorne o total depois da iterações;
16 | }
17 | console.log(fatorial(5));
18 | console.log(fatorial(0));
19 | console.log(fatorial(-2));
20 |
--------------------------------------------------------------------------------
/Desafios/escada.js:
--------------------------------------------------------------------------------
1 | // Desafio 05: Escada
2 | // Queremos representar uma escada com altura variável, utilizando um array de strings.
3 | // Por exemplo, uma escada com altura 3, representaremos com o seguinte array:
4 | // var escada3 = [
5 | // " #",
6 | // " ##",
7 | // "###"
8 | // ]
9 | // Escreva uma função escada que utilize uma altura (um número) e retorne um array que represente a escada correspondente. Não esqueça que o espaço " " faz parte da resposta.
10 | // Resolução:
11 | function escada(tamanhoDaEscada) {
12 | var totalDegraus = []; //Array vazio que receberá o tamanho total da escada;
13 |
14 | for (let i = 1; i <= tamanhoDaEscada; i++) { //Enquanto iteração for menor que o tamanhoDaEscada, faça mais um loop;
15 | var degraus = " ".repeat(tamanhoDaEscada - i) + "#".repeat(i); //A Variável degraus recebe a quantidade de espaços e a quantidade de # de acordo com o loop;
16 | totalDegraus.push(degraus); //Adiciona o que foi recebido pela variável graus no tamanho total da escada;
17 | }
18 | return totalDegraus; //Retorna um array com o tamanho total da escada;
19 | };
20 |
21 | console.log(escada(2));
22 |
23 |
--------------------------------------------------------------------------------
/Desafios/arvoreUtopica.js:
--------------------------------------------------------------------------------
1 | // Desafio 06: Árvore Utópica
2 | // As árvores utópicas crescem de uma forma particular, em dois ciclos:
3 | // cada primavera dobram seu tamanho
4 | // cada verão crescem um metro
5 | // Se Laura planta uma árvore utópica com um metro, no final do outono, qual seria sua altura depois de N ciclos?
6 | // Alguns exemplos:
7 | // si N = 0, sua altura será 1 metro(não cresceu nada)
8 | // si N = 1, sua altura será de 2 metros(dobrou a altura na primavera)
9 | // si N = 2, sua altura será de 3 metros(cresceu um metro mais no verão)
10 | // si N = 3, sua altura será de 6 metros(dobrou a altura na primavera seguinte)
11 | // Escreva a função alturaArvoreUtopica, que utilize uma quantidade de ciclos de crescimento, e retorne a altura resultante da árvore de Laura.
12 | // Resolução:
13 | function alturaArvoreUtopica(nCiclos) {
14 | let tamanhoArvore = 1; //Tamanho incial da árvore / 1 metro;
15 | for (let i = 0; i < nCiclos; i++) //Enquanto iteração for menor que o nCiclos, repita o loop;
16 | if (i & 1) //Se iteração for 1, faça:
17 | tamanhoArvore += 1; //tamanhoArvore = tamanhoArvore + 1;
18 | else //Se não:
19 | tamanhoArvore *= 2; //tamanhoArvore = tamanhoArvore * 2;
20 | return tamanhoArvore; //Retorne o tamanho depois das condições;
21 | }
22 | console.log(alturaArvoreUtopica(3));
23 |
--------------------------------------------------------------------------------
/Desafios/professoraFuriosa.js:
--------------------------------------------------------------------------------
1 | // Desafio 01: Professora Furiosa
2 | // Escreva as seguintes funções: 1. acontece, que diz se a aula sucederá de acordo com o array dos estudantes que entraram. 2. aberturas, que utiliza um array
3 | // com os arrays dos estudantes que entraram nos outros dias, e a quantidade mínima de estudantes, e diga quais os dias
4 | // em que as aulas aconteceram e quais não.Por exemplo:
5 | // acontece(alunosDaSegunda, 2)
6 | // true
7 | // aberturas([alunosDaSegunda, alunosDaTerça, alunosDaQuarta], 2)
8 | // [true, false, false]
9 | // Resolução:
10 | var alunosDaSegunda = [10, -5, 3, 0];
11 | var alunosDaTerca = [5, 7, -5, 1];
12 | var alunosDaQuarta = [-10, -2, -5, 4];
13 |
14 | function acontece(arr, num) {
15 | if (arr.length < num) {
16 | return false;
17 | }
18 |
19 | let presentes = 0;
20 | for (let i = 0; i < arr.length; i++) {
21 | if (arr[i] <= 0) {
22 | presentes += 1;
23 | }
24 | }
25 |
26 | return (presentes >= num);
27 | }
28 | console.log(acontece(alunosDaSegunda, 2));
29 |
30 | function aberturas(arr, num) {
31 | let arrAcontece = [];
32 | for (let i = 0; i < arr.length; i++) {
33 | arrAcontece.push(acontece(arr[i], num));
34 | }
35 |
36 | return arrAcontece;
37 | }
38 | console.log(aberturas([alunosDaSegunda, alunosDaTerca, alunosDaQuarta], 3));
39 |
--------------------------------------------------------------------------------
/Lógica básica/variables.js:
--------------------------------------------------------------------------------
1 | // Exercício 01:
2 | // Declare e atribuia duas variáveis, uma com o seu nome e outra com o seu sobrenome, e então na variável nomeCompleto mantenha tudo junto.
3 | // Exemplo: "Cesar Michelin"
4 | // Resolução:
5 | var nome = "Michel";
6 | var sobrenome = "Bernardo";
7 | var nomeCompleto = (nome + " " + sobrenome);
8 | console.log(nomeCompleto);
9 |
10 | //Exercício 02:
11 | // Declarar e atribuir três variáveis, uma com o seu 'nome', outra com o seu 'sobrenome' e outra com a sua 'idade'.
12 | // Então, declare uma variável com nome resultado e atribua uma string unindo suas variaveis da seguinte forma: " João Silva terá 30 anos"
13 | // e utilize o console.log pra mostrar o que acontece. Respeite os espaços!
14 | // Resolução:
15 | var nome = "João";
16 | var sobrenome = "Silva";
17 | var idade = 30;
18 | var resultado = (nome + " " + sobrenome + " terá " + idade + " anos");
19 | console.log(resultado);
20 |
21 | //Exercício 03:
22 | // Defina duas variáveis: umNumeroPequeno e umNumeroGrande, e atribua a elas valores numéricos diferentes de acordo com seus nomes.
23 | // Então defina a variável eMenor e atribua o resultado da comparação se umNumeroPequeno é menor do que umNumeroGrande; e defina a variável eMaior,
24 | // com o resultado da comparação umNumeroPequeno é maior que umNumeroGrande.
25 | // Resolução:
26 | var umNumeroPequeno = 2;
27 | var umNumeroGrande = 10;
28 | var eMenor = umNumeroPequeno < umNumeroGrande;
29 | var eMaior = umNumeroPequeno > umNumeroGrande;
30 | console.log(eMenor);
31 | console.log(eMaior);
32 |
--------------------------------------------------------------------------------
/Desafios/maisMenos.js:
--------------------------------------------------------------------------------
1 | // Desafio 04: Mais Menos (Porcentagem de elementos)
2 | // Necessitamos uma função maisMenos que receba um array e retorne outro com os seguintes três números:
3 | // na primeira posição, a fração de números que são positivos
4 | // na segunda posição, a fração de números que são zero
5 | // na última posição, a fração de números que são negativos
6 | // Por exemplo, maisMenos([1, 2, 0, -1]) deveria retornar[0.5, 0.25, 0.25], devido a que há 50 % de positivos, 25 % de zeros, e 25 % de negativos.
7 | // Resolução:
8 | function maisMenos(arrayNumeros) {
9 | var quantidade = arrayNumeros.length; //Variável que guarda a quantidade números o array
10 | var positivos = 0; //Variável que conta os números positivos
11 | var zeros = 0; //Variável que conta o o número 0
12 | var negativos = 0; //Variável que conta os números negativos
13 |
14 | for (var contador = 0; contador < quantidade; contador++) { //Enquanto contador for menor que a quantidade repita o loop
15 | if (arrayNumeros[contador] < 0) { //Se qualquer elemento do array for menor que zero:
16 | negativos += 1; //Adiciona esse elemento dentro da variável negativos
17 | } else if (arrayNumeros[contador] > 0) { //Se qualquer elemento do array for maior que zero:
18 | positivos += 1; //Adiciona esse elemento dentro da variável positivos
19 | } else { //Se não for nenhum dos casos anteriores,
20 | zeros += 1; //Adiciona o elemento na variável zeros
21 | }
22 | }
23 | //Com os elementos já alocados corretamente faça as operações:
24 | positivos = positivos / quantidade;
25 | zeros = zeros / quantidade;
26 | negativos = negativos / quantidade;
27 | //Array que recebe os números já operados
28 | var total = [positivos, zeros, negativos];
29 | return total;
30 | }
31 | console.log(maisMenos([1, 2, 0, -1, 0, 0, 1, 2]))
32 |
--------------------------------------------------------------------------------
/Desafios/professoraFuriosa2.js:
--------------------------------------------------------------------------------
1 | // Desafio 01: Professora Furiosa
2 | // Escreva as seguintes funções:
3 | // 1. acontece, que diz se a aula sucederá de acordo com o array dos estudantes que entraram.
4 | // 2. aberturas, que utiliza um array
5 | // com os arrays dos estudantes que entraram nos outros dias, e a quantidade mínima de estudantes, e diga quais os dias
6 | // em que as aulas aconteceram e quais não.Por exemplo:
7 | // acontece(alunosDaSegunda, 2)
8 | // true
9 | // aberturas([alunosDaSegunda, alunosDaTerça, alunosDaQuarta], 2)
10 | // [true, false, false]
11 | // Minha Resolução:
12 | var alunosDaSegunda = [10, -5, 3, 0];
13 | var alunosDaTerca = [5, 7, -5, 1];
14 | var alunosDaQuarta = [-10, -2, -5, 4];
15 |
16 | function acontece(estudantes, quantidadeParaAula) {
17 | let pontuais = 0; //variável que recebe os alunos que chegaram na hora correta
18 |
19 | for (let i = 0; i < estudantes.length; i++) { //Enquanto iteração for menor que o array de estudantes, faça mais um loop
20 | if (estudantes[i] >= 0) { //Se o elemento dentro do array for maior ou igual a zero:
21 | pontuais += 1; //Adiciona o elemento na variáevl pontuais
22 | }
23 | }
24 |
25 | return (pontuais >= quantidadeParaAula); //Retorne verdadeiro se pontuais for maior ou igual que a quantidade de alunos necessários para aula
26 | }
27 | console.log(acontece(alunosDaSegunda, 2));
28 |
29 |
30 | function aberturas(diasDaSemana, quantidadeParaAula) {
31 | let relatorio = []; ///variável irá retornar os valores booleanos
32 | for (let i = 0; i < diasDaSemana.length; i++) { //Enquanto iteração for menor que o array, faça mais um loop
33 | relatorio.push(acontece(diasDaSemana[i], quantidadeParaAula)); //Relatório recebe um booleano resultado da função acontece
34 | }
35 |
36 | return relatorio; //Retorna o array depois da iterações (Com o resultado final)
37 | }
38 | console.log(aberturas([alunosDaSegunda, alunosDaTerca, alunosDaQuarta], 2));
39 |
--------------------------------------------------------------------------------
/Lógica básica/functions.js:
--------------------------------------------------------------------------------
1 | // Exercício 01:
2 | // Escreva a função multiplicar que receba dois parâmetros, multiplique-os e retorne o resultado da multiplicação.
3 | // Resolução:
4 | function multiplicar(numero1, numero2) {
5 | return numero1 * numero2;
6 | };
7 | console.log(multiplicar(5, 10));
8 |
9 | // Exercício 02:
10 | // Agora pedimos que você declare uma função chamada triploDaSoma() que recebe dois parâmetros. Então você tem que adicionar ambos e retornar
11 | // três vezes o valor do resultado da soma dos dois parâmetros . Será preciso declarar a função triplo,
12 | // que recebe um parâmetro e retorna o valor dele multiplicado por três.
13 | // Resolução:
14 | function triplo(num1) {
15 | return num1 * 3;
16 | };
17 | function triploDaSoma(numero1, numero2) {
18 | var soma = numero1 + numero2;
19 | return triplo(soma);
20 | };
21 | console.log(triploDaSoma(3, 2));
22 | console.log(triploDaSoma(4, 5));
23 |
24 | // Exercício 03:
25 | // Vamos criar uma função perimetro que nos diga o perímetro de um círculo quando damos a ele o raio como parâmetro.
26 | // Também a função area que nos dá a área de um círculo quando recebe o raio como parâmetro.
27 | // Lembre-se de usar o valor de 3.14 no lugar do π . perimetro = π * raio * 2; area = π * raio * raio;
28 | // Resolução:
29 | function perimetro(raio) {
30 | return 3.14 * raio * 2;
31 | };
32 | console.log(perimetro(4));
33 | function area(raio) {
34 | return 3.14 * raio * raio;
35 | };
36 | console.log(area(4));
37 |
38 | // Exercício 04:
39 | // Escreva a função escreverCartao, que recebe como parâmetros um título, um nome e um sobrenome e retorna uma única string como resultado.
40 | // Resolução:
41 | function escreverCartao(titulo, nome, sobrenome) {
42 | var informacoes = titulo + " " + nome + " " + sobrenome;
43 | return informacoes;
44 | };
45 |
46 | console.log(escreverCartao('Dra.', 'Ana', 'Pérez'));
47 | console.log(escreverCartao('Dr.', 'Julio', 'Gelman'));
48 |
49 | // Exercício 05s:
50 | // Escreva uma função gerarProbabilidade(), que não recebe parâmetros e retorna a porcentagem de probabilidade de chuva, calculada aleatoriamente usando Math.random ().
51 | // Resolução:
52 | function gerarProbabilidade() {
53 | return Math.random() * 100;
54 | };
55 | console.log(gerarProbabilidade(0.5));
56 |
--------------------------------------------------------------------------------
/Lógica básica/loops.js:
--------------------------------------------------------------------------------
1 | // Exercício 01:
2 | // Faça uma função chamada imprimirAzul4 que mostre 4 vezes a palavra Azul.
3 | // Resolução:
4 | function imprimirAzul4() {
5 | for (var i = 0; i < 4; i++) {
6 | console.log("Azul");
7 | };
8 | };
9 | imprimirAzul4();
10 |
11 | // Exercício 02:
12 | // Execute uma função chamada imprimir5vezes5 que mostra no console 5 vezes o número 5.
13 | // Resolução:
14 | function imprimir5vezes5() {
15 | for (var i = 0; i < 5; i++) {
16 | console.log(5);
17 | };
18 | };
19 | imprimir5vezes5();
20 |
21 | // Exercício 03:
22 | // Escreva uma função passoAPasso, que imprime 5 vezes o conteúdo de i.
23 | // Resolução:
24 | function passoAPasso() {
25 | for (var i = 0; i <= 4; i++) {
26 | console.log(i);
27 | };
28 | };
29 | passoAPasso();
30 |
31 | // Exercício 04:
32 | // Execute uma função chamada passandoPelosPares() que mostra pelo console aqui eu tenho o valor de x para cada valor PAR que percorra i de 0 até e inclusive 6.
33 | // Resolução:
34 | function passandoPelosPares() {
35 | for (var i = 0; i <= 6; i++) {
36 | if (i % 2 == 0) {
37 | console.log("aqui eu tenho o valor de " + i);
38 | }
39 | };
40 | };
41 | passandoPelosPares();
42 |
43 | // Exercício 05:
44 | // Escreva uma função somar5MoedasDe25Centavos, que adiciona o valor de 5 moedas de 0,25 centavos e retorna o resultado.
45 | // Resolução:
46 | var totalMoedas = 0;
47 | function somar5MoedasDe25Centavos() {
48 | for (var i = 0; i < 5; i++) {
49 | totalMoedas = totalMoedas + 0.25;
50 | };
51 | return totalMoedas;
52 | };
53 | console.log(somar5MoedasDe25Centavos());
54 |
55 | // Exercício 06:
56 | // Escreva uma função somarMoedasDe25(quantidadeDeMoedas), que toma como parâmetro um valor numérico e retorna a soma das moedas de 25 centavos.
57 | // Resolução:
58 | function somarMoedasDe25(quantidadeDeMoedas) {
59 | var totalMoedas = 0;
60 | for (var i = 0; i < quantidadeDeMoedas; i++) {
61 | totalMoedas = totalMoedas + 0.25;
62 | };
63 | return totalMoedas;
64 | };
65 | console.log(somarMoedasDe25(1));
66 | console.log(somarMoedasDe25(10));
67 |
68 | // Exercício 07:
69 | // Defina a função somaDosPares(x) que retorna a soma total de todos os números que são pares, ou seja, divisíveis por 2 obtendo resto 0.
70 | // Desta forma: 0 + 2 + 4 + 6 + 8 + 10 + ..... X
71 | // Resolução:
72 | function somaDosPares(x) {
73 | var somaTotal = 0;
74 | for (var i = 0; i <= x; i++) {
75 | if (i % 2 == 0) {
76 | somaTotal = somaTotal + i;
77 | }
78 | };
79 | return somaTotal;
80 | };
81 | console.log(somaDosPares(20));
82 |
83 | // Exercício 08:
84 | // Defina a função chamada somatoria, que receba como parâmetro um número e retorne a soma dos números antecessores a ele.
85 | // Resolução:
86 | function somatoria(numeroX) {
87 | var somaTudo = 0;
88 | for (var i = 0; i < numeroX; i++) {
89 | somaTudo = somaTudo + i;
90 | }
91 | return somaTudo;
92 | }
93 | console.log(somatoria(4));
94 | console.log(somatoria(5));
95 |
96 | // Exercício 09:
97 | // Crie uma função chamada caloriasDeTrote(), que recebe por parâmetro o número de voltas representado por um valor numérico e retorne a quantidade de calorias que será consumida.
98 | // Resolução:
99 | function caloriasDeTrote(numeroVoltas) {
100 | var totalCalorias = 0;
101 | var calorias = 5;
102 | for (var i = 0; i <= numeroVoltas; i++) {
103 | totalCalorias = totalCalorias + (calorias * i);
104 | };
105 | return totalCalorias;
106 | };
107 | console.log(caloriasDeTrote(2));
108 |
--------------------------------------------------------------------------------
/Lógica básica/array_vectors.js:
--------------------------------------------------------------------------------
1 | // Exercício 01:
2 | // Crie uma variável do tipo array chamada pertences que contém as strings "espada","escudo","crossbow" e imprima o array utilizando o console.log.
3 | // Utilize o método push para adicionar a string "cross", após adicionar a string imprima o array novamente com o console.log.
4 | // Resolução:
5 | var pertences = ["espada", "escudo", "crossbow"];
6 | console.log(pertences);
7 | pertences.push("cross");
8 | console.log(pertences);
9 |
10 | // Exercício 02:
11 | // Declarar uma função chamada “mover”, que recebe dois arrays, remove o último elemento do primeiro e adiciona-o ao segundo.
12 | // Resolução:
13 | var umArray = [1, 2, 3];
14 | var outroArray = [4, 5];
15 | function mover(x, y) {
16 | y.push(x.pop());
17 | };
18 | mover(umArray, outroArray);
19 | console.log(umArray);
20 | console.log(outroArray);
21 |
22 | // Exercício 03:
23 | // Escreva a função contem(array, numero) que nos diz se um array contém um determinado elemento.
24 | // Resolução:
25 | function contem(array, numero) {
26 | for (var i = 0; i <= array.length; i++) {
27 | if (array.indexOf(numero) != -1) {
28 | return true;
29 | } else {
30 | return false;
31 | };
32 | };
33 | };
34 | console.log(contem(umArray, 2));
35 |
36 | // Exercício 04:
37 | // Escreva a função “medalhaDeAcordoComPosto(numero)”, que recebe um número como parâmetro. Usando apenas o máximo de um “if” apenas.
38 | // Resolução:
39 | var medalhas = ["ouro", "prata", "bronze"];
40 |
41 | function medalhaDeAcordoComPosto(numero) {
42 | if (numero > medalhas.length) {
43 | return "nada"
44 | } else {
45 | return medalhas[numero - 1];
46 | };
47 | };
48 | console.log(medalhaDeAcordoComPosto(1));
49 |
50 | // Exercício:
51 | // Complete a função quantidadeDeMesesComLucro.
52 | // function quantidadeDeMesesComLucro(umPeriodo) {
53 | // var quantidade = ????;
54 | // for (let mes = 0; mes < umPeriodo.length; mes++) {
55 | // ????
56 | // }
57 | // return quantidade;
58 | // }
59 | // Resolução:
60 | var trimestre = [50, 200, -10];
61 | function quantidadeDeMesesComLucro(umPeriodo) {
62 | let quantidade = 0;
63 | for (let mes = 0; mes < umPeriodo.length; mes++) {
64 | if (umPeriodo[mes] > 0) {
65 | quantidade = quantidade + 1;
66 | };
67 | };
68 | return quantidade;
69 | };
70 | console.log(quantidadeDeMesesComLucro(trimestre));
71 |
72 | // Exercício 05:
73 | // Escreva a função quantidadeDeMesesComPerda
74 | // Resolução:
75 | function quantidadeDeMesesComPerda(umPeriodo) {
76 | let quantidade = 0;
77 | for (let mes = 0; mes < umPeriodo.length; mes++) {
78 | if (umPeriodo[mes] < 0) {
79 | quantidade = quantidade + 1;
80 | };
81 | };
82 | return quantidade;
83 | };
84 | console.log(quantidadeDeMesesComPerda(trimestre));
85 |
86 | // Exercício 06:
87 | // Escreva a função saldoDeMesesComLucro. Você pode usar a mesma estrutura do exercício dos exercícios anteriores.
88 | // Resolução:
89 | function saldoDeMesesComLucro(umPeriodo) {
90 | let saldo = [];
91 | for (let mes = 0; mes < umPeriodo.length; mes++) {
92 | if (umPeriodo[mes] > 0) {
93 | saldo.push(umPeriodo[mes]);
94 | };
95 | };
96 | return saldo;
97 | };
98 | console.log(saldoDeMesesComLucro(trimestre));
99 |
100 | // Exercício 07:
101 | // Queremos escrever uma função naipeDeTruco, que dado um naipe, devolva uma lista de strings, uma por cada carta desse naipe seguindo as cartas do truco.
102 | // Lembre-se que as cartas de truco incluem todas as cartas numeradas de 1 a 12, com exceção das cartas 8 e 9.
103 | // Resolução:
104 | function naipeDeTruco(naipe) {
105 | return ["1", "2", "3", "4", "5", "6", "7", "10", "11", "12"].map(function (tipo) {
106 | return [tipo, naipe].join(' de ');
107 | });
108 | }
109 | console.log(naipeDeTruco('espadas'));
110 | console.log(naipeDeTruco('copas'));
111 |
112 |
--------------------------------------------------------------------------------
/Lógica básica/conditionals.js:
--------------------------------------------------------------------------------
1 | // Exercício 01:
2 | // Declara a variável diaDeSemana que receba uma string "domingo". Depois implemente uma condicional usando o if que compare se
3 | // diaDeSemana é igual a "domingo", se for verdadeiro imprima uma string "Hoje é dia de futebol!!!".
4 | // Resolução:
5 | var diaDeSemana = "domingo";
6 | if (diaDeSemana == "domingo") {
7 | console.log("Hoje é dia de futebol! ! !");
8 | };
9 |
10 | // Exercício 02:
11 | // Define a função hojeSeJoga, que receba por parâmetro uma string que informe o día da semana. Esta função deve retornar"Hoje é dia de futebol!!!"
12 | // se parâmetro for "domingo", caso contrário deve retornar "Hoje não é dia de futebol :(".
13 | // Resolução:
14 | function hojeSeJoga(diaDaSemana) {
15 | if (diaDaSemana == "domingo") {
16 | return ("Hoje é dia de futebol! ! !");
17 | } else {
18 | return ("Hoje não é dia de futebol :(");
19 | };
20 | };
21 | console.log(hojeSeJoga("domingo"));
22 | console.log(hojeSeJoga("terça"));
23 |
24 | // Exercício 03:
25 | // Defina a função eMaior, que recebe dois números por parâmetro, e retorna o maior entre eles.
26 | // Resolução:
27 | function eMaior(numero1, numero2) {
28 | if (numero1 > numero2) {
29 | return numero1 + " é maior";
30 | } else {
31 | return numero2 + " é maior";
32 | };
33 | };
34 | console.log(eMaior(10, 8));
35 |
36 | // Exercício 04:
37 | // Podemos dizer que é um número da sorte se o número: 1-é positivo 2-é um múltiplo de 2 ou 3 3-não é 15
38 | // Escreva a função eNumeroDaSorte que, recebendo um número, diz se é um número da sorte (true). Lembre-se de que o número deve
39 | // obedecer às três condições mencionadas. Seu desafio adicional será: NÃO use o if.
40 | // Resolução:
41 | function eNumeroDaSorte(numero1) {
42 | return numero1 >= 1 && numero1 % 2 == 0 && numero1 != 15;
43 | }
44 | console.log(eNumeroDaSorte(4));
45 |
46 | // Exercício 05:
47 | // Defina a função possoIrAoBanco que, receba dois parâmetros, o primeiro é diaDaSemana (string) e o
48 | // segundo horaAtual(numero), a função deve retornar true, apenas se o banco estiver aberto.
49 | // Resolução:
50 | function possoIrAoBanco(diaDaSemana, horaAtual) {
51 | return diaDaSemana != "Sábado" && diaDaSemana != "Domingo" && horaAtual >= 9 && horaAtual <= 15;
52 | };
53 | console.log(possoIrAoBanco("Terça", 10));
54 | console.log(possoIrAoBanco('Sábado', 11));
55 | console.log(possoIrAoBanco('Domingo', 13));
56 |
57 | // Exercício 06:
58 | // Defina a função filosofoHipster que recebe como parâmetro: a profissão de uma pessoa (string), nacionalidade (string)
59 | // e o número de quilômetros que ele anda por dia (número). Com esses parâmetros avalie se essa pessoa é ou não (true / false), um filósofo Hipster.
60 | // Tenha em mente que um filósofo Hipster é um Músico, nascido no Brasil e que gosta de andar mais de 2 quilômetros por dia.
61 | // Resolução:
62 | function filosofoHipster(profissao, nacionalidade, kmDia) {
63 | return profissao == "Músico" && nacionalidade == "Brasil" && kmDia >= 5;
64 | };
65 | console.log(filosofoHipster('Músico', 'Brasil', 5));
66 | console.log(filosofoHipster('Jogador de futebol', 'Alemanha', 12));
67 | console.log(filosofoHipster('Músico', 'Argentina', 1));
68 |
69 | // Exercício 07:
70 | // Escreva a função podeSeAposentar que recebe por parâmetro a idade, o sexo e os anos de contribuição previdenciária que uma pessoa tem.
71 | // Tenha em mente que a idade mínima para se aposentar para mulheres é 60 anos, enquanto que para homens é 65. Em ambos os casos, você deve ter pelo menos 30 anos de contribuição.
72 | // Resolução:
73 | function podeSeAposentar(idade, sexo, anosContribuicao) {
74 | return idade >= 60 && sexo == "F" && anosContribuicao >= 30 || idade >= 65 && sexo == "M" && anosContribuicao >= 30;
75 | };
76 | console.log(podeSeAposentar(62, "M", 34));
77 |
78 | // Exercício 08:
79 | // Defina a função podeSubir, recebendo 3 parâmetros: alturaPessoa (numero), vemComCompania (booleano), temProblemaCardiaco (booleano), retorne true ou false
80 | // conforme o caso. Levar em conta as condições necessárias mencionadas acima.
81 | // Condições: 1- Atingir a altura mínima de 1,5 m (ou 1,2 m, se acompanhada por um adulto) 2- Não ter qualquer problema cardíaco.
82 | // Resolução:
83 | function podeSubir(alturaPessoa, vemComCompania, temProblemaCardiaco) {
84 | return alturaPessoa >= 1.5 && temProblemaCardiaco == false || alturaPessoa >= 1.2 && vemComCompania == true && temProblemaCardiaco == false;
85 | };
86 | console.log(podeSubir(1.7, false, true));
87 | console.log(podeSubir(1.2, true, false));
88 |
89 | // Exercício 09:
90 | // Defina a função medalhaSegundoOPosto que recebe o posto como parâmetro e retorna um texto de acordo com o parâmetro. Dica: nessa função você pode usar vários if.
91 | // Resolução:
92 | function medalhaSegundoOPosto(posto) {
93 | if (posto == 1) {
94 | return "ouro"
95 | };
96 | if (posto == 2) {
97 | return "prata"
98 | };
99 | if (posto == 3) {
100 | return "bronze"
101 | } else {
102 | return "Continue participando"
103 | };
104 | };
105 | console.log(medalhaSegundoOPosto(1));
106 | console.log(medalhaSegundoOPosto(2));
107 | console.log(medalhaSegundoOPosto(3));
108 | console.log(medalhaSegundoOPosto(5));
109 |
110 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Banco de questões em JS
2 |
3 | 
4 |
5 |
6 | Introdução
7 |
8 | Esse repositório foi criado com o objetivo de compartilhar questões de lógica de programação com JS. As questões dispobilizadas aqui serão resolvidas e as resoluções se econtrarão dentro do repositório. A ideia é fazer com que você pratique tentando resolver as questões sem antes consultar as resoluções. Bons estudos!
9 |
10 | ## Sumário
11 | > * [Variáveis](#variáveis)
12 | > * [Funções](#funções)
13 | > * [Condicionais](#condicionais)
14 | > * [Laços de repetição](#laços)
15 | > * [Arrays](#arrays)
16 | > * [Desafios](#desafios)
17 | > * [Resoluções](#resoluções)
18 |
19 | Questões
20 |
21 | ### Variáveis
22 |
23 | 1 - Declare e atribuia duas variáveis, uma com o seu nome e outra com o seu sobrenome, e então na variável nomeCompleto mantenha tudo junto. Exemplo: "Cesar Michelin"
24 |
25 | 2 - Declare e atribua três variáveis, uma com o seu 'nome', outra com o seu 'sobrenome' e outra com a sua 'idade'. Então, declare uma variável com nome resultado e atribua uma string unindo suas variaveis da seguinte forma: " João Silva terá 30 anos" e utilize o console.log pra mostrar o que acontece. Respeite os espaços!
26 |
27 | 3 - Defina duas variáveis: umNumeroPequeno e umNumeroGrande, e atribua a elas valores numéricos diferentes de acordo com seus nomes. Então defina a variável eMenor e atribua o resultado da comparação se umNumeroPequeno é menor do que umNumeroGrande; e defina a variável eMaior, com o resultado da comparação umNumeroPequeno é maior que umNumeroGrande.
28 |
29 | ### Funções
30 |
31 | 1 - Escreva a função multiplicar que receba dois parâmetros, multiplique-os e retorne o resultado da multiplicação.
32 |
33 | 2 - Declare uma função chamada triploDaSoma() que recebe dois parâmetros. Então você tem que adicionar ambos e retornar três vezes o valor do resultado da soma dos dois parâmetros . Será preciso declarar a função triplo, que recebe um parâmetro e retorna o valor dele multiplicado por três.
34 |
35 | 3 - Vamos criar uma função perimetro que nos diga o perímetro de um círculo quando damos a ele o raio como parâmetro e também a função area que nos dá a área de um círculo quando recebe o raio como parâmetro. Lembre-se de usar o valor de 3.14 no lugar do π . perimetro = π * raio * 2; area = π * raio * raio;
36 |
37 | 4 - Escreva a função escreverCartao, que recebe como parâmetros um título, um nome e um sobrenome e retorna uma única string como resultado.
38 |
39 | 5 - Escreva uma função gerarProbabilidade(), que não recebe parâmetros e retorna a porcentagem de probabilidade de chuva, calculada aleatoriamente usando Math.random ().
40 |
41 | ### Condicionais
42 |
43 | 1 - Declara a variável diaDeSemana que receba uma string "domingo". Depois implemente uma condicional usando o if que compare se diaDeSemana é igual a "domingo", se for verdadeiro imprima uma string "Hoje é dia de futebol!!!".
44 |
45 | 2 - Defina a função hojeSeJoga, que receba por parâmetro uma string que informe o día da semana. Esta função deve retornar "Hoje é dia de futebol!!!" se parâmetro for "domingo", caso contrário deve retornar "Hoje não é dia de futebol :(".
46 |
47 | 3 - Defina a função eMaior, que recebe dois números por parâmetro, e retorna o maior entre eles.
48 |
49 | 4 - Escreva a função eNumeroDaSorte que, recebendo um número, diz se é um número da sorte (true). Podemos dizer que é um número da sorte se o número: 1-é positivo. 2-é um múltiplo de 2 ou 3. 3-não é 15. Lembre-se de que o número deve obedecer às três condições mencionadas. Seu desafio adicional será: NÃO use o if.
50 |
51 | 5 - Defina a função possoIrAoBanco que, receba dois parâmetros, o primeiro é diaDaSemana (string) e o segundo horaAtual(numero), a função deve retornar true, apenas se o banco estiver aberto.
52 |
53 | 6 - Defina a função filosofoHipster que recebe como parâmetro: a profissão de uma pessoa (string), nacionalidade (string) e o número de quilômetros que ele anda por dia (número). Com esses parâmetros avalie se essa pessoa é ou não (true / false), um filósofo Hipster. Tenha em mente que um filósofo Hipster é um Músico, nascido no Brasil e que gosta de andar mais de 2 quilômetros por dia.
54 |
55 | 7 - Escreva a função podeSeAposentar que recebe por parâmetro a idade, o sexo e os anos de contribuição previdenciária que uma pessoa tem.Tenha em mente que a idade mínima para se aposentar para mulheres é 60 anos, enquanto que para homens é 65. Em ambos os casos, você deve ter pelo menos 30 anos de contribuição.
56 |
57 | 8 - Defina a função podeSubir, recebendo 3 parâmetros: alturaPessoa (numero), vemComCompania (booleano), temProblemaCardiaco (booleano), retorne true ou false conforme o caso. Levar em conta as condições necessárias mencionadas acima.
58 |
59 | 9 - Defina a função medalhaSegundoOPosto que recebe o posto como parâmetro e retorna um texto de acordo com o parâmetro. Dica: nessa função você pode usar vários if.
60 |
61 | ### Laços
62 |
63 | 1 - Faça uma função chamada imprimirAzul4 que mostre 4 vezes a palavra Azul.
64 |
65 | 2 - Execute uma função chamada imprimir5vezes5 que mostra no console 5 vezes o número 5.
66 |
67 | 3 - Escreva uma função passoAPasso, que imprime 5 vezes o conteúdo de i.
68 |
69 | 4 - Execute uma função chamada passandoPelosPares() que mostra pelo console aqui eu tenho o valor de x para cada valor PAR que percorra i de 0 até e inclusive 6.
70 |
71 | 5 - Escreva uma função somar5MoedasDe25Centavos, que adiciona o valor de 5 moedas de 0,25 centavos e retorna o resultado.
72 |
73 | 6 - Escreva uma função somarMoedasDe25(quantidadeDeMoedas), que toma como parâmetro um valor numérico e retorna a soma das moedas de 25 centavos.
74 |
75 | 7 - Defina a função somaDosPares(x) que retorna a soma total de todos os números que são pares, ou seja, divisíveis por 2 obtendo resto 0.
76 |
77 | 8 - Defina a função chamada somatoria, que receba como parâmetro um número e retorne a soma dos números antecessores a ele.
78 |
79 | 9 - Crie uma função chamada caloriasDeTrote(), que recebe por parâmetro o número de voltas representado por um valor numérico e retorne a quantidade de calorias que será consumida.
80 |
81 | ### Arrays
82 |
83 | 1 - Crie uma variável do tipo array chamada pertences que contém as strings "espada","escudo","crossbow" e imprima o array utilizando o console.log. Utilize o método push para adicionar a string "cross", após adicionar a string imprima o array novamente com o console.log.
84 |
85 | 2 - Declarar uma função chamada “mover”, que recebe dois arrays, remove o último elemento do primeiro e adiciona-o ao segundo.
86 |
87 | 3 - Escreva a função contem(array, numero) que nos diz se um array contém um determinado elemento.
88 |
89 | 4 - Escreva a função “medalhaDeAcordoComPosto(numero)”, que recebe um número como parâmetro. Usando apenas o máximo de um “if” apenas.
90 |
91 | 5 - Escreva a função quantidadeDeMesesComPerda
92 |
93 | 6 - Escreva a função saldoDeMesesComLucro. Você pode usar a mesma estrutura do exercício dos exercícios anteriores.
94 |
95 | 7 - Queremos escrever uma função naipeDeTruco, que dado um naipe, devolva uma lista de strings, uma por cada carta desse naipe seguindo as cartas do truco. Lembre-se que as cartas de truco incluem todas as cartas numeradas de 1 a 12, com exceção das cartas 8 e 9.
96 |
97 | ### Desafios
98 |
99 | 1 - Escreva as seguintes funções:
100 |
101 | 1. acontece, que diz se a aula sucederá de acordo com o array dos estudantes que entraram.
102 |
103 | 2. aberturas, que utiliza um array com os arrays dos estudantes que entraram nos outros dias, e a quantidade mínima de estudantes, e diga quais os dias em que as aulas aconteceram e quais não.
104 |
105 | Por exemplo:
106 |
107 |
108 | acontece(alunosDaSegunda, 2)
109 | true
110 |
111 | aberturas([alunosDaSegunda, alunosDaTerça, alunosDaQuarta], 2)
112 | [true, false, false]
113 |
114 |
115 | 2 - Necessitamos uma função produto que receba um array de números e retorne o produto: o resultado de multiplicar todos os elementos entre si. Por exemplo, produto([1, 4, 7]) deve retornar 28, que é 1 * 4 * 7.
116 |
117 | 3 - Escreva uma função fatorial, que calcule o fatorial de um número.
118 |
119 | 4 - Necessitamos uma função maisMenos que receba um array e retorne outro com os seguintes três números:
120 |
121 | 1. na primeira posição, a fração de números que são positivos
122 |
123 | 2. na segunda posição, a fração de números que são zero
124 |
125 | 3. na última posição, a fração de números que são negativos
126 |
127 | Por exemplo, maisMenos([1, 2, 0, -1]) deveria retornar[0.5, 0.25, 0.25], devido a que há 50 % de positivos, 25 % de zeros, e 25 % de negativos.
128 |
129 | 5 - Escreva uma função escada que utilize uma altura (um número) e retorne um array que represente a escada correspondente. Não esqueça que o espaço " " faz parte da resposta. Queremos representar uma escada com altura variável, utilizando um array de strings. Por exemplo, uma escada com altura 3, representaremos com o seguinte array:
130 |
131 |
132 |
133 | var escada3 = [
134 | " #",
135 | " ##",
136 | "###"
137 | ]
138 |
139 |
140 |
141 | 6 - Escreva a função alturaArvoreUtopica, que utilize uma quantidade de ciclos de crescimento, e retorne a altura resultante da árvore de Laura. As árvores utópicas crescem de uma forma particular, em dois ciclos:
142 | 1- cada primavera dobram seu tamanho
143 | 2- cada verão crescem um metro
144 | Se Laura planta uma árvore utópica com um metro, no final do outono, qual seria sua altura depois de N ciclos? Alguns exemplos:
145 |
146 | si N = 0, sua altura será 1 metro(não cresceu nada)
147 |
148 | si N = 1, sua altura será de 2 metros(dobrou a altura na primavera)
149 |
150 | si N = 2, sua altura será de 3 metros(cresceu um metro mais no verão)
151 |
152 | si N = 3, sua altura será de 6 metros(dobrou a altura na primavera seguinte)
153 |
154 | ### Resoluções
155 |
156 | 1 - Clique na pasta: Lógica.
157 |
158 | 2 - Encontre a questão de acordo com o tópico.
159 |
--------------------------------------------------------------------------------