quinto capítulo

Chapter1/Exercise1/maiorNumero.js

@@ -1,6 +1,29 @@
 //Escreve uma função que receba uma lista de números inteiros e retorna o maior número
 
-function maiorNumero(lista) {}
+
+function maiorNumero(lista) {
+    let max = 0
+    for (let i = 0; i < lista.length; i++)
+        if (max < lista[i]) {
+            max = lista[i]
+        }
+    return max
+}
+
+//ouu
+
+function maiorNumero2(lista) {
+    let max = 0
+    for (item of lista)
+        if (max < item) {
+            max = item
+        }
+    return max
+}   
+
+
+
+
 
 let numeros = [3, 5, 7, 2, 8];
 console.log("Maior número:", maiorNumero(numeros)); //output: 8

Chapter1/Exercise2/Media.js

@@ -1,6 +1,11 @@
 // Escreve uma função que calcule a média de uma sequência de números
 
-function media(numero) {}
+function media(numero) {
+    let soma = 0
+    for (item of numero)
+        soma += item
+    return soma/numero.length
+}  
 
 let numeros = [3, 5, 7, 2, 8];
-console.log("Média:", media(numeros)); //output: 6
+console.log("Média:", media(numeros)); //output: 5

Chapter1/Exercise3/segundomaior.js

@@ -1,6 +1,9 @@
 // Escreve uma função que encontre o segundo maior número em um array de inteiros
 
-function segundoMaior(numeros) {}
+function segundoMaior(numero) {
+    let numerosOrd = numero.sort()
+    return numerosOrd[(numero.length)-2]
+}
 
 let numeros = [3, 5, 7, 2, 8];
 console.log("Segundo maior número:", segundoMaior(numeros)); //output: 7

Chapter1/Exercise4/contarDigitos.js

@@ -1,5 +1,19 @@
 // Escreve uma função que conte quantos dígitos um número inteiro possui
 
-function contarDigitos(n) {}
+function contarDigitos2(n) {
+    let i = 0
+    while (n > 0) {
+        n = Math.floor(n / 10)
+        i++
+    }
+    return i
+}
+
+// ouu
+
+function contarDigitos(n) {
+    return n.toString().length
+}
+
+console.log("Numero de digitos:", contarDigitos2(440)); //output: 3
 
-console.log("Numero de digitos:", contarDigitos(440)); //output: 3

Chapter1/Exercise5/juntarStrings.js

@@ -1,5 +1,7 @@
 // Escreva uma função que junta duas strings.
 
-function juntarStrings(s1, s2) {}
+function juntarStrings(s1, s2) {
+    return s1.concat(s2)
+}
 
-console.log("Strings juntas:", juntarStrings("Hello, ", "World!"));
+console.log("Strings juntas:", juntarStrings2("Hello, ", "World!"));

Chapter2/Exercise10/Palindromo.js

@@ -1,6 +1,13 @@
 //Escreve uma função que verifique se uma palavra lida de trás para frente é igual à leitura normal.
 
-function Palindromo(s) {}
+function Palindromo(s) {
+    const reversed = s.split("").reverse().join("")
+    if (reversed == s) {
+        return true
+    } else {
+        return false
+    }
+}
 
 let palavra = "arara";
 console.log("É palíndromo:", Palindromo(palavra)); //output: true

Chapter2/Exercise6/Inverterstring.js

@@ -1,6 +1,8 @@
 //Escreve uma função que inverta a ordem dos caracteres de uma string.
 
-function inverter(s) {}
+function inverter(s) {
+    return s.split("").reverse().join("")
+}
 
 let string = "exemplo";
 console.log("String invertida:", inverter(string)); //output: olpmexe

Chapter2/Exercise7/removerVogais.js

@@ -1,6 +1,15 @@
 //Escreve uma função que remova todas as vogais de uma string
 
-function removerVogais(s) {}
+function removerVogais(s) {
+    const vowels = "aeiouAEIOU"
+    let str = ""
+    for (item of s) {
+        if (!vowels.includes(item)) {
+            str += item
+        }
+    }
+    return str
+}
 
 let string = "exemplo";
 console.log("String sem vogais:", removerVogais(string)); //output: xmpl

Chapter2/Exercise8/eliminarEspacos.js

@@ -1,6 +1,14 @@
 // Escreve uma função que elimine espaços extras em uma string, deixando apenas um espaço entre as palavras
 
-function eliminarEspacos(s) {}
+function eliminarEspacos(s) {
+    str = ""
+    for (item of s.split("")) {
+        if (item!=" ") {
+            str += item
+        }
+    }
+    return str
+}
 
 let stringComEspacos = "a    a bb     a";
 console.log("String sem espaços extras:", eliminarEspacos(stringComEspacos)); //output: aabba

Chapter2/Exercise9/contarPalavra.js

@@ -1,6 +1,8 @@
 //Escreve uma função que conte quantas palavras existem em uma string separadas por espaços.
 
-function contarPalavrasSimples(s) {}
+function contarPalavrasSimples(s) {
+    return s.split(" ").length
+}
 
 let frase = "exemplo de uma frase simples";
 console.log("Número de palavras:", contarPalavrasSimples(frase)); //output: 5

Chapter3/Exercise11/minimo.js

@@ -1,6 +1,19 @@
 //Escreve uma função que encontre o menor número em um array de inteiros.
 
-function minimoSimples(arr) {}
+function minimoSimples(arr) {
+    let min = 1000000
+    for (item of arr) {
+        if (min>item) {
+            min = item
+        }
+    } return min
+}
+
+// ou
+
+function minimoSimples2(arr) {
+    return Math.min(...arr)
+}
 
 let numeros = [10, 5, 8, 1, 7];
-console.log("Menor número:", minimoSimples(numeros)); //output: 1
+console.log("Menor número:", minimoSimples2(numeros)); //output: 1

Chapter3/Exercise12/removerDuplicados.js

@@ -1,6 +1,13 @@
 // Escreve uma função que remova todos os elementos duplicados de um array.
 
-function removeDuplicados(arr) {}
+function removeDuplicados(arr) {
+    let arrF = []
+    for (item of arr) {
+        if (!arrF.includes(item)) {
+            arrF.push(item)
+        }
+    } return arrF
+} 
 
 let arrDuplicados = [1, 2, 3, 2, 1, 4, 5];
 console.log("Array sem duplicatas:", removeDuplicados(arrDuplicados)); //output: [ 1, 2, 3, 4, 5 ]

Chapter3/Exercise13/contarOcorrencias.js

@@ -1,6 +1,12 @@
 //Escreve uma função que conte quantas vezes um número aparece em um array.
 
-function contarOcorrencias(arr, num) {}
+function contarOcorrencias(arr, num) {
+    let i = 0
+    for (item of arr) {
+        if (num == item)
+            i++
+    }return i
+}
 
 let numerosArr = [1, 2, 3, 2, 1, 4, 2];
 console.log("Ocorrências de 2:", contarOcorrencias(numerosArr, 2)); //output: 3

Chapter3/Exercise14/somarPares.js

@@ -1,6 +1,13 @@
 // Escreve uma função que some todos os números pares de um array
 
-function somarPares(arr) {}
+function somarPares(arr) {
+    let soma = 0
+    for (item of arr) {
+        if (item % 2 == 0) {
+            soma += item
+        }
+    } return soma
+}
 
 let numerosPares = [1, 2, 3, 4, 5, 6];
 console.log("Soma dos pares:", somarPares(numerosPares)); //output: 12

Chapter3/Exercise15/contarDiferentes.js

@@ -1,6 +1,13 @@
 // Escreve uma função que conte quantos caracteres únicos existem em uma string
 
-function contarDiferentes(s) {}
+function contarDiferentes(s) {
+    let str = []
+    for (item of s) {
+        if (!str.includes(item)) {
+            str.push(item)
+        }
+    } return str.length
+}
 
 let stringDiferente = "aabbccdde";
 console.log("Caracteres diferentes:", contarDiferentes(stringDiferente)); //output: 5

Chapter4/Exercise16/juntaArrays.js

@@ -1,6 +1,13 @@
 // Escreve uma função que mescle dois arrays e remova os elementos duplicados do array resultante
 
-function juntaArrays(arr1, arr2) {}
+function juntaArrays(arr1, arr2) {
+    let narr = []
+    for (item of arr1.concat(arr2)) {
+        if (!narr.includes(item)) {
+            narr.push(item)
+        }
+    }return narr
+}
 
 let arr1 = [1, 2, 3];
 let arr2 = [3, 4, 5];

Chapter4/Exercise17/twoSum.js

@@ -1,6 +1,14 @@
 // Dado um array de inteiros nums e um inteiro target, retorne os índices de dois números no array
 // que somam o valor target.
 
-function twoSum(nums, target) {}
+function twoSum(nums, target) {
+    for (item of nums) {
+        for (itemI of (nums.filter(x => x !== item))) {
+            if (item + itemI == target) {
+                return [nums.indexOf(item), nums.indexOf(itemI)]
+            }
+        }
+    }
+}
 
 console.log(twoSum([2, 7, 11, 15], 9)); //output: [0, 1]

Chapter4/Exercise18/fizzBuzz.js

@@ -1,7 +1,21 @@
 // Escreve um programa que imprima números de 1 a n. Para múltiplos de 3, imprima "Fizz" em vez do número,
 // e para múltiplos de 5, imprima "Buzz". Para números múltiplos de 3 e 5, imprima "FizzBuzz".
 
-function fizzBuzz(n) {}
+function fizzBuzz(n) {
+    for (let i=1; i<=n; i++) {
+        if (i % 3 == 0) {
+            if (i % 5 == 0) {
+                console.log("FizzBuzz")
+            } else {
+                console.log("Fizz")
+            }
+        } else if (i % 5 == 0) {
+            console.log("Buzz")
+        } else {
+            console.log(i)
+        }
+    }
+}
 
 fizzBuzz(15);
 //output:

Chapter4/Exercise19/eAnagrama.js

@@ -1,26 +1,17 @@
 // Dadas duas strings, verifica se uma é o anagrama da outra (ou seja, se contêm os mesmos caracteres, com a mesma frequência, mas em qualquer ordem).
 
 function eAnagrama(str1, str2) {
-  if (str1.length !== str2.length) return false;
+  if (!str1.length == str2.length) return false
 
-  let contador1 = {};
-  let contador2 = {};
-
-  for (let i = 0; i < str1.length; i++) {
-    let char1 = str1[i];
-    let char2 = str2[i];
-
-    contador1[char1] = (contador1[char1] || 0) + 1;
-    contador2[char2] = (contador2[char2] || 0) + 1;
+  for (item of str1) {
+    if (!str2.includes(item)) return false
   }
 
-  for (let key in contador1) {
-    if (contador1[key] !== contador2[key]) {
-      return false;
-    }
+  for (item of str2) {
+    if (!str1.includes(item)) return false
   }
 
-  return true;
+  return true
 }
 
 console.log(eAnagrama("listen", "silent")); //output: true

Chapter4/Exercise20/fatorial.js

@@ -1,5 +1,10 @@
 // Escreve uma função que calcule o fatorial de um número n. O fatorial de n é o produto de todos os números inteiros de 1 a n.
 
-function fatorial(n) {}
+function fatorial(n) {
+    let result = 1        //fatorial de 0 é 1
+    for (let i = 1; i<=n; i++) {
+        result *= i
+    } return result
+}
 
 console.log(fatorial(5)); //output: 120

Chapter5/Exercise21/ordenarArray.js

@@ -1,5 +1,7 @@
 // Implementa uma função para ordenar um array de números em ordem crescente.
 
-function ordenarArray(nums) {}
+function ordenarArray(nums) {
+    return nums.sort()
+}
 
 console.log(ordenarArray([4, 2, 7, 1, 9])); //output: [1, 2, 4, 7, 9]

Chapter5/Exercise22/maiorEmMatriz.js

@@ -1,6 +1,15 @@
 // Dada uma matriz (array de arrays) de números inteiros, encontra o maior número presente em qualquer das sublistas.
 
-function maiorEmMatriz(matriz) {}
+function maiorEmMatriz(matriz) {
+  let max = 0
+  for (l of matriz) {
+    for (item of l) {
+      if (max < c) {
+        max = c
+      }
+    }
+  } return max
+}
 
 console.log(
   maiorEmMatriz([

Chapter5/Exercise23/maiorNumeroComum.js

@@ -1,6 +1,15 @@
 // Dados dois arrays de números, retorna o maior número que esteja presente em ambos os arrays. Se não houver número comum, retorne -1.
 
-function maiorNumeroComum(arr1, arr2) {}
+function maiorNumeroComum(arr1, arr2) {
+    let max = 0
+    for (item of arr1) {
+        if (arr2.includes(item)) {
+            if (max < item) {
+                max = item
+            }
+        }
+    } return max || -1
+}
 
 console.log(maiorNumeroComum([1, 5, 10, 20], [3, 5, 10, 30])); //output: 10
 console.log(maiorNumeroComum([1, 2, 3], [4, 5, 6])); //output: -1

Chapter5/Exercise24/rotacionarArray.js

@@ -1,5 +1,12 @@
 // Dado um array de números e um número k, rotaciona o array para a direita k vezes. A rotação move o último elemento do array para a primeira posição.
 
-function rotacionarArray(arr, k) {}
+function rotacionarArray(arr, k) {
+    let rodados = []
+    while (k !== 0) {
+        rodados.push(arr[arr.length-1])
+        arr = arr.filter((x) => x !== arr[arr.length-1])
+        k--
+    } return rodados.reverse().concat(arr)
+}
 
 console.log(rotacionarArray([1, 2, 3, 4, 5], 2)); //output: [4, 5, 1, 2, 3]