Estou com dificuldades de arrays, funções, retorno

Front-end
, ,
#1

Olá boa tarde. Tenho uma lista de exercícios para praticar mais sobre arrays, funções e retornos e tenho uma dúvida que não estou conseguindo como vou colocar os arrays. A pergunta é a seguinte:

Desenvolva uma função chamada dominantePet que receba um parâmetro:

  1. list, um array de strings contendo as palavras “dog” ou “cat” escritas sem um padrão definido.

E deve retornar uma string com o tipo de bichinho que aparece mais vezes no array, ou seja, a dominante maiúscula e com uma exclamação (“CAT!” ou “DOG!”). Se a quantidade dos dois for a mesma, deve retornar a string “DRAW!”.

Exemplo:

dominantPet(["DoG", "cat", "cAT", "dOg", "cat", "Dog", "caT"]
⁠// Deve retornar:
⁠// "CAT!"

eu fiz assim:

function dominanPet(lista) {
    let c = 0
    let um = []
    let s = " "

    for (let i = 0; i < lista.lenght; i++)
        s += lista[i]
    if (lista[i] === "gato" || lista [i] === "gato" || lista[i] === "cAt" || lista[i] === "caT") {
        a.push(s)
    } else if (lista[i] === "cachorro" || lista [i] === "cachorro" || lista[i] === "dOg" || lista[i] === " cão") {
        a.push(s)
    } else {
        console.log(("DRAW"))
    }
    
    return s
}

console.log(dominanPet(["DoG", "cat", "cAT", "dOg", "cat", "Dog", "caT"]))
#2

Fala igor. Bem vindo! cara, eu dei uma ajustada no seu codigo e coloquei alguns comentários:

function dominanPet(animalList) {
    //lista de possíveis formas de poder "ler" gatos
    const catVariantsList = ["gato", "cat"]

    //lista de possíveis formas de poder "ler" cachorros
    const dogVariantsList = ["cachorro", "cão", "dog"]

    //filtra a lista de animais, e verifica se nessa lista inclui algum dos termos de gato ["gato", "cat"]
    const catList = animalList.filter(animal => catVariantsList.includes(animal.toLowerCase()))

    //filtra a lista de animais, e verifica se nessa lista inclui algum dos termos de cachorro ["cachorro", "cão", "dog"]
    const dogList = animalList.filter(animal => dogVariantsList.includes(animal.toLowerCase()))

    //se a lista de gatos for maior que a lista de cachorros, retorna gato
    if (catList.length > dogList.length) {
        return "CAT!"
    }

    //se a lista de cachorros for maior que a lista de gatos, retorna cachorro
    if (dogList.length > catList.length) {
        return "DOG!"
    }

    //se a qtd na lista de gatos e cachorros forem iguais, retorna cachorro
    if (catList.length === dogList.length) {
        return "DRAW!"
    }
}

//criamos a lista de animais
const animalList = ["DoG", "cat", "cAT", "dOg", "cat", "Dog", "caT", "dog"];

// chamamos a função dominanPet, passando a lista de animais
const result = dominanPet(animalList);

//imprimimos o resultado
console.log(result);

Tirei a necessidade de usar o loop e mudei pra o filter, o código fica mais limpo e mais simples de entender.

Obs: usei o .toLowerCase(), pra deixar todos os itens com a mesma escrita. Aí elimina o DoG, dOg, doG… no fim vira só “dog”

Caso queira usar o for mesmo assim

function dominanPet(animalList) {
    const catVariantsList = ["gato", "cat"]
    const dogVariantsList = ["cachorro", "cão", "dog"]
    const qtdDogs = [];
    const qtdCats = [];

    for (let i = 0; i < animalList.length; i++) {
        const animal = animalList[i];

        if (catVariantsList.includes(animal.toLowerCase())) {
            qtdCats.push(animal);
        }
        if (dogVariantsList.includes(animal.toLowerCase())) {
            qtdDogs.push(animal);
        }
    }

    if (qtdDogs.length > qtdCats.length) {
        return "dog";
    }
    
    if (qtdCats.length > qtdDogs.length) {
        return "cat";
    }

    if (qtdCats.length === qtdDogs.length) {
        return "draw";
    }
}
#3

Obrigado mesmo! Vou ver aqui como vai ficar. Muito obrigado!

#4

Reparou que tanto no if quanto no else if você faz a mesma coisa? Ou seja, se for gato ou cachorro, vc faz exatamente a mesma ação: adiciona s no array a. Não faz o menor sentido.

Se quer saber quantos gatos e quantos cachorros têm ali, então precisa ter dois contadores separados. Depois, você compara os contadores:

function dominantePet(animals) {
    // variações, coloque todas que forem necessárias
    var catVariants = ["gato", "cat"];
    var dogVariants = ["cachorro", "cão", "dog"];

    // um contador para cada tipo de animal
    var dogs = 0;
    var cats = 0;
    for (var animal of animals) {
        // converte para minúscula, assim não precisa testar milhares de variações
        animal = animal.toLowerCase();
        // use includes para saber se o animal está no array, e adicione o respectivo contador
        if (catVariants.includes(animal)) {
            cats++;
        } else if (dogVariants.includes(animal)) {
            dogs++;
        }
    }
    if (cats > dogs) {
        return "CAT!"
    } else if (dogs > cats) {
        return "DOG!"
    } else { // se não entrou em nenhum dos if's acima, é porque são iguais, então nem precisa testar
        return "DRAW!"
    }
}

const animals = ["DoG", "cat", "cAT", "dOg", "cat", "Dog", "caT", "dog"];
console.log(dominantePet(animals));

Claro que com filter também dá (como foi sugerido acima), mas cuidado com essa história de que “tira a necessidade de usar o loop”. Ele pode até “tirar” o loop do código, mas lembre-se que um filter no fundo também é um loop, só que “escondido”. Ele percorre o array da mesma forma que o for, a única diferença é que você não precisou escrever o loop.

Outro detalhe é que ao chamar filter duas vezes, você está percorrendo o array duas vezes. E cada chamada de filter retorna outro array contendo os elementos filtrados. Mas nesse caso você só quer saber a quantidade, então eu acho desnecessário criar esses arrays extras só para pegar o tamanho. Fazer um único loop como eu fiz acima, e manter apenas os contadores (em vez de criar outros arrays só para pegar o tamanho) me parece bem mais simples.

Claro que para um exercício simples e/ou para poucos arrays pequenos rodando poucas vezes, não fará tanta diferença assim. Mas se tivesse que verificar vários tipos diferentes de animais, com arrays maiores (milhares/milhões de elementos), aí começaria a fazer diferença (veja aqui).

Ah, também corrigi o nome da função para dominantePet (faltou um “te” antes do “P”) :slight_smile:

2 curtidas
#6

Beleza, obrigado mesmo. Vou ajeitar aqui os erros.