Bem-vindos à nossa comunidade!

Junte-se a nós e faça parte hoje mesmo!

Aula: Lista de exercícios: Fundamentos, Estruturas de controle e Funções

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 08 - Por quê o if não faz a comparação das pontuações?

É porque faltou um parseInt nas comparações dos ifs.

Isso pode ser corrigido da seguinte maneira:

JavaScript:
function avaliaPontuacoes () {
    let stringPontuacoes = "30, 40, 20, 4, 51, 25, 42, 38, 56, 0"
    let pontuacoes = stringPontuacoes.split(", ")
    let maiorPontuacao = pontuacoes[0]
    let menorPontuacao = pontuacoes[0]
    let qtdQuebraDeRecords = 0
    let piorJogo = 1


    for (let i = 1; i < pontuacoes.length; i++) {
        if(parseInt(pontuacoes[i]) > parseInt(maiorPontuacao)){
            maiorPontuacao = pontuacoes[i]
            qtdQuebraDeRecords++
        }else if(parseInt(pontuacoes[i]) < parseInt(maiorPontuacao)) {
            menorPontuacao = pontuacoes[i]
            piorJogo = i+1;
        }
    }
    return [qtdQuebraDeRecords, piorJogo]
}

console.log(avaliaPontuacoes())
 
Last edited:

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Okay, isso tudo é muito legal, incrível que agora funciona com o parseInt!

Mas por quê é necessário usar esse parseInt afinal de contas?

É que nesse caso o problema não é que ele retorna ou não um Array, mas sim porque ele retorna valores em String.

Daí, quando feita as comparações, às vezes ele dá uma bug e afirma coisas como 20 < 13, sabe? Então, para resolver isso, pegamos o valor retornado e fazemos em cima dele um parseInt, que vai receber uma String e retornar um inteiro com aquele valor.

Ele recebe um "20" que seria uma String com o valor 20, e retorna o Number 20, e agora as comparações funcionam corretamente!
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 09 - Dúvidas nas notas que devem ser arredondadas

De acordo com o enunciado da questão, temos as seguintes condições:
  • Alunos com nota abaixo de 40 são reprovados;
  • Se a diferença entre a nota e o próximo múltiplo de 5 for menor que 3, arredondar a nota para esse próximo múltiplo de 5;
  • Se a nota for abaixo de 38, não é feito nenhum arredondamento pois esta nota resulta na reprovação do aluno.
  • No caso de a nota ser 38, o arredondamento é possível pois atingirá 40 e o aluno será aprovado.
Pela interpretação do enunciado, tiramos que as notas maiores que 40 podem ainda sofrer o arredondamento.

Considerando essas condições, é elaborado o código:
JavaScript:
function classificaAluno(nota) {
    if (nota >= 38){
        let notaCorrigida = arredondar(nota)
        if (notaCorrigida >= 40) {
             console.log(`Aprovado com nota ${notaCorrigida}`);
            }
    }else{
        console.log(`Reprovado com nota ${nota}`);
    }
}

function arredondar (nota) {
    if (nota % 5 > 2) {
        return nota + (5 - (nota % 5))
    } else {
        return nota
    }
}

classificaAluno(100)
classificaAluno(21)
classificaAluno(28)
classificaAluno(30)
classificaAluno(38)
classificaAluno(88)
classificaAluno(61)
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 19 - Indo além, usando ARRAYS e calculando o valor pago por toda comanda

O colega Guilherme compartilhou sua solução lá na Udemy e resolvi trazer para cá a solução dele desse exercício.

A ideia dele foi de montar um sistema que permitisse o cálculo do valor de toda a comanda, e não apenas dos itens, além de apresentar uma lista com os valores para a conferência do "cliente" e apontar os itens que não foram encontrados e não somá-los na conta total do cliente.

Segue a solução dele:

JavaScript:
    const padraoReal = new Intl.NumberFormat('pt-BR',{style: 'currency', currency: 'BRL'})
    
    const catalogo = {
        100 : ['Cachorro Quente', 3.00],
        200 : ['Hambúrguer Simples', 4.00],
        300 : ['Cheeseburguer', 5.50],
        400 : ['Bauru', 7.50],
        500 : ['Refrigerante', 3.50],
        600 : ['Suco', 2.80]
    }
    
    let pedidoCliente = [
        [00, 2],
        [900, 5],
        [500, 5],
        [600, 2]
    ]
    
    const getNome = (catalogo, codigo) => {
        if(catalogo[codigo]) {
            return catalogo[codigo][0]
        } else {
            return 'Produto não cadastrado'
        }
    }
    
    const getPreco = (catalogo, codigo) => {
        if(catalogo[codigo]) {
           return catalogo[codigo][1]   
        } else {
            return 0
        }
    }
    
    const valorItem = (catalogo, [cod, num]) => {
        let valor = getPreco(catalogo, cod)
            return valor * num 
    }
    
    const somarComanda = (catalogo, pedidoCliente) => {
        return pedidoCliente.map(item => valorItem(catalogo, item))
                            .reduce((total, item) => total + item)
    }
    
    const conferirPedidos = (catalogo, pedidoCliente) => {
        return pedidoCliente.map(item => `${item[1]} x ${getNome(catalogo, item[0])} = ${padraoReal.format(valorItem(catalogo, item))}`)
                            .reduce((total, item) => total +'\n'+ item )
    }
    
    let valorComanda = padraoReal.format(somarComanda(catalogo, pedidoCliente))
    
    console.log(conferirPedidos(catalogo, pedidoCliente))
    console.log('Total = ' + valorComanda)
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 20 - Usando Array, map, filter e Reduce

Também pelo colega Guilherme, ele sugeriu uma solução para o exercício 20 usando arrays, maps, filters e reduce!

Achei bem interessante e resolvi compartilhar por aqui também.

Segue a solução dele:


JavaScript:
    function notas(valor) {
        let notasDe100 = Math.floor(valor / 100)
        let restoDe100 = valor % 100
        
        let notasDe50 = Math.floor(restoDe100 / 50)
        let restoDe50 = restoDe100 % 50
        
        let notasDe10 = Math.floor(restoDe50 / 10)
        let restoDe10 = restoDe50 % 10
        
        let notasDe5 = Math.floor(restoDe10 / 5)
        let restoDe5 = restoDe10 % 5
        
        let notasDe1 = restoDe5
        
        let arrayNotas = [[notasDe100, 100], [notasDe50, 50], [notasDe10, 10], [notasDe5, 5], [notasDe1, 1]]
        return arrayNotas.filter(item => item[0]> 0)
                         .map(item => `${item[0]} nota(s) de R$ ${item[1]}.`)
                         .reduce((total, item) => total + ' ' + item)
    }
    
    let numNotas = notas(153)
    
    console.log(numNotas)
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
O que significa o any nos parâmetros de uma função?

Eu tenho pra mim que todo mundo tem essa dúvida mas ninguém nunca tem coragem de perguntar. Eu mesma aprendi hoje o que era o tal do any kkkkk

A dúvida veio da questão 05 dessa lista. Ao passar o mouse por cima do parâmetro valorDecimal, o aluno viu que mostrava valorDecimal: any. Mas o que é esse any?

Acontece que
esse any pode ser literalmente qualquer coisa. É um tipo qualquer, pois a linguagem JavaScript é fracamente tipada, então se você passasse quaisquer valor para esse valorDecimal, ele ia aceitar.

Observe também que valorDecimal não foi inicializada anteriormente com um valor (por exemplo, valorDecimal = 0 diria que é um Number, valorDecimal = ' ' diria que é uma String).

Isso ocorre para que possam ser chamados qualquer métodos nele sem ocasionar erros de compilação!

É mais um jeito de JavaScript ser a linguagem mãezona que tenta rodar seus códigos a todo custo kkkkkk
 
Cadastro
15/2/21
Postagens
13
Curtidas
12
Pontuação
21
Cidade
Mundo Mágico de Oz - SP
Exercício 20 - Usando Array, map, filter e Reduce

Também pelo colega Guilherme, ele sugeriu uma solução para o exercício 20 usando arrays, maps, filters e reduce!

Achei bem interessante e resolvi compartilhar por aqui também.

Segue a solução dele:


JavaScript:
    function notas(valor) {
        let notasDe100 = Math.floor(valor / 100)
        let restoDe100 = valor % 100
       
        let notasDe50 = Math.floor(restoDe100 / 50)
        let restoDe50 = restoDe100 % 50
       
        let notasDe10 = Math.floor(restoDe50 / 10)
        let restoDe10 = restoDe50 % 10
       
        let notasDe5 = Math.floor(restoDe10 / 5)
        let restoDe5 = restoDe10 % 5
       
        let notasDe1 = restoDe5
       
        let arrayNotas = [[notasDe100, 100], [notasDe50, 50], [notasDe10, 10], [notasDe5, 5], [notasDe1, 1]]
        return arrayNotas.filter(item => item[0]> 0)
                         .map(item => `${item[0]} nota(s) de R$ ${item[1]}.`)
                         .reduce((total, item) => total + ' ' + item)
    }
   
    let numNotas = notas(153)
   
    console.log(numNotas)
Olá Raquel, boa noite.

Dei um upgrade nesta questão, para criar uma função que permita encontrar o número de notas para qualquer valores diferentes de notas.

Consegui criar esta solução, acho que ficou bem legal:


JavaScript:
function notas(valor, notasDisponiveis = [100, 50, 10, 5, 1]) {
    let resto = valor
    
    function calcularNumNotas(nota) {
        let numNotas = [Math.floor(resto / nota), nota]
        resto = resto % nota
        return numNotas
    }
    return notasDisponiveis.sort((a, b) => a < b ? 1 : -1)
                           .map(calcularNumNotas)
                           .filter(item => item[0]> 0)
                           .map(item => `${item[0]} nota(s) de R$ ${item[1]}.`)
                           .reduce((total, item) => total + ' ' + item)
}
let numNotas = notas(242)
let numNotas2 = notas(253, [100, 20, 5, 2])
console.log(numNotas)
console.log(numNotas2)

Porém, ao criar esta solução, surgiu uma dúvida quanto a função 'calcularNumNotas(nota).

Criei esta função para ela entrar no map e retornar o numero de notas dentro de um array. Porém, constatei que ela precisa ficar dentro da função notas. Acredito que isto ocorra devido ela precisar da variável chamada resto.

Como eu faço para deixar esta função externa (fora da função notas)?

Para por exemplo, eu acessá-la em outra função?

Só consegui pensar na situação de eu tornar o resto externo (à função notas) também, mas não queria fazer isto, pois acho que isso poderia expor muito as variaveis.
 

mourabraz

Membro
Moderador
Cadastro
23/12/20
Postagens
113
Curtidas
158
Pontuação
100
Cidade
Leiria
@Guilherme Frade bom dia! Se me permites posso sugerir o uso de parâmetros. Se quiser isolar uma função, verifique se esse artifício não resolveria.


Se ficar preso posta o que você tentou fazer, que tento ajudar melhor.

Abraços!
 
Cadastro
15/2/21
Postagens
13
Curtidas
12
Pontuação
21
Cidade
Mundo Mágico de Oz - SP
Consegui fazer o upgrade com a função externa.
Só que não consegui usar os parâmetros conforme você explicou. Usei um array. Não sei se é a melhor forma, mas está funcionando!
JavaScript:
function calcularNumNotas(nota, arrayValor) {
    let numNotas = [Math.floor(arrayValor[arrayValor.length - 1] / nota), nota]
    arrayValor.push(arrayValor[arrayValor.length - 1] % nota)
    return numNotas
}
function notas(valor, notasDisponiveis = [100, 50, 10, 5, 1]) {
    let arrayValor = [valor]
    return notasDisponiveis.sort((a, b) => a < b ? 1 : -1)
                           .map(item => calcularNumNotas(item, arrayValor))
                           .filter(item => item[0]> 0)
                           .map(item => `${item[0]} nota(s) de R$ ${item[1]}.`)
                           .reduce((total, item) => total + ' ' + item)
}
let numNotas = notas(242)
let numNotas2 = notas(253, [100, 20, 5, 2, 1])

console.log(numNotas)
console.log(numNotas2)
 

mourabraz

Membro
Moderador
Cadastro
23/12/20
Postagens
113
Curtidas
158
Pontuação
100
Cidade
Leiria
@Guilherme Frade boa noite! Na minha opinião ficou muito legal.

O que quis dizer com usar parâmetros foi o que vc fez, não pensei necessáriamente numa solução como a sua (agora nem consigo imaginar como faria senão como você implementou)

Os parametros de uma função são essas variáveis internas da função que recebem seus valores por ocasião da sua invocação. Podem ser de qualquer tipo como number, string, boolean, Arrays, Objects... até mesmo podem ser outras funções.

A ideia de se usar parâmetros seria a de não depender de valores referenciados externamente à função e passar o que for necessário no momento em que se invoca a função, ganhando independência do código externo. Onde quer que você precise você pode usar essa função, pois ela só depende do que vc passa para ela no momento em que o seu resultado é necesário.

Abraços.
 
Cadastro
15/2/21
Postagens
13
Curtidas
12
Pontuação
21
Cidade
Mundo Mágico de Oz - SP
Sobre o exercicio 7:
Fui além e criei uma função capaz de encontrar todas as raízes pertencente aos reais para qualquer polinômio.
Segue a resolução:

JavaScript:
function funcao(x, vetorPolinomial) {  //vetor polinomial: Exemplo: [c, b, a] ==> ax² + bx + c = y OU [d, c, b, a] ==> ax³ + bx² + cx + d = y
    let resultado = 0
    for(let i = 0; i < vetorPolinomial.length; i++){
        resultado += vetorPolinomial[i] * (x ** i)
    }
    return resultado
}
function raizesFuncao(funcao, entrada, inicio, fim) {
    let y = 0
    let x = new Set     //Um tipo de Lista que não permite repetição
    for(let i = inicio; i <= fim; i += 0.00001) {
        y = Math.abs(funcao(i, entrada).toFixed(2))      
        if(y == 0){
            x.add(Number(i.toFixed(2)))
        }
    }
    let resultado =  [...x]
    if(!resultado[0]) {
        return 'Sem raízes neste intervalo'
    } else return resultado
}
console.log(raizesFuncao(funcao, [8, -10, 2], -10, 20))     //raizes  da função polinomial 2x² -10x + 8  = y
console.log(raizesFuncao(funcao, [1, -10, 5, 1], -10, 20))  //raizes da função polinomial 1x³ + 5x² -10x + 1 = y
 
Cadastro
15/2/21
Postagens
13
Curtidas
12
Pontuação
21
Cidade
Mundo Mágico de Oz - SP
@Guilherme Frade boa noite! Na minha opinião ficou muito legal.

O que quis dizer com usar parâmetros foi o que vc fez, não pensei necessáriamente numa solução como a sua (agora nem consigo imaginar como faria senão como você implementou)

Os parametros de uma função são essas variáveis internas da função que recebem seus valores por ocasião da sua invocação. Podem ser de qualquer tipo como number, string, boolean, Arrays, Objects... até mesmo podem ser outras funções.

A ideia de se usar parâmetros seria a de não depender de valores referenciados externamente à função e passar o que for necessário no momento em que se invoca a função, ganhando independência do código externo. Onde quer que você precise você pode usar essa função, pois ela só depende do que vc passa para ela no momento em que o seu resultado é necesário.

Abraços.
Ahh, agora eu entendi o que você quis dizer quanto a usar os parâmetros. Você quis dizer os parâmetros de entrada da função obviamente hahahaha. Exatamente o que eu acabei fazendo.
Na hora eu viajei e fiquei pesquisando se isso era alguma coisa que eu ainda não sabia. Mas no fim deu certo.
 
Cadastro
15/2/21
Postagens
13
Curtidas
12
Pontuação
21
Cidade
Mundo Mágico de Oz - SP
Exercício 38 - Propus uma versão diferente.
Para me desafiar, propus um exercício diferente. Criar uma função capaz de encontrar os números primos dentro de qualquer intervalo. (lembrando que 0 e 1 não são primos e o número 2 é o único primo par)

A resolução ficou conforme abaixo:

JavaScript:
function isPrime(num) {
    if(num == 0 || num == 1){
        return false
    }
    if(num == 2){
        return true
    }
    for(let i = 2; i < Math.abs(num); i++){
        if(num % i == 0){
            return false 
        }
    }
    return true
    
}

function primosNoIntervalo (min = 0, max = 100) {
    if(min > max) [min, max] = [max, min]
    
    let arrayPrimos = []
    
    for(let i = min; i <= max; i++){
        if(isPrime(i)){
            arrayPrimos.push(i)  
        }   
    }
    return arrayPrimos
}

console.log(primosNoIntervalo())
console.log(primosNoIntervalo(2, -100))
 
Cadastro
15/2/21
Postagens
13
Curtidas
12
Pontuação
21
Cidade
Mundo Mágico de Oz - SP
Exercício 39 - Achei a resolução mais difícil que minha solução, então vou compartilhar a minha aqui.
Especialmente porque é possível aplicar o conteúdo da aula 45 (destructuring) para facilitar a função.

JavaScript:
function inversaoVariaveis(vetorA, vetorB) {

    if(vetorA.length != vetorB.length) {
        return 'Vetores de tamanho diferentes.'
    } 
    for (let i = 0; i < vetorA.length; i++) {
        [vetorA[i], vetorB[i]] = [vetorB[i], vetorA[i]]
    }
    return [vetorA, vetorB]
}

let vetorA = [1, 2, 3, 4]
let vetorB = [2, 4, 6, 8]

console.log([vetorA, vetorB])
console.log('Invertendo ficou:')
console.log(inversaoVariaveis(vetorA, vetorB))
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 08 - Solução Alternativa

Lá na Udemy, recentemente, um aluno postou uma solução alternativa que eu resolvi trazer para vocês!
JavaScript:
let stringPontuacoes = "30 40 20 4 51 25 42 38 56 0"
let teste1 = '10 20 20 30 20 50 0'
let teste2 = '20 30 10 50 90 10 100 150 20 10 30 56 0'
let teste3 = '10 20'
 
let desempenho = (string) => {
    let melhorDesempenho = 0;
    let piorJogo = 0;
    let arrayConverter = string.split(' ');
    let firstScore = arrayConverter[0];
    let subsequente = firstScore;
    for (i = 0; i < arrayConverter.length; i++) {
        if (Number(arrayConverter[i]) > Number(subsequente)) {   
            subsequente = arrayConverter[i];   
            melhorDesempenho++;
        }
    }
    let convertNumber = arrayConverter.map(Number);
    let min = Math.min(...convertNumber)
    piorJogo = convertNumber.indexOf(min) + 1;
    console.log([melhorDesempenho, piorJogo]);
}
 
desempenho(stringPontuacoes);
desempenho(teste1);
desempenho(teste2);
desempenho(teste3);
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 12 - Fatorial

Respondi uma galera que teve dificuldade nessa questão, então resolvi trazer uns conceitos aqui que podem ajudar!

O cálculo de fatorial é um dos melhores exemplos que se tem de recursividade, que é quando uma função chama ela mesma, dentro dela mesma, até que um problema seja resolvido.

O fatorial de um número é calculado multiplicando esse número por todos os números antes dele, por exemplo, o fatorial de 4 (que fica 4! na notação é 4 * 3 * 2 * 1 que é 24, o fatorial de 3! é 3 * 2 * 1 que é 6, e por assim vai.

Então é por isso que na solução desse exercício é declarado uma função fatorial que recebe um parâmetro numero, onde se numero for igual a 0 o return é 1 (o fatorial de 0 é 1), e, caso contrário, retorna a multiplicação de numero * chamada da função novamente passando o valor de numero - 1.

Sugiro a leitura desse link aqui sobre recursividade.

Espero que assim fique mais fácil o entedimento dessa solução!
 

Raquel

Membro
Cadastro
24/9/20
Postagens
198
Curtidas
192
Pontuação
100
Exercício 34 - Explicando a solução

Recebi uma pergunta de um aluno que teve dificuldades de entender a solução desse exercício e passei a explicação passo a passo para ele. Resolvi trazer para cá, caso mais alguém tenha problemas com essa questão também!

JavaScript:
    function verificacaoDeString (string1, string2) { //recebe as duas strings
        let estaContido = true; //variável para verificar se os caracteres estao contidos nas duas strings
        for (let i = 0; i < string1.length; i++) { //loop que vai percorrer a primeira string (string1)
            let caractereString1 = string1.charAt(i).toLowerCase() //vai converter os caracteres da string1 para minusculo
            for(let j = 0; j < string2.length; j++){ //dentro do loop da string1, vai percorrer a string2
                let caractereString2 = string2.charAt(j).toLowerCase() //tal qual string1, vai converter os caracteres da string2 para minusculo
    
                if(caractereString1 == caractereString2) { //comparação dos caracteres da string1 e string2
                    estaContido = true //se, e somente se, as strings tiverem os mesmos caracteres, o estaContido continuará true
                    break //quebra do loop!
                } else { //caso contrário, se os caracteres não estiverem nas duas strings...
                    estaContido = false //estaContido é convertido para false!
                }
            }
            if(!estaContido) { //caso estaContido seja falso...
                console.log(estaContido) //imprime o valor de estaContido
                return estaContido //retorna o valor para a chamada da função
            }
        }
        console.log(estaContido) //imprime o valor true ou false
        return estaContido //retorna o valor de estaContido para a chamada da função
     }
    
     console.log(verificacaoDeString('abc','cba'))
     console.log(verificacaoDeString('abc','cdb'))
 
Top