Exercício – Letras repetidas

Neste exercício, temos um array composto de letras repetidas e uma letra isolada. Por exemplo, temos um array chamado vetor:

let vetor = ["a", "b", "a", "a", "c", "b"]

Aqui, temos:

vetor[0] = "a";
vetor[1] = "b";
vetor[2] = "a";
vetor[3] = "a";
vetor[4] = "c";
vetor[5] = "b";

Sabemos que a única letra que não possui repetição está na posição [4], elemento “c”. Então, precisamos retornar este elemento.

No nosso exercício, faremos:

  • Criaremos uma variável que terá o nosso vetor ordenado de forma crescente;
  • Criaremos uma variável chamada odd, que receberá futuramente o valor isolado;
  • Percorreremos o vetor ordenado;
  • Armazenaremos em variáveis o elemento atual e o próximo elemento;
  • Se o elemento atual for igual ao próximo, seguimos a iteração;
  • Senão, a variável odd recebe o valor isolado.

Você pode realizar o download da solução deste exercício aqui:

[download id=”4148″]

Exercício – Rotacionando vetor

Um vetor é um conjunto de dados que pode armazenar vários dados em apenas um lugar. Por exemplo, em um vetor, podemos armazenar uma lista de itens de, por exemplo, uma lista de compras.

Uma lista de compras armazenada em um vetor seria algo como:

let listaDeCompras = ["arroz", "massa", "carne", "alface"];

Um vetor também pode ser criado vazio e, depois, utilizando métodos de inserção, podemos inserir itens neste vetor.

let vetor = [];

Podemos inserir no vetor utilizando o método push(), e remover itens usando o método pop().

O método push() adiciona um valor ao fim do vetor, e o método pop() remove o elemento do final do vetor. Também temos outros métodos, por exemplo:

  • unshift(): adiciona um elemento na primeira posição do vetor;
  • shift(): remove o elemento na primeira posição do vetor.

Entre outros métodos. Você pode verificar os outros métodos em: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array

Exercício:

Neste exercício, criaremos uma função que rotaciona o nosso vetor. Levaremos em consideração as letras do alfabeto, de A a E.

let vetorAlfabeto = ["A", "B", "C", "D", "E"];

O que queremos que aconteça é: rotacionar o vetor a quantidade de vezes indicada. Essa quantidade será representada pela letra Q.

Caso o valor apresentado por Q for 1, o array deverá rotacionar um elemento:

["E", "A", "B", "C", "D"]

Para realizar esse exercício, você precisará:

  • Criar uma função rotacao(), que receberá dois parâmetros. O vetor e a quantidade (V, Q);
  • Adicione um índice para percorrer o vetor;
  • Caso o vetor passado por parâmetro for um vetor vazio, retorne um vetor vazio.

Solução:

Você pode fazer o download da solução aqui:

[download id=”4138″]

Como quebrar um vetor grande em vários menores

Neste artigo veremos duas funções que leem um vetor e devolvem um outro dividido em pedaços menores. O exemplo será bem simples pois a aplicação é a mesma para 5 o para 5 bilhões de registros. 

A primeira função será genérica e você provavelmente poderá utilizá-la em outras linguagens com pouca ou nenhuma adaptação. Já a segunda é utilizando mais das funções do JavaScript para reduzir o código

Em resumo queremos que um vetor linear seja quebrado em vários pequenos vetores. No meu caso, eu precisava que uma lista de contatos fosse quebrada em diversas listas menores para facilitar o controle e atualização das mesmas.

Iremos de algo assim:

let vetor = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14];

Para algo assim:

let vetor = [[0, 1, 2], 
             [3, 4, 5], 
             [6, 7, 8], 
             [9, 10, 11], 
             [12, 13, 14], 
             [15, 16]];

Como podemos fazer isso? Bom, a primeira forma é a seguinte:

Algoritmo Genérico

  1. Criar a função e inicializar as variáveis. Observe que novoVetor é um vetor com um vetor vazio dentro dele.
    function converterVetor(vetor, tamanho) {
        let novoVetor = [[]];
        let novoIndice = 0;
        let novoIndiceSub = 0;
    }
  2. Criar um laço FOR para adicionar os elementos no novoVetor. Observe que:
    1. Precisamos de um IF para testar a hora de avançar de um sub-vetor para outro.
    2. Dentro deste IF é necessário criar um vetor em branco para que o Javascript saiba o tipo do dado.
    3. No final, você está adicionando o valor dentro de um vetor que está dentro de outro vetor, então é preciso usar [x][y] para adicionar na posição correta.
    for(let indice = 0; indice < vetor.length; indice++){
    
        if(indice % tamanho == 0 && indice != 0){
            novoIndice++;
            novoVetor[novoIndice] = [];
            novoIndiceSub = 0;
        }
    
        novoVetor[novoIndice][novoIndiceSub] = vetor[indice];
        novoIndiceSub++;
    }
  3. Por ultimo, basta retornar o resultado. Veja abaixo o código completo.
    function converterVetor(vetor, tamanho) {
        let novoVetor = [[]];
        let novoIndice = 0;
        let novoIndiceSub = 0;
    
    
        for (let indice = 0; indice < vetor.length; indice++) {
    
            if (indice % tamanho == 0 && indice != 0) {
                novoIndice++;
                novoVetor[novoIndice] = [];
                novoIndiceSub = 0;
            }
    
            novoVetor[novoIndice][novoIndiceSub] = vetor[indice];
            novoIndiceSub++;
        }
    
        return novoVetor;
    }

Usando mais recursos JavaScript

Agora vejamos a mesma função, mas usando mais recursos JavaScript para reduzir um pouco o trabalho.

  1. Iniciaremos de forma muito parecida, mas precisaremos de uma variável a menos
    function converterVetor2(vetor, tamanho) {
        let index = 0;
        let novoVetor = [];
    }
  2. Agora faremos o loop for, mas ao invés de percorremos o loop original de 1 em 1, percorreremos o tamanho que já queremos colocar no sub-vetor.
    1. Dentro do loop, usaremos a função slice() que nos retornará um pedaço do vetor. Sendo ele o tamanho exato do sub-vetor.
    2. Após, adicionamos o subVetor ao novo com o método push() que adiciona um elemento na ultima posição.
    for (index = 0; index < vetor.length; index += tamanho) {
        let subVetor = vetor.slice(index, index + tamanho);
        novoVetor.push(subVetor);
    }
  3. Pronto!! Basta retornar o objeto com o resultado. Segue abaixo o código completo.
    function converterVetor2(vetor, tamanho) {
        let index = 0;
        let novoVetor = [];
    
        for (index = 0; index < vetor.length; index += tamanho) {
            let subVetor = vetor.slice(index, index + tamanho);
            novoVetor.push(subVetor);
        }
    
        return novoVetor;
    }

Conclusão

Como você pode ver, o segundo formato é um pouco menos detalhado, mas utilizando os recursos do JavaScript é possível escrever menos código que ainda é fácil de entender. Por isso que, quando você estuda uma linguagem, é importante conhecer as funções nativas e formas mais inteligentes de trabalhar com seus objetos.

Exercício Intermediário: multiplicando em FOR aninhado.

Uma tarefa muito comum em JavaScript é percorrer o conteúdo de um vetor. Você pode utilizar o loop FOR para isso. Lembre-se de que os vetores começam com o índice em 0, o que significa que o último elemento do vetor é o comprimento -1.

Se você tem um vetor multidimensional, você pode utilizar a mesma lógica do laço for para percorrer os vetores e os sub-vetores. Este é um exemplo:

let arr = [[1,2], [3,4], [5,6]];
for (let i=0; i < arr.length; i++) {
  for (let j=0; j < arr[i].length; j++) {
    console.log(arr[i][j]);
  }
}

Este laço de repetição aninhado percorre cada sub-elemento do sub-vetor por vez. Observe que, para percorrer o loop interno, estamos verificando o comprimento de arr[i], visto que arr[i] é, em si, um vetor.

EXERCÍCIO:

Modifique a função multiplicarTudo de modo que multiplique a variável produto por cada número nos sub-vetores do array:

function multiplicarTudo(arr) {
  let produto = 1;
  // Altere o código a partir desta linha

  // Altere o código até esta linha.
  return produto;
}

// Modifique os valores para testar o seu código.
multiplicarTudo ([[1,2],[3,4],[5,6,7]]);

RESULTADOS:

  • A função multiplicarTudo([[1],[2],[3]]) deve retornar 6;
  • A função multiplicarTudo([[1,2],[3,4],[5,6,7]]) deve retornar 5040;
  • A função multiplicarTudo([[5,1],[0.2,4, 0.5],[3,9]]) deve retornar 54;

Exercício Fácil: Soma de itens do vetor

Neste exercício, você terá que somar os valores de um vetor até a metade de seu tamanho e colocar a soma em um índice de um novo vetor.

Faça a soma também dos valores dos itens do vetor após a metade de seu tamanho. Coloque a soma em um índice do novo vetor.

Exemplo:

let vetor = [10, 20, 30, 40, 50, 60, 70, 80, 90];

Neste exemplo, temos um vetor de tamanho 9. Sabemos que a metade de 9 é 4.5, logo, devemos pegar todos os valores contidos em cada elemento que seja menor que a metade do tamanho do vetor. Neste caso, teremos a soma dos valores 10 + 20 + 30 + 40, que resulta em: 100.

O valor obtido, 100, deverá ser inserido na primeira posição de um novo vetor, que deverá ser criado.

let novoVetor = [];

Partindo para a próxima etapa do nosso exercício, devemos realizar a soma dos valores nos elementos restantes. Para isso, você deve realizar a soma dos elementos e inserir o resultado no índice do novo vetor. A soma dos elementos deve ser 50 + 60 + 70 + 80 + 90, que resulta em: 35.

O valor obtido, 350, deverá ser inserido na segunda posição do nosso novo vetor, que foi criado anteriormente.

O seu resultado deverá ser algo parecido como:

novoVetor = [100, 350];

Utilize o console.log() para mostrar o seus resultados.

DICA:

Para chegar no resultado correto, utilize o vetor.length -1 na sua condicional.

Você pode realizar este exercício da maneira que lhe convém, mas aconselhamos a utilizar uma estrutura condicional dentro de seu loop de repetição. Mas nada impede de você utilizar suas próprias maneiras para resolução deste exercício.

Você pode realizar a nossa resolução do exercício abaixo:

let vetor = [10, 20, 30, 40, 50, 60, 70, 80, 90];

let novo = [0, 0];

for (let indice = 0; indice < vetor.length; indice++) {
           
    if (indice < ((vetor.length-1) / 2)){
        novo[0] += vetor[indice];
           
    } else {
        novo[1] += vetor[indice];
    }
            
}
console.log(novo);

Gostou deste exercício? Comente o seu resultado e tire suas dúvidas!

 

Como remover Elementos de um Array JavaScript alterando o length

Em JavaScript, os Arrays permitem agrupar valores e iterar sobre eles. Você pode adicionar e remover elementos destes vetores de várias maneiras diferentes.

Ao invés de um método de exclusão, o Array JavaScript possui várias maneiras de limpar os valores do vetor. Você pode remover os elementos do final de um Array usando pop(), no início usando shift(), ou no meio usando splice().

Removendo elementos do final de um Array utilizando o length:

Os elementos de um Array JavaScript podem ser removidos do final de um vetor, definindo a propriedade length (tamanho do array) como um valor menor que o valor atual. Qualquer elemento que possuir o índice maior que o estipulado no novo length, será removido.

// Definindo o vetor de tamanho 6 (a partir do índice 0)
let array1 = [1, 2, 3, 4, 5, 6];
array1.length = 4; // Alterando o tamanho (length) do array
console.log(array1); // [1, 2, 3, 4] vetor alterado

Removendo elementos do início de um Array utilizando o shift():

Para remover o primeiro elemento de um Array no JavaScript, podemos utilizar o método shift(). Ele funciona de forma muito parecida com o método pop(), com a diferença que o pop() remove o último elemento, e o shift() remove o primeiro elemento do vetor. Não é necessário passar parâmetros neste método, pois o shift() irá remover apenas o primeiro elemento do vetor. Os outros elementos restantes serão realocados para seus novos índices. O elemento que estava no índice 1, será realocado para o índice 0, e assim, sucessivamente.

// Criando um vetor com 4 elementos
let array2 = ['Ana', 'Marcos', 'Paulo', 'Alexandre'];
array2.shift(); // Removerá o primeiro elemento do vetor: 'Ana'
console.log(array2); // ['Marcos', 'Paulo', 'Alexandre']

O shift() retorna o elemento que foi removido, atualiza os índices e atualiza o length do Array. Se não houver elementos ou o comprimento da matriz for 0, o método retornará undefined.

Removendo elementos do meio do Array utilizando o splice():

O método splice() é utilizado para remover elementos de determinados índices de um vetor. Será necessário passar dois parâmetros neste método. O primeiro, especifica o índice que será removido. O segundo, especifica quantos elementos a partir deste índice serão removidos.

// Criando um vetor com os elementos 
let array3 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
// Crie uma variável para adicionar o método slice()
// Passe como argumentos a partir de qual índice será removido, e quantos elementos serão removidos
let remover = array3.splice(3, 3);
console.log(array3); // [1, 2, 3, 7, 8, 9]

Gostou deste artigo? Tire suas dúvidas abaixo na sessão de comentários!

Exercício fácil: Unindo Arrays em JavaScript

Você sabe o que é um array?

Arrays são objetos semelhantes a listas. O tamanho de um array pode ser alterado a qualquer momento e os dados podem ser armazenados em posições não necessariamente seguindo uma ordem contínua. Eles possuem índices, que devem ser em números inteiros. Utilizando a notação de colchetes, você pode acessar ou definir os valores dos elementos dentro do array.

União de Arrays:

Requisitos:

Existem várias maneiras de adicionar novos elementos à um vetor em JavaScript. Neste exercício, serão utilizados as funções concat() e push().

Concat: Cria um novo array contendo uma cópia de si e dos argumentos passados.

arr.concat(valor1, valor2, ..., valorN)

// Onde: arr é o vetor que será concatenado
// Concat: função de concatenação
// Valores: argumentos

Push: Adiciona um ou mais elementos ao final do array e retorna o comprimento deste array.

arr.push(elemento1, ..., elementoN)

// Onde: arr é o vetor que será utilizado
// Push: função push para inserção de elementos no vetor
// Elementos: Argumentos/Elementos que serão inseridos no vetor

Para descobrir outras funções de união de vetores, acesse o artigo a seguir: Adicionando elementos em uma lista array JavaScript

Exercício:

Parte 1:

Crie três vetores, chamados vetorInteiro, vetorString e vetorDouble. Cada um destes vetores deverá conter quatro valores, sendo o primeiro com valores inteiros, o segundo com strings e o terceiro com valores decimais.

Declarados os vetores, utilize a função de união concat() de duas maneiras diferentes para unir os vetores, e mostre o resultado no console. Todos os elementos do vetor resultado deverão aparecer no console.

Se você não sabe quais são os modos de usar a função concat, acesse este artigo para descobrir: Duas maneiras de unir vetores em JavaScript

Parte 2:

Crie dois vetores chamados vetorPilha e vetorAdiciona. Utilize o método Push para adicionar elementos do vetorAdiciona ao vetorPilha. Inicialmente, o vetorPilha conterá cinco elementos inteiros: [1, 2, 3, 4, 5]. Você deverá adicionar os valores contidos no vetorAdiciona [6, 7, 8, 9,10] e mostrá-los no console. É importante lembrar que o método Push retorna somente o tamanho do Vetor, então, justifique por quê motivo isso acontece e imprima no console o vetor com os elementos adicionados.

Você pode fazer o download das respostas destes exercícios aqui: [download id=”2547″]

Gostou deste exercício? Comente os seus resultados abaixo!

 

Duas maneiras de unir vetores em JavaScript:

Você sabe como unir vetores?

Este artigo mostrará duas maneiras de unir vetores e retornar um novo vetor.

Serão utilizados os operadores Spread e Concat.

// Duas formas de unir vetores
const circ = [‘círculo’, ‘esfera’];
const quadr = [‘quadrado’, ‘cubo’];

// Usando o Concat para unir os vetores:
cons unirVet = [].concat(circ, quadr);

// Usando o Spread para unir os vetores:
const unirSpread = [...circ, ...quadr];

// E o resultado será:
console.log(unirSpread);

// [‘círculo’, ‘esfera’, ‘quadrado’, ‘cubo’]

Você também pode escrever o método Concat deste modo:

const circ = [‘círculo’, ‘esfera’];
const quadr = [‘quadrado’, ‘cubo’];

const unirVetor = circ.concat(quadr);
console.log(unirVetor);

E o resultado será:
// [‘círculo’, ‘esfera’, ‘quadrado’, ‘cubo’]

console.log(circ); // [‘círculo’, ‘esfera’];
console.log(quadr); // [‘quadrado’, ‘cubo’];

Este modo não altera o vetor existente.

Comparando os dois modos do concat:
// Versão 1
cons unirVet = [].concat(circ, quadr);

// Versão 2
const unirVetor = circ.concat(quadr);

A versão 1 cria uma nova matriz e não manipula uma matriz existente. Visualmente falando, a versão 2 parece adicionar a matriz de quadrados à matriz de círculos.

A diferença entre Spread e Concat:

Spread:

O Spread quebra um array ou uma string em múltiplos elementos. Se você possui um array e quer criar um array com o existente fazendo parte dele, você pode usar o Spread.

let umaString = "Olá Mundo";

console.log(umaString); // exibe a string

console.log(...umaString); // exibe cada caracter

let umVetor = [11,22,33,44,55,66]; //cria um vetor

console.log(umVetor); // mostra conteúdo o vetor

console.log(...umVetor); // mostra o conteúdo de cada índice do vetor

Concat:

Já o Concat cria um novo vetor unindo os elementos que foram passados como parâmetro, não alterando a si mesmo ou aos argumentos passados, mas criando um novo vetor contendo uma cópia de si e dos argumentos.

A cópia é uma referência aos objetos. Se o objeto original for modificado, as mudanças serão visíveis no original e na cópia.

Strings e numbers (diferente dos objetos String e Number), o concat copia os valores de strings e numbers para o novo vetor, mas qualquer alteração no novo vetor não refletirá no original.

// Cria uma função que concatenará
// o vetor e a variável
function combinaVetor(vetor1, vetor2){ 
    return [].concat(vetor1, vetor2);
} 

// Crie um vetor
const ehVetor = ['carro', 'moto', 'onibus'];

// Crie uma variável
const notVetor = 7;

// Chamada da função
combinaVetor(ehVetor, notVetor);

// [“carro”, “moto”, “onibus”, 7]

Unindo arrays com Push:

Quando você utilizar o método Push, você não criará um novo array, mas sim manipulando um existente:

const meninos = ["joao", "josé"];
const meninas = ["maria", "vanessa"];
const alunos = meninos.push(...meninas);

console.log(alunos); //Quando você usa o push, ele retornará o tamanho do vetor unido.
console.log(meninos); 
["joao", "josé", "maria", "vanessa"] // Retorna o vetor meninos modificado 

console.log(meninas);
 ["maria", "vanessa"]

Gostou deste artigo? Comente abaixo e compartilhe com seus amigos!