├── 139-ejercicio.js ├── 22-ejercicio.js ├── 55-ejercicio.js ├── 102-ejercicio.js ├── 57-ejercicio.js ├── 122-ejercicio.js ├── 24-ejercicio.js ├── 29-ejercicio.js ├── 30-ejercicio.js ├── 127-ejercicio.js ├── 25-ejercicio.js ├── 126-ejercicio.js ├── 82-ejercicio.js ├── 173-ejercicio.js ├── 27-ejercicio.js ├── 35-ejercicio.js ├── 37-ejercicio.js ├── 52-ejercicio.js ├── 36-ejercicio.js ├── 38-ejercicio.js ├── 83-ejercicio.js ├── 121-ejercicio.js ├── 34-ejercicio.js ├── 39-ejercicio.js ├── 129-ejercicio.js ├── 28-ejercicio.js ├── 23-ejercicio.js ├── 33-ejercicio.js ├── 40-ejercicio.js ├── 43-ejercicio.js ├── 198-ejercicio.js ├── 31-ejercicio.js ├── 32-ejercicio.js ├── 42-ejercicio.js ├── 124-ejercicio.js ├── 144-ejercicio.js ├── 196-ejercicio.js ├── 26-ejercicio.js ├── 50-ejercicio.js ├── package.json ├── 96-ejercicio.js ├── 177-ejercicio.js ├── 61-ejercicio.js ├── 70-ejercicio.js ├── 157-ejercicio.js ├── 53-ejercicio.js ├── 120-ejercicio.js ├── 73-ejercicio.js ├── 119-ejercicio.js ├── 148-ejercicio.js ├── 51-ejercicio.js ├── 134-ejercicio.js ├── 54.ejericicio.js ├── 69-ejercicio.js ├── 158-ejercicio.js ├── 128-ejercicio.js ├── 41-ejercicio.js ├── 104-ejercicio.js ├── 118-ejercicio.js ├── 149-ejercicio.js ├── 107-ejercicio.js ├── 135-ejercicio.js ├── 18-ejercicio.js ├── 45-ejercicio.js ├── 175-ejercicio.js ├── 75-ejercicio.js ├── 147-ejercicio.js ├── 58-ejercicio.js ├── 130-ejercicio.js ├── 99-ejercicio.js ├── 106-ejercicio.js ├── 140-ejercicio.js ├── 60-ejercicio.js ├── 146-ejercicio.js ├── 63-ejercicio.js ├── 194-ejercicio.js ├── 94-ejercicio.js ├── 145-ejercicio.js ├── 79-ejercicio.js ├── 125-ejercicio.js ├── 193-ejercicio.js ├── 85-ejercicio.js ├── 03-ejercicio.js ├── 116-ejercicio.js ├── 131-ejercicio.js ├── 142-ejercicio.js ├── 143-ejercicio.js ├── 168-ejercicio.js ├── 197-ejercicio.js ├── 201-ejercicio.js ├── 78-ejercicio.js ├── 76-ejercicio.js ├── 77-ejercicio.js ├── 187-ejercicio.js ├── 44-ejercicio.js ├── 59-ejercicio.js ├── 101-ejercicio.js ├── 178-ejercicio.js ├── 97-ejercicio.js ├── 164-ejercicio.js ├── 46-ejercicio.js ├── 89-ejercicio.js ├── 184-ejercicio.js ├── 186-ejercicio.js ├── 156-ejercicio.js ├── 162-ejercicio.js ├── 199-ejercicio.js ├── 74-ejercicio.js ├── 183-ejercicio.js ├── 84-ejercicio.js ├── 98-ejercicio.js ├── 113-ejercicio.js ├── 180-ejercicio.js ├── 200-ejercicio.js ├── 179-ejercicio.js ├── 67-ejericicio.js ├── 195-ejercicio.js ├── 47-ejercicio.js ├── 08-ejercicio.js ├── 48-ejercicio.js ├── 159-ejercicio.js ├── 19-ejercicio.js ├── 100-ejercicio.js ├── 152-ejercicio.js ├── 62-ejercicio.js ├── 91-ejercicio.js ├── 72-ejercicio.js ├── 167-ejercicio.js ├── 169-ejercicio.js ├── 172-ejercicio.js ├── 115-ejercicio.js ├── 114-ejercicio.js ├── 87-ejercicio.js ├── 56-ejercicio.js ├── 01-ejercicio.js ├── 188-ejercicio.js ├── 171-ejercicio.js ├── 71-ejercicio.js ├── 141-ejercicio.js ├── 09-ejercicio.js ├── 153-ejercicio.js ├── 205-ejercicio.js ├── 16-ejercicio.js ├── 02-ejericicio.js ├── 182-ejercicio.js ├── 189-ejercicio.js ├── 138-ejercicio.js ├── 166-ejercicio.js ├── 160-ejercicio.js ├── 202-ejercicio.js ├── 04-ejericicio.js ├── data └── characters.js ├── 15-ejercicio.js ├── 80-ejercicio.js ├── 191-ejercicio.js ├── 68-ejercicio.js ├── 64-ejercicio.js ├── 117-ejercicio.js ├── 204-ejercicio.js ├── 161-ejercicio.js ├── 10-ejercicio.js ├── 123-ejercicio.js ├── 181-ejercicio.js ├── 132-ejercicio.js ├── 12-ejercicio.js ├── 176-ejercicio.js ├── 133-ejercicio.js ├── 137-ejercicio.js ├── 05-ejercicio.js ├── 105-ejercicio.js ├── 07-ejercicio.js ├── 86-ejercicio.js ├── 103-ejercicio.js ├── 17-ejercicio.js ├── 11-ejercicio.js ├── 06-ejercicio.js ├── 21-ejericicio.js ├── 95-ejercicio.js ├── 163-ejercicio.js ├── 90-ejercicio.js ├── 185-ejercicio.js ├── 111-ejercicio.js ├── 174-ejercicio.js ├── 151-ejercicio.js ├── 203-ejercicio.js ├── 20-ejercicio.js ├── 49-ejercicio.js ├── 92-ejercicio.js ├── 112-ejercicio.js ├── 206-ejercicio.js ├── 88-ejercicio.js ├── 155-ejercicio.js ├── 165-ejercicio.js ├── 136-ejercicio.js ├── 93-ejercicio.js ├── 81-ejercicio.js ├── 170-ejercicio.js ├── 13-ejercicio.js ├── 65-ejercicio.js ├── 14-ejercicio.js ├── 150-ejercicio.js ├── 192-ejercicio.js ├── 66-ejericicio.js ├── 190-ejercicio.js ├── 109-ejercicio.js ├── 108-ejercicio.js ├── 110-ejercicio.js └── 154-ejercicio.js /139-ejercicio.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /22-ejercicio.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /55-ejercicio.js: -------------------------------------------------------------------------------- 1 | // eliminar los duplicados de un arreglo dado 2 | 3 | const eliminarDuplicados = (arr) => { 4 | return [... new Set(arr)]; 5 | } 6 | console.log(eliminarDuplicados([1,2,3,1,2])) -------------------------------------------------------------------------------- /102-ejercicio.js: -------------------------------------------------------------------------------- 1 | // implemetar una llamada a json placeholder usando top level await 2 | 3 | const res = await fetch("https://jsonplaceholder.typicode.com/users/1").then((data) => data.json()) 4 | console.log(res) -------------------------------------------------------------------------------- /57-ejercicio.js: -------------------------------------------------------------------------------- 1 | // aplanar un arreglo anidado: [1, 2, [3, 4, [5]]] => [1, 2, 3, 4, 5] 2 | 3 | const flatArray = (array) => { 4 | return array.flat(Infinity) 5 | } 6 | 7 | console.log(flatArray([1, 2, [3, 4, [5]]])) -------------------------------------------------------------------------------- /122-ejercicio.js: -------------------------------------------------------------------------------- 1 | // contar los carecteres de "a" en el string 2 | 3 | const contarAes = (cadena) => { 4 | return [...cadena].filter((letra) => letra === "a").length 5 | } 6 | 7 | console.log(contarAes("abracadabra")) 8 | 9 | -------------------------------------------------------------------------------- /24-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //obtener todas las alturas 4 | const getAllHeights = (arr) => { 5 | return arr.map(({height}) => Number(height)) 6 | } 7 | 8 | console.log(getAllHeights(characters)) -------------------------------------------------------------------------------- /29-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //recuperar todos los hombres 4 | 5 | const getAllMale = (arr) =>{ 6 | return arr.filter(({gender}) => gender === "male") 7 | } 8 | 9 | console.log(getAllMale(characters)) -------------------------------------------------------------------------------- /30-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //recuperar todas las mujeres 4 | const getAllFemale = (arr) =>{ 5 | return arr.filter(({gender}) => gender === "female") 6 | } 7 | 8 | console.log(getAllFemale(characters)) -------------------------------------------------------------------------------- /127-ejercicio.js: -------------------------------------------------------------------------------- 1 | const min = (arr) => { 2 | let ordenarArr = arr.sort((a, b) => a-b) 3 | return ordenarArr.at(0) 4 | } 5 | 6 | console.log(min([3, 9, 6])) // 3 7 | console.log(min([67, 35, 54, 26])) // 26 8 | console.log(min([5, 9, 2, 4, 5, 7])) // 2 -------------------------------------------------------------------------------- /25-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | // regresar un arreglo de objetos con nombre y altura 3 | const getNamesHeights = (arr) => arr.map(({name, height}) => ({ name,height })) 4 | 5 | console.log(getNamesHeights(characters)) -------------------------------------------------------------------------------- /126-ejercicio.js: -------------------------------------------------------------------------------- 1 | const max = (arr) => { 2 | let ordenarArr = arr.sort((a, b) => a-b) 3 | return ordenarArr.at(-1) 4 | } 5 | 6 | console.log(max([3, 9, 6])) // 9 7 | console.log(max([67, 35, 54, 26])) // 67 8 | console.log(max([5, 9, 2, 4, 5, 7])) // 9 -------------------------------------------------------------------------------- /82-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dados los 3 lados de un triangulo estimar su area 2 | 3 | const areaTriangulo = (a, b ,c) => { 4 | let s = (a + b + c)/ 2; 5 | let A = Math.sqrt(s*(s-a)*(s-b)*(s-c)); 6 | return A; 7 | } 8 | 9 | console.log(areaTriangulo(5,6,7)) -------------------------------------------------------------------------------- /173-ejercicio.js: -------------------------------------------------------------------------------- 1 | //regresar el num mayor de una matriz 2 | 3 | const maxMatriz = (matriz) => { 4 | return Math.max(...matriz.flat()) 5 | } 6 | 7 | console.log(maxMatriz([ 8 | [2, 7, 12, 1], 9 | [8, 23], 10 | [9, 45, 7], 11 | [22, 3, 24, 4] 12 | ])) -------------------------------------------------------------------------------- /27-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //obtener los personajes cuya masa es mayor a 100 4 | 5 | const getMassTotal = (arr) => { 6 | return arr.filter(({mass}) => Number(mass) > 100 ) 7 | } 8 | 9 | console.log(getMassTotal(characters)) -------------------------------------------------------------------------------- /35-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | // todos los perosnajes tiene ojos azules? 4 | 5 | const todoOjosAzules = (arr) => { 6 | return arr.every(({eye_color}) => eye_color ==="blue") 7 | } 8 | 9 | console.log(todoOjosAzules(characters)) -------------------------------------------------------------------------------- /37-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | // todos los perosnajes miden menos de 200 4 | 5 | const todosSonHombres = (arr) => { 6 | return arr.every(({gender}) => gender === "male") 7 | } 8 | 9 | console.log(todosSonHombres(characters)) -------------------------------------------------------------------------------- /52-ejercicio.js: -------------------------------------------------------------------------------- 1 | // [0, 1, false, 2, undefined, '', 3, null] => [1, 2, 3] 2 | // extraer todos los valores falsy de un arreglo 3 | 4 | const compact = (arr) => { 5 | return arr.filter(Boolean) 6 | } 7 | 8 | console.log(compact([0, 1, false, 2, undefined, '', 3, null])) -------------------------------------------------------------------------------- /36-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | // todos los perosnajes tienen una masa superior a 40 4 | 5 | const todoOjosAzules = (arr) => { 6 | return arr.every(({mass}) => Number(mass) > 40) 7 | } 8 | 9 | console.log(todoOjosAzules(characters)) -------------------------------------------------------------------------------- /38-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | // todos los perosnajes miden menos de 200 4 | 5 | const todosMidenMenosDe200 = (arr) => { 6 | return arr.every(({height}) => Number(height) < 200) 7 | } 8 | 9 | console.log(todosMidenMenosDe200(characters)) -------------------------------------------------------------------------------- /83-ejercicio.js: -------------------------------------------------------------------------------- 1 | //Este programa genera un número aleatorio entre el valor mínimo y máximo. 2 | 3 | const generarRandom = (min, max) => { 4 | return Math.floor(Math.random() * (max - min + 1) + min); 5 | } 6 | 7 | console.log(generarRandom(1,10)) 8 | console.log(generarRandom(5,16)) -------------------------------------------------------------------------------- /121-ejercicio.js: -------------------------------------------------------------------------------- 1 | // contar la cantidad de digitos de un numero sin convertir su tipo de dato 2 | 3 | let n = 578; 4 | let contador = 1; 5 | while (n > 0) { 6 | n = Math.trunc(n / 10); 7 | if (n > 0) { 8 | contador++; 9 | } 10 | } 11 | console.log(contador); 12 | -------------------------------------------------------------------------------- /34-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //verificar si hay al menos un personaje con ojos azules 4 | const isExistePersonajeMasa50 = (arr) =>{ 5 | return arr.some(({mass}) => mass < "50") 6 | } 7 | 8 | console.log(isExistePersonajeMasa50(characters)); -------------------------------------------------------------------------------- /39-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //total de masa de todos los personajes 4 | 5 | const getTotalMasa = (arr) => { 6 | return arr.map(({mass}) => Number(mass)).reduce((acc, mass) => acc +mass) 7 | } 8 | 9 | console.log(getTotalMasa(characters)) -------------------------------------------------------------------------------- /129-ejercicio.js: -------------------------------------------------------------------------------- 1 | // regresar solo los index de las posiciones pares de un arreglo 2 | const posicionesPares = (arr) => { 3 | return arr.map((item, i) => item % 2 === 0 ? i : []).flat() 4 | } 5 | 6 | console.log(posicionesPares([5,9,2,10,7])) // [2,3] 7 | console.log(posicionesPares([])) // [] -------------------------------------------------------------------------------- /28-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //obtener los personas cuya altura sea menor a 200 4 | 5 | const getHeightLessThan200 = (arr) => { 6 | return arr.filter(character => character.height < 200) 7 | } 8 | 9 | console.log(getHeightLessThan200(characters)) -------------------------------------------------------------------------------- /23-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //obtener todos los nombres 4 | const getAllNames = (arr) => { 5 | return arr.map(({name}) => name) 6 | } 7 | 8 | console.log(getAllNames(characters)) // [ 'Luke Skywalker', 'Darth Vader', 'Leia Organa', 'Anakin Skywalker' ] -------------------------------------------------------------------------------- /33-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //verificar si hay al menos un personaje con ojos azules 4 | const isExistePersonajeAltura200 = (arr) =>{ 5 | return arr.some(({height}) => height >= "200") 6 | } 7 | 8 | console.log(isExistePersonajeAltura200(characters)); -------------------------------------------------------------------------------- /40-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //total de alturas de todos los personajes 4 | const getTotalAltura = (arr) => { 5 | return arr.map(({height }) => Number(height )).reduce((acc, height ) => acc +height ) 6 | } 7 | 8 | console.log(getTotalAltura(characters)) -------------------------------------------------------------------------------- /43-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | // ordenar characters por nombre 4 | 5 | const sortedName = (arr) => { 6 | return arr.sort((a, b) => { 7 | return a.name.localeCompare(b.name) 8 | }) 9 | } 10 | 11 | console.log(sortedName(characters)) -------------------------------------------------------------------------------- /198-ejercicio.js: -------------------------------------------------------------------------------- 1 | 2 | 3 | const removeProperties = (data, props) => { 4 | for(key in data){ 5 | if(props.includes(key)){ 6 | delete data[key] 7 | } 8 | } 9 | return data 10 | } 11 | console.log(removeProperties({ a: 1, b: 2, c: 3 }, ["c"])) // returns {a: 1} -------------------------------------------------------------------------------- /31-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //verificar si hay al menos un personaje con el sexo masculino 4 | 5 | const isMaleCharacter = (arr) =>{ 6 | return arr.some((character) => character.gender === "male") 7 | } 8 | 9 | console.log(isMaleCharacter(characters)); -------------------------------------------------------------------------------- /32-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //verificar si hay al menos un personaje con ojos azules 4 | 5 | const isBlueEyesCharacter = (arr) =>{ 6 | return arr.some((character) => character.eye_color === "blue") 7 | } 8 | 9 | console.log(isBlueEyesCharacter(characters)); -------------------------------------------------------------------------------- /42-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //contar cuantas personas tienen los ojos azules 4 | const contarOjosAzules = (arr) => { 5 | return arr.map(({eye_color}) => eye_color).filter(color => color === 'blue').length 6 | } 7 | 8 | console.log(contarOjosAzules(characters)) -------------------------------------------------------------------------------- /124-ejercicio.js: -------------------------------------------------------------------------------- 1 | const capitalizar = (cadena) => { 2 | if(cadena.length === 0) return "" 3 | return `${cadena.at(0).toUpperCase()}${cadena.slice(1)}` 4 | } 5 | 6 | console.log(capitalizar("pedro")) // "Pedro" 7 | console.log(capitalizar("hola mundo")) // "Hola mundo" 8 | console.log(capitalizar("")) // "" -------------------------------------------------------------------------------- /144-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dada un arrglo de colores estimar si un color dado esta en dicho arreglo 2 | 3 | 4 | 5 | console.log(perteneceArray(["azul", "amarillo", "rojo", "verde", "café", "rosa"], "rojo")) // true 6 | console.log(perteneceArray(["azul", "amarillo", "rojo", "verde", "café", "rosa"], "violeta")) //false -------------------------------------------------------------------------------- /196-ejercicio.js: -------------------------------------------------------------------------------- 1 | // escribir una funcion que verifique si un objeto esta vacio 2 | const isEmpty = (obj) => { 3 | return Object.keys(obj).length === 0 4 | } 5 | 6 | console.log(isEmpty({})) 7 | console.log(isEmpty({a:1})) 8 | console.log(isEmpty({a:null})) 9 | console.log(isEmpty({a:undefined})) 10 | -------------------------------------------------------------------------------- /26-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | // regresar un arreglo solo con los primeros nombres de los characters 4 | const getAllFirstNames = (arr) => { 5 | return arr.map(({name}) => { 6 | return name.split(' ')[0] 7 | }) 8 | } 9 | console.log(getAllFirstNames(characters)) -------------------------------------------------------------------------------- /50-ejercicio.js: -------------------------------------------------------------------------------- 1 | // escribir la funcion fill con la longitud y el valor que debe tener el arreglo resultate 2 | // arraySize = 3, value = "a" => ["a", "a", "a"] 3 | 4 | const fill = (arraySize, value) => { 5 | return Array(arraySize).fill(value); 6 | }; 7 | 8 | console.log(fill(3, "a")); 9 | console.log(fill(5, "k")); -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "javascript-ejercicios", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "type": "module", 7 | "scripts": { 8 | "test": "echo \"Error: no test specified\" && exit 1" 9 | }, 10 | "keywords": [], 11 | "author": "", 12 | "license": "ISC" 13 | } 14 | -------------------------------------------------------------------------------- /96-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un numero n regresar true o false si es o no primo 2 | const isPrime = (n) => { 3 | if (n <= 1) { 4 | return false; 5 | } 6 | for (let i = 2; i <= n - 1; i++) { 7 | if (n % i === 0) { 8 | return false; 9 | } 10 | } 11 | return true; 12 | }; 13 | 14 | console.log(isPrime(5)); -------------------------------------------------------------------------------- /177-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getBiggestNumber 3 | * @description Devuelve el número más grande de un array 4 | * 5 | * @param {number[]} numbers - Un array de números 6 | * @returns {Number} El número más grande del arrray {numbers} 7 | * 8 | * @example 9 | * getBiggestNumber([3, 8, 2, 1, 10]) // returns 10 10 | */ -------------------------------------------------------------------------------- /61-ejercicio.js: -------------------------------------------------------------------------------- 1 | //data un objeto, elminar la llave pasada como argumento 2 | //({ a: 1, b: 2 }, 'b') => { a: 1 } 3 | 4 | const eliminarLlave = (obj, ...rest) => { 5 | rest.forEach((item) => { 6 | delete obj[item] 7 | }); 8 | return obj; 9 | } 10 | 11 | console.log(eliminarLlave({ a: 1, b: 2 }, 'b', 'a')) -------------------------------------------------------------------------------- /70-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Dada una matriz de números enteros, encuentre el índice del número más grande en la matriz. 2 | 3 | const indiceMayor = (arr) => { 4 | const max = Math.max(...arr); 5 | return arr.indexOf(max); 6 | } 7 | 8 | console.log(indiceMayor([12, 3, 1, 54, 65, 4, 9])) // 4 9 | console.log(indiceMayor([12, 3, 1, 54])) // 3 -------------------------------------------------------------------------------- /157-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que pida ingresar números separados por espacios y devuelva un mensaje con el menor número ingresado. 2 | 3 | const min = (numeros) => { 4 | let arrNumeros = numeros.split(" ") 5 | return arrNumeros.map((numero) =>Number(numero)).sort((a,b) => a-b).at(0) 6 | } 7 | 8 | console.log(min("5 7 99 34 54 2 12")) // 2 -------------------------------------------------------------------------------- /53-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un array anidado, convertirlo en un objeto 2 | // Expected Result: [['a', 1], ['b', 2]] => { a: 1, b: 2 } 3 | 4 | const fromPairs = (array) => { 5 | return array.reduce((acc, [key, value]) => { 6 | acc[key] = value; 7 | return acc; 8 | },{}) 9 | } 10 | 11 | console.log(fromPairs([['a', 1], ['b', 2]] )) -------------------------------------------------------------------------------- /120-ejercicio.js: -------------------------------------------------------------------------------- 1 | //funcion que regrese los items repetidos de un array dado 2 | 3 | const palabras = ["perro", "gato", "perro", "loro", "elefante", "gato", "loro"]; 4 | 5 | const getPalabrasRepetidas = (palabras) => { 6 | return palabras.filter((palabra, index) => palabras.indexOf(palabra) !== index) 7 | } 8 | 9 | console.log(getPalabrasRepetidas(palabras)) -------------------------------------------------------------------------------- /73-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Cree una función que acepte el parámetro de tamaño en número y registre el patrón de estrella de triángulo rectángulo. 2 | 3 | const triangulo = (n) => { 4 | for(let i=1; i<=5; i++){ 5 | console.log("*".repeat(i)) 6 | } 7 | } 8 | 9 | console.log(triangulo(5)); 10 | // * 11 | // ** 12 | // *** 13 | // **** 14 | // ***** -------------------------------------------------------------------------------- /119-ejercicio.js: -------------------------------------------------------------------------------- 1 | // regresar los valores duplicados de un arreglo en otro arreglo 2 | const repetidos = (numeros) => { 3 | return numeros.filter((numero, index) => { 4 | console.log(numeros.indexOf(numero), index); 5 | return numeros.indexOf(numero) !== index 6 | }) 7 | }; 8 | 9 | console.log(repetidos([3, 1, 4, 2, 5, 3, 6, 2, 7])); 10 | -------------------------------------------------------------------------------- /148-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Existen dos arrays, cada uno con 3 numeros, 2 | // generar un nuevo array con la unión de ambos elementos, 3 | //(Ejemplo: [1, 2, 3] unión [1,2,4] =[1, 1, 2, 2, 3, 4] 4 | 5 | const unionArreglos = (arr1, arr2) => { 6 | return [...arr1, ...arr2].sort((a, b) => a - b); 7 | }; 8 | 9 | console.log(unionArreglos([1, 2, 3], [1, 2, 4])); 10 | -------------------------------------------------------------------------------- /51-ejercicio.js: -------------------------------------------------------------------------------- 1 | // la funcion reverse debe dar la vuelta un arreglo 2 | 3 | const reverse = (arr) => { 4 | const reversed = []; 5 | // [1,2,3,4,5] 6 | for (let i = arr.length -1 ; i >= 0; i -= 1) { // i = 4 7 | reversed.push(arr[i]); 8 | } 9 | 10 | return reversed; 11 | } 12 | 13 | console.log(reverse([1, 2, 3, 4, 5])) 14 | 15 | -------------------------------------------------------------------------------- /134-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribir una función llamada numAsteriscos que reciba un arreglo y retorne el número de asteriscos: 2 | 3 | const numAsteriscos = (arr) => { 4 | return arr.filter((item) => item === "*" ).length 5 | } 6 | 7 | console.log(numAsteriscos(['', '*', '', '*'])) // 2 8 | console.log(numAsteriscos(['*', '*', '*'])) // 3 9 | console.log(numAsteriscos([])) // 0 -------------------------------------------------------------------------------- /54.ejericicio.js: -------------------------------------------------------------------------------- 1 | //aliminar los elementos repetidos de un arreglo, pasados por una lista 2 | const eliminarElementos = (array, ...list) => { 3 | return array.filter((item) => { 4 | return !list.includes(item) 5 | }) 6 | } 7 | 8 | console.log(eliminarElementos([1,2,1,3,2], 1,2)) // [3] 9 | console.log(eliminarElementos([0,1,2,3,4,5], 1,2,3)) // [0,4,5] -------------------------------------------------------------------------------- /69-ejercicio.js: -------------------------------------------------------------------------------- 1 | //Dado un número N, imprima la suma de todos los números del 1 al N. 2 | 3 | const sumaN = (n) => { 4 | let suma = 0 5 | for(let i = 1; i <=n; i++){ 6 | suma += i 7 | } 8 | return suma 9 | } 10 | 11 | console.log(sumaN(10)) // 55 12 | console.log(sumaN(5)) // 15 13 | console.log(sumaN(1)) // 1 14 | console.log(sumaN(0)) // 0 -------------------------------------------------------------------------------- /158-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que pida ingresar números separados por espacios y devuelva un mensaje con la suma de todos los números. 2 | 3 | const suma = (numeros) => { 4 | let arrNumeros = numeros.split(" ") 5 | return arrNumeros.map((numero) =>Number(numero)).reduce((acc,item) => acc+item,0) 6 | } 7 | 8 | console.log(suma("5 7 10 12 24")) // 58 9 | 10 | -------------------------------------------------------------------------------- /128-ejercicio.js: -------------------------------------------------------------------------------- 1 | // sumar el min y el max de un arr sin usar Math.min y Math.max 2 | 3 | const sumaMinMax = (arr) => { 4 | let ordenarArr = arr.sort((a, b) => a-b) 5 | return ordenarArr.at(0) + ordenarArr.at(-1) 6 | } 7 | 8 | console.log(sumaMinMax([3, 9, 6])) // 12 9 | console.log(sumaMinMax([67, 35, 54, 26])) // 93 10 | console.log(sumaMinMax([5, 9, 2, 4, 5, 7])) // 11 -------------------------------------------------------------------------------- /41-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | // obtener el numero total de caracteres del name de los personajes 3 | 4 | const getCantidadCaracteresNombre = (arr) => { 5 | return arr.map(({name}) => { 6 | return name.length 7 | }).reduce((item, acc) => item + acc, 0) 8 | } 9 | 10 | console.log(getCantidadCaracteresNombre(characters)) 11 | 12 | -------------------------------------------------------------------------------- /104-ejercicio.js: -------------------------------------------------------------------------------- 1 | // un contador de vocales 2 | const contadorVocales = (cadena) => { 3 | const vocales = ["a", "e", "i", "o", "u"]; 4 | const arrCadena = cadena.toLowerCase().split(""); 5 | return arrCadena.filter((letra) => vocales.includes(letra)).length; 6 | }; 7 | 8 | console.log(contadorVocales("JavaScript")); // 3 9 | console.log(contadorVocales("Javascript es genial")); 10 | -------------------------------------------------------------------------------- /118-ejercicio.js: -------------------------------------------------------------------------------- 1 | // realizar un contador de letras 2 | 3 | const contadorLetras = (arr) => { 4 | return arr.reduce((acc, letra) => { 5 | if (!acc[letra]) { 6 | acc[letra] = 1; 7 | } else { 8 | acc[letra]++; 9 | } 10 | return acc; 11 | }, {}); 12 | }; 13 | const letras = ["a", "b", "a", "c", "b", "a", "d", "b", "c", "c"]; 14 | console.log(contadorLetras(letras)); 15 | -------------------------------------------------------------------------------- /149-ejercicio.js: -------------------------------------------------------------------------------- 1 | const interseccion = (arr1, arr2) => { 2 | let agrupar = Object.groupBy(arr1.concat(arr2), (item) => item) 3 | let res = Object.values(agrupar).filter((arr) => arr.length >= 2).flat(); 4 | return [...new Set(res)] 5 | } 6 | console.log(interseccion([1, 2, 3,5], [1, 2, 4,5])) // [1,2] 7 | // [1, 2, 3, 1, 2, 4,5,2] 8 | // 1:2 9 | // 2:3, 10 | // 3:1 11 | // 4:1 12 | // 5:1 -------------------------------------------------------------------------------- /107-ejercicio.js: -------------------------------------------------------------------------------- 1 | // contar la cantidad del caracter en la cedena 2 | const contarCaracteres = (cadena, caracter) => { 3 | let cadenaRes = cadena.toLowerCase().split(" ") 4 | return cadenaRes.filter((palabra) => palabra.includes(caracter)).length 5 | }; 6 | 7 | console.log(contarCaracteres ("Hola, mundo en JavaScript", "j")); //2 8 | console.log(contarCaracteres ("Javascript es genial", "p")); // 1 -------------------------------------------------------------------------------- /135-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribir una función llamada numAsteriscos que reciba una matriz(un arreglo de arreglos) y retorne el número de asteriscos: 2 | 3 | const numAsteriscos = (arr) => { 4 | return arr.flat().filter((item) => item === "*").length; 5 | }; 6 | 7 | console.log( 8 | numAsteriscos([ 9 | ["*", "", "*"], 10 | ["", "*", ""], 11 | ["*", "", "*"], 12 | ]) 13 | ); 14 | // 5 15 | -------------------------------------------------------------------------------- /18-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribe una función que muestre la tabla de multiplicar del 6 (del 0 al 60). 2 | // La función devuelve un arreglo con los resultados de la tabla de multiplicar del 6 en orden creciente. 3 | // Tu código: 4 | function tablaDelSeis() { 5 | let numero = 6; 6 | for(let i = 1; i<=60; i++){ 7 | console.log(`${numero} x ${i} = ${numero*i}`); 8 | } 9 | } 10 | 11 | tablaDelSeis(); -------------------------------------------------------------------------------- /45-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //ordenar por sexo 4 | const sortedGender = (arr) => { 5 | return arr.sort((a, b) => { 6 | if (a.gender < b.gender) { 7 | return -1 8 | } 9 | if (a.gender > b.gender) { 10 | return 1 11 | } 12 | return 0 13 | }) 14 | } 15 | 16 | console.log(sortedGender(characters)) -------------------------------------------------------------------------------- /175-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name isOdd 3 | * @description Devuelve si un número es impar 4 | * 5 | * @param {number} x - El número a evaluar 6 | * @returns {Boolean} Devuelve true si el número {x} es impar, false sino 7 | * 8 | * @example 9 | * isOdd(3) // returns true 10 | */ 11 | 12 | const isOdd = (x) => { 13 | return x % 2 !== 0 14 | } 15 | 16 | console.log(isOdd(2)) 17 | console.log(isOdd(3)) 18 | -------------------------------------------------------------------------------- /75-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escriba una función para convertir un objeto en una matriz de matrices que contengan clave y valor. 2 | 3 | const objectToArray = (obj) => { 4 | return Object.entries(obj) 5 | } 6 | 7 | console.log(objectToArray({ a: 1, b: 2 })); // [["a", 1], ["b", 2]] 8 | console.log(objectToArray({ name: 'Will Smith', dob: '15-09-1968' }) ) 9 | // [["name", "Will Smith"], ["dob", "15-09-1968"]]); 10 | 11 | -------------------------------------------------------------------------------- /147-ejercicio.js: -------------------------------------------------------------------------------- 1 | const sumaArreglos = (arr1, arr2) => { 2 | if (arr1.length !== arr2.length) return false; 3 | if (arr1.length === arr2.length) { 4 | let res = []; 5 | for (let i = 0; i < arr1.length; i++) { 6 | res.push(arr1[i] + arr2[i]); 7 | } 8 | return res; 9 | } 10 | }; 11 | 12 | console.log(sumaArreglos([1, 2, 3], [4, 5, 6])); 13 | console.log(sumaArreglos([1, 2, 3], [4, 5, 6, 8])); 14 | -------------------------------------------------------------------------------- /58-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un arreglo, anidar los items segun un 2do parametro dado 2 | 3 | const chuck = (array, size) => { 4 | const resultado = []; 5 | let index = 0; 6 | const longitud = array.length; 7 | while (index < longitud) { 8 | resultado.push(array.slice(index, index + size)); 9 | index += size; 10 | } 11 | return resultado; 12 | } 13 | 14 | console.log([1,2,3,4,5,6,7], 3) -------------------------------------------------------------------------------- /130-ejercicio.js: -------------------------------------------------------------------------------- 1 | // regresar todas las palabras que empiecen por a 2 | 3 | const empiezanConA = (arr) => { 4 | const A = ["a", "A", "á", "Á"]; 5 | return arr.filter((item) => A.includes(item.at(0))) 6 | } 7 | 8 | // código de prueba 9 | console.log(empiezanConA(["beta", "alfa", "Arbol", "gama"])) // ["alfa", "Arbol"] 10 | console.log(empiezanConA(["beta", "delta", "gama"])) // [] 11 | console.log(empiezanConA([])) // [] -------------------------------------------------------------------------------- /99-ejercicio.js: -------------------------------------------------------------------------------- 1 | //obtener el promedio de edades del arreglo dado 2 | const personas = [ 3 | { nombre: "Alice", edad: 30 }, 4 | { nombre: "Bob", edad: 45 }, 5 | { nombre: "Charlie", edad: 28 }, 6 | { nombre: "David", edad: 35 }, 7 | ]; 8 | 9 | const promedioEdades = (personas) => { 10 | return personas.reduce((acc, { edad }) => acc + edad, 0) / personas.length; 11 | }; 12 | console.log(promedioEdades(personas)); 13 | -------------------------------------------------------------------------------- /106-ejercicio.js: -------------------------------------------------------------------------------- 1 | // remplaza las vocales por _ 2 | const transformaVocales = (cadena) => { 3 | const vocales = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]; 4 | const res = [...cadena].map((letra) => 5 | vocales.includes(letra) ? "_" : letra 6 | ); 7 | return res.join(""); 8 | }; 9 | 10 | console.log(transformaVocales("Hola, mundo en JavaScript")); 11 | console.log(transformaVocales("Javascript es genial")); 12 | -------------------------------------------------------------------------------- /140-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Hacer una función que reciba una string y retorne la misma string pero agregando después de cada caracter su í­ndice correspondiente. 2 | 3 | const agregarIndice = (str) => { 4 | return Array.from(str) 5 | .map((item, i) => `${item}${i}`) 6 | .join(""); 7 | }; 8 | console.log(agregarIndice("kawabonga")); // imprime "k0a1w2a3b4o5n6g7a8" 9 | console.log(agregarIndice("casa")); // imprime "c0a1s2a3" 10 | -------------------------------------------------------------------------------- /60-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un objeto plano, convertirlo en un array anidado : 2 | //({ a: 1, b: 2 }) => [['a', 1], ['b', 2]] 3 | 4 | const makePairs = (obj) => { 5 | return Object.entries(obj) 6 | } 7 | 8 | 9 | const makePairs2 = (obj) => { 10 | return Object.keys(obj).map((item) => [item, obj[item]]) 11 | } 12 | 13 | console.log(makePairs({ a: 1, b: 2 })) 14 | console.log(makePairs2({ a: 1, b: 2, c: 3 })) -------------------------------------------------------------------------------- /146-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un array vacío, luego generar 20 números al azar entre 1 y 10 y guardarlos en un array. 2 | 3 | const agregarArregloRandom = () => { 4 | const limite = 20; 5 | const numerosArr = []; 6 | for (let i = 0; i < limite; i++) { 7 | const random = Math.floor(Math.random() * 10) + 1; 8 | numerosArr.push(random); 9 | } 10 | return numerosArr; 11 | }; 12 | 13 | console.log(agregarArregloRandom()); 14 | -------------------------------------------------------------------------------- /63-ejercicio.js: -------------------------------------------------------------------------------- 1 | // verificar que dos objetos planos son iguales 2 | 3 | const isEqual = (obj1, obj2) => { 4 | return JSON.stringify(obj1) === JSON.stringify(obj2); 5 | } 6 | 7 | console.log(isEqual({ a: 1, b: 1 }, { a: 1, b: 1 })) 8 | console.log(isEqual({ a: 1, b: 1 }, { a: 1, c: 3 })) 9 | console.log(isEqual({ }, { })) 10 | console.log(isEqual({ a:undefined }, { a:undefined })) 11 | console.log(isEqual({ a: {b:2} }, { a: {b:2} })) -------------------------------------------------------------------------------- /194-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Hacer una función que dado un número, devuelva un objeto con el número redondeado hacia abajo (Math.floor), hacia arriba (Math.ceil) y dependiendo de su punto flotante (Math.round) 2 | 3 | const round = (x) => { 4 | return { 5 | floor: Math.floor(x), 6 | ceil: Math.ceil(x), 7 | round: Math.round(x) 8 | } 9 | } 10 | 11 | console.log(round(13.3)) // returns { floor: 13, ceil: 14, round: 13 } -------------------------------------------------------------------------------- /94-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado el objeto de inventario, calcular el total de las ventas 2 | 3 | const inventario = { 4 | "Producto A": 150, 5 | "Producto B": 200, 6 | "Producto C": 120, 7 | "Producto D": 250, 8 | // ... más productos ... 9 | }; 10 | 11 | const calcularTotalInventario = (obj) => { 12 | return Object.values(obj).reduce((acc, costo) => acc + costo, 0); 13 | }; 14 | 15 | console.log(calcularTotalInventario(inventario)); 16 | -------------------------------------------------------------------------------- /145-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dada un arrglo de colores estimar si un color dado esta en dicho arreglo 2 | const perteneceArray = (arr, color) => { 3 | return arr.includes(color); 4 | }; 5 | 6 | console.log( 7 | perteneceArray(["azul", "amarillo", "rojo", "verde", "café", "rosa"], "rojo") 8 | ); // true 9 | console.log( 10 | perteneceArray( 11 | ["azul", "amarillo", "rojo", "verde", "café", "rosa"], 12 | "violeta" 13 | ) 14 | ); //false 15 | -------------------------------------------------------------------------------- /79-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Dada una matriz de objetos, devuelve la suma de la edad de todos los objetos. 2 | 3 | const sumaEdades = (array) => { 4 | return array.reduce((acc,item) => acc + item.age,0) 5 | } 6 | 7 | console.log(sumaEdades([{name: 'John', age: 20}, {name: 'Jane', age: 30}, {name: 'Jack', age: 40}])) //90 8 | console.log(sumaEdades( [{name: 'John', age: 20}, {name: 'Jane', age: 30}])) //50 9 | console.log(sumaEdades([{name: 'John', age: 20}])) //20 -------------------------------------------------------------------------------- /125-ejercicio.js: -------------------------------------------------------------------------------- 1 | //capitalizar cada letra 2 | const capitalizar = (cadena) => { 3 | if(cadena.length === 0) return "" 4 | const salida = cadena.split(" ").map((letra) => { 5 | return res = letra.at(0).toUpperCase() + letra.slice(1) 6 | }) 7 | return salida.join(" ") 8 | } 9 | 10 | console.log(capitalizar("hola mundo")) // "Hola Mundo" 11 | console.log(capitalizar("make it real")) // "Make It Real" 12 | console.log(capitalizar("")) // "" -------------------------------------------------------------------------------- /193-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que devuelva el volumen de una caja cuando se le pase un objeto con las medidas de la misma, correspondientes al ancho, alto, y largo. El volumen se calcula multiplicando entre sí dichos valores. 2 | 3 | const getBoxVolume = (size) => { 4 | const { width, length, height} = size; 5 | return width * length * height 6 | } 7 | const size = { width: 2, length: 5, height: 1 } 8 | console.log(getBoxVolume(size)) // returns 10 9 | -------------------------------------------------------------------------------- /85-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Cree una función que tome una cadena como entrada y devuelva la versión invertida de la cadena sin utilizar el método inverso() incorporado. 2 | 3 | const reverseString = (cadena) => { 4 | let arrCadena = [...cadena]; 5 | const resulatado = [] 6 | for(let i = arrCadena.length - 1; i>=0; i--){ 7 | resulatado.push(arrCadena[i]) 8 | } 9 | return resulatado.join("") 10 | } 11 | 12 | console.log(reverseString("cris")) -------------------------------------------------------------------------------- /03-ejercicio.js: -------------------------------------------------------------------------------- 1 | //Retornar la longitud del arreglo recibido por parámetro. 2 | function obtenerLargoDelArray(array) { 3 | return (!Array.isArray(array) ? "El parámetro no es un arreglo." : array.length); 4 | } 5 | 6 | 7 | console.log(obtenerLargoDelArray([1,2,3,4,5,6,7,8,9,10])); 8 | console.log(obtenerLargoDelArray([])); 9 | console.log(obtenerLargoDelArray({})); 10 | console.log(obtenerLargoDelArray(1)); 11 | console.log(obtenerLargoDelArray("Hola")); 12 | -------------------------------------------------------------------------------- /116-ejercicio.js: -------------------------------------------------------------------------------- 1 | // sumar los digitos individuales de un numero dado hasta que el numero resultante solo tenga un digito 2 | const sumaDigitos = (numero) => { 3 | while (numero >= 10) { 4 | let ultimo = numero % 10; 5 | let primeros = Math.trunc(numero / 10); 6 | numero = ultimo + primeros; 7 | } 8 | return numero; 9 | }; 10 | 11 | console.log(sumaDigitos(318)); // 3 12 | 13 | /* 14 | 318: 3 + 1 + 8 = 12 15 | 12: 1 + 2 = 3 16 | */ 17 | -------------------------------------------------------------------------------- /131-ejercicio.js: -------------------------------------------------------------------------------- 1 | // regresar todas las palabras de un arreglo que terminen en s 2 | const terminanConS =(arr)=> { 3 | return arr.filter((palabra) => { 4 | let ultimaLetra = palabra.at(-1); 5 | return ultimaLetra === "s" 6 | }) 7 | } 8 | 9 | 10 | console.log(terminanConS(["pruebas", "arroz", "árbol", "tokens"])) // ["pruebas", "tokens"] 11 | console.log(terminanConS(["beta", "delta", "gama"])) // [] 12 | console.log(terminanConS([])) // [] -------------------------------------------------------------------------------- /142-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Hacer una función que reciba un array y retorne otro array con la misma cantidad de elementos, pero que cada elemento sea el tipo de dato del array original. 2 | 3 | const transformarATipos = (arr) => { 4 | return arr.map((item) => typeof item); 5 | }; 6 | 7 | console.log(transformarATipos([1, "casa", {}])); // imprime ["number", "string", "object"] 8 | console.log(transformarATipos([function () {}, true])); // imprime ["function", "boolean"] 9 | -------------------------------------------------------------------------------- /143-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Hacer una función que reciba un objeto el cual posee propiedades con valores de string y retorne una string cómo resultado de la concatenación de todos los valores de las propiedades del objeto. 2 | 3 | const concatenarObj = (obj) => { 4 | return Object.values(obj).join("") 5 | } 6 | 7 | console.log(concatenarObj({ a: "h", b: "o", c: "l", d: "a" })); // imprime "hola" 8 | console.log(concatenarObj({ z: "sa", x: "ra", y: "sa" })); // imprime "sarasa" -------------------------------------------------------------------------------- /168-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita ingresar una lista de animales separados por espacios y devuelva un mensaje con todos los animales menos los mosquitos y alacranes. 2 | 3 | const exterminador = (arr) => { 4 | return arr.filter((item) => item !== "🦟" && item !== "🦂") 5 | } 6 | 7 | // Ingrese animales: 🐱 🐭 🐶 🦟 🦊 🦂 8 | 9 | // Animales sin insectos: [🐱, 🐭, 🐶, 🦊] 10 | 11 | console.log(exterminador(["🐱", "🐭", "🐶", "🦟", "🦊", "🦂"])) -------------------------------------------------------------------------------- /197-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crea una función multiplyNumeric(obj) que multiplique todas las propiedades numéricas de obj por 2. 2 | 3 | const multiplyNumeric = (obj) => { 4 | let aux = Object.entries(obj).map((item) => typeof item[1] === "number" ? [item[0], item[1] * 2] : [item[0], item[1]]) 5 | return Object.fromEntries(aux) 6 | } 7 | 8 | let menu = { 9 | width: 200, 10 | height: 300, 11 | title: "Mi menú" 12 | }; 13 | console.log(multiplyNumeric(menu)) -------------------------------------------------------------------------------- /201-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que dado un objeto con productos y precios, y la cantidad de dinero disponible, true si puede comprarlos a todos o false si no 2 | 3 | const canBuyAllProduct = (money, products) => { 4 | return Object.values(products).reduce((acc, current) => acc + current,0) < money 5 | 6 | } 7 | 8 | const products = { cookies: 60, chocolate: 110, soda: 120, } 9 | const money = 300 10 | console.log(canBuyAllProduct(money, products)) 11 | -------------------------------------------------------------------------------- /78-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Dada una matriz de números pares e impares, devuelve una matriz de números pares y convierte números impares en pares. 2 | 3 | const paresImpares = (array) => array.map((number) => number % 2 !== 0 ? number + 1 : number) 4 | 5 | 6 | console.log(paresImpares([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])) // [2, 2, 4, 4, 6, 6, 8, 8, 10, 10] 7 | console.log(paresImpares([1, 3, 5, 7, 9])) // [2, 4, 6, 8, 10] 8 | console.log(paresImpares([2, 4, 6, 8, 10])) // [2, 4, 6, 8, 10] -------------------------------------------------------------------------------- /76-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Implemente una función de JavaScript que tome una matriz de números y devuelva una nueva matriz con los números en orden inverso. 2 | 3 | 4 | const reverseArray = (arr) => { 5 | const res = [] 6 | for(let i = arr.length - 1; i>=0; i--){ 7 | res.push(arr[i]) 8 | } 9 | return res; 10 | } 11 | 12 | 13 | console.log(reverseArray([1, 2, 3, 4, 5])); // [5, 4, 3, 2, 1] 14 | console.log(reverseArray([9, 9, 2, 3, 4])); // [4, 3, 2, 9, 9] -------------------------------------------------------------------------------- /77-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Given a Quadratic Equation $$ ax^2+bx+c=0 $$ 2 | 3 | //We wish to find the solutions for x. We derive the quadratic formula from the equation above. $$ x = -b \pm \sqrt(b^2 - 4ac) / 2a $$ 4 | 5 | const ecuacionCuadratica = (a, b, c) => { 6 | let res1 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a); 7 | let res2 = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a); 8 | return [res1, res2]; 9 | } 10 | 11 | console.log(ecuacionCuadratica(1,8,15)) -------------------------------------------------------------------------------- /187-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name flatArray 3 | * @description Dado un array 2D, devuelve un array 1D que contiene todos los ítems 4 | * 5 | * @param {[][]} arr - Array 2D a "aplanar" 6 | * @returns {[]} - El array "aplanado" 7 | * 8 | * @example 9 | * flatArray([[1, 5, 4], [3, 10], [2, 5]]) // returns [1, 5, 6, 3, 10, 2, 5] 10 | */ 11 | 12 | const flatArray = (arr) => { 13 | return arr.flat(Infinity) 14 | } 15 | console.log(flatArray([[1, 5, 4], [3, 10], [2, 5]])) -------------------------------------------------------------------------------- /44-ejercicio.js: -------------------------------------------------------------------------------- 1 | import { characters } from "./data/characters.js" 2 | 3 | //ordernar por mass 4 | const sortedMass = (arr) => { 5 | return arr.sort((a, b) => { 6 | return a.mass - b.mass 7 | }) 8 | } 9 | 10 | console.log(sortedMass(characters)) 11 | 12 | 13 | //ordernar por altura 14 | const sortedAltura = (arr) => { 15 | return arr.sort((a, b) => { 16 | return a.height - b.height 17 | }) 18 | } 19 | 20 | console.log(sortedAltura(characters)) -------------------------------------------------------------------------------- /59-ejercicio.js: -------------------------------------------------------------------------------- 1 | //verificar que un objeto es un objeto (de tipo objeto) 2 | const isPlainObject = (obj) => { 3 | return typeof obj === "object" && obj !== null && !Array.isArray(obj) 4 | } 5 | 6 | console.log(isPlainObject({a:1})) 7 | console.log(isPlainObject([])) 8 | console.log(isPlainObject(null)) 9 | console.log(isPlainObject(undefined)) 10 | console.log(isPlainObject("")) 11 | console.log(isPlainObject(0)) 12 | console.log(isPlainObject(false)) 13 | -------------------------------------------------------------------------------- /101-ejercicio.js: -------------------------------------------------------------------------------- 1 | // obtner el factorial de un numero 2 | 3 | const factorial = (n) => { 4 | let res = 1; 5 | for (let i = 1; i <= n; i++) { 6 | res *= i; 7 | } 8 | console.log(res); 9 | }; 10 | 11 | console.log(factorial(5)); 12 | 13 | const factorialReduce = (n) => { 14 | const arr = []; 15 | for (let i = 1; i <= n; i++) { 16 | arr.push(i); 17 | } 18 | return arr.reduce((acc, numero) => acc * numero, 1); 19 | }; 20 | 21 | console.log(factorialReduce(5)); 22 | -------------------------------------------------------------------------------- /178-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getBiggestNumber 3 | * @description Devuelve el número más grande de un array 4 | * 5 | * @param {number[]} numbers - Un array de números 6 | * @returns {Number} El número más grande del arrray {numbers} 7 | * 8 | * @example 9 | * getBiggestNumber([3, 8, 2, 1, 10]) // returns 10 10 | */ 11 | 12 | function getBiggestNumber(numbers) { 13 | return Math.max(...numbers); 14 | } 15 | 16 | console.log(getBiggestNumber([3, 8, 2, 1, 10])); //10 17 | -------------------------------------------------------------------------------- /97-ejercicio.js: -------------------------------------------------------------------------------- 1 | const isPrime = (n) => { 2 | if (n <= 1) { 3 | return false; 4 | } 5 | for (let i = 2; i <= n - 1; i++) { 6 | if (n % i === 0) { 7 | return false; 8 | } 9 | } 10 | return true; 11 | }; 12 | 13 | const sumaPrimo = (n) => { 14 | let suma = 0; 15 | if (n < 2) return 0; 16 | for (let i = 2; i <= n; i++) { 17 | if (isPrime(i)) { 18 | suma += i; 19 | } 20 | } 21 | return suma; 22 | }; 23 | 24 | console.log(sumaPrimo(100)); 25 | -------------------------------------------------------------------------------- /164-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita ingresar perros y gatos y devuelva un mensaje con los perros agrupados por un lado y los gatos por otro. 2 | const perrosGatos = (arr) => { 3 | const perros = arr.filter((item) => item === "🐶") 4 | const gatos = arr.filter((item) => item === "🐱") 5 | return perros.concat(gatos) 6 | } 7 | console.log(perrosGatos(["🐶","🐱","🐶","🐱","🐱","🐶","🐶"])) 8 | 9 | // Ingrese perros y gatos: 🐶🐱🐶🐱🐱🐶🐶 10 | // Resultado: 🐶🐶🐶🐶🐱🐱🐱 11 | -------------------------------------------------------------------------------- /46-ejercicio.js: -------------------------------------------------------------------------------- 1 | // escribir una fn cleanNames que limpie las cadenas del arreglo 2 | 3 | const cleanNames = (arr) => { 4 | if(!Array.isArray(arr)) return "De sebe pasar un arreglo" 5 | if(arr.some((name) => typeof name !== "string")) return "Todos los elementos deben ser strings" 6 | return arr.map((name) => name.trim()) 7 | } 8 | 9 | console.log(cleanNames([" avengers", " captain_america", "ironman ", " black panther "])) 10 | console.log(cleanNames([1,2,3])) 11 | console.log(cleanNames(1)) -------------------------------------------------------------------------------- /89-ejercicio.js: -------------------------------------------------------------------------------- 1 | // veriricar si un numero es palindromo pero sin convetirlo a string 2 | 3 | const isPalindrome = (number) => { 4 | const arr = [] 5 | while(number > 0){ 6 | let lastDigit = number % 10; 7 | arr.push(lastDigit); 8 | number = Math.floor(number / 10); 9 | } 10 | return arr.join('') === arr.reverse().join('') 11 | } 12 | 13 | console.log(isPalindrome(121)); // true 14 | console.log(isPalindrome(1221)); // true 15 | console.log(isPalindrome(12)); // false 16 | -------------------------------------------------------------------------------- /184-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name areArraysEqual 3 | * @description Devuelve si dos arrays son iguales (tienen los mismos ítems en el mismo orden) 4 | * 5 | * @param {[]} a 6 | * @param {[]} b 7 | * @returns {Boolean} - Devuelve true si ambos arrays son iguales, false sino 8 | * 9 | * @example 10 | * areArraysEqual([1, 4], [1, 4]) // returns true 11 | */ 12 | 13 | const areArraysEqual = (a, b) => { 14 | return JSON.stringify(a) === JSON.stringify(b) 15 | } 16 | console.log(areArraysEqual([1, 4], [1, 4])) -------------------------------------------------------------------------------- /186-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getFileExtension 3 | * @description Obtiene la extensión de un archivo 4 | * 5 | * @param {string} file - El nombre del archivo a obtener la extensión 6 | * @returns {String} - La extensión del archivo 7 | * 8 | * @example 9 | * getFileExtension("imagen.jpg") // returns "jpg" 10 | */ 11 | 12 | const getFileExtension =(file) => { 13 | return file.split(".").at(-1) 14 | } 15 | 16 | console.log(getFileExtension("imagen.jpg")) 17 | console.log(getFileExtension("imagen-2.1.jpg")) -------------------------------------------------------------------------------- /156-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que pida ingresar nombres separados por espacios y devuelva un mensaje que contenga un saludo a cada persona. Ejemplo: 2 | const saludos = (nombres) => { 3 | let arrNombres = nombres.split(" ") 4 | let arrNombresSaludo = arrNombres.map((nombre) => `¡Hola ${nombre}!`) 5 | for(let i=0; i<=arrNombresSaludo.length; i++){ 6 | console.log(arrNombresSaludo[i]) 7 | } 8 | } 9 | 10 | saludos("Ada Greta Grace") 11 | 12 | // ¡Hola Ada! 13 | // ¡Hola Greta! 14 | // ¡Hola Grace! -------------------------------------------------------------------------------- /162-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita saber si Sam y Frodo están juntos.El programa debe permitir ingresar nombres separados por espacios, y mostrar con un mensaje si Sam se encuentra al lado de Frodo, ya sea antes o después. 2 | 3 | const contadorFrutas = (frutas) => { 4 | let arr = Object.entries(Object.groupBy(frutas, (item) => item)) 5 | for([key, value] of arr){ 6 | console.log(key, value.length) 7 | } 8 | } 9 | 10 | console.log(contadorFrutas(["manzana","pera", "fresa", "manzana", "fresa"])) 11 | -------------------------------------------------------------------------------- /199-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que tome como argumentos un objeto y un array con strings, y devuelva el objeto con solo las propiedades especificadas en el array 2 | 3 | 4 | 5 | const removeProperties = (data, props) => { 6 | const res = {} 7 | for(key in data){ 8 | if(props.includes(key)){ 9 | res[key]= data[key] 10 | } 11 | } 12 | return res 13 | } 14 | console.log(removeProperties({ a: 1, b: 2, c: 3 }, ["c"])) 15 | console.log(removeProperties({ a: 1, b: 2, c: 3 }, ["c", "b"])) -------------------------------------------------------------------------------- /74-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escriba una función que devuelva la cantidad de datos incorrectos en una matriz. 2 | 3 | const countBadData = (arr) => { 4 | return arr.filter(item => item < 0 || typeof item === "string").length 5 | } 6 | 7 | console.log(countBadData([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])); // 0 8 | console.log(countBadData([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "L-B"])); // 1 9 | console.log(countBadData([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "L-B", "L-B"])); // 2 10 | console.log(countBadData([1, 2, 3, 4, 5, 6, 7, -8, 9, -10, "L-B", "L-B"])); // 4 -------------------------------------------------------------------------------- /183-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getFactorial 3 | * @description Devuelve el factorial de un número 4 | * 5 | * @param {number} x - Número del cuál obtener factorial 6 | * @returns {Number} - Factorial de {x} 7 | * 8 | * @example 9 | * getFactorial(4) // returns 24 10 | */ 11 | 12 | const getFactorial = (x) => { 13 | let res = 1; 14 | for(let i = 1; i<=x; i++){ 15 | res *=i 16 | } 17 | return res 18 | } 19 | console.log(getFactorial(4)) // 4 * 3 * 2 * 1 20 | console.log(getFactorial(5)) // 5 * 4 * 3 * 2 * 1 -------------------------------------------------------------------------------- /84-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Dada una matriz de números, encuentre los números más altos y más bajos de la matriz. 2 | 3 | let numbers = [5, 3, 8, 2, 9]; // Min: 2, Max: 9 4 | let numbers2 = [4, 10, 18, 2, 3]; // Min: 2, Max: 18 5 | let numbers3 = [0, 100, 8, 21, 39]; // Min: 0, Max: 100 6 | 7 | const minMax= (arr) => { 8 | const min = Math.min(...arr); 9 | const max = Math.max(...arr); 10 | return { 11 | min,max 12 | } 13 | } 14 | 15 | console.log(minMax(numbers)) 16 | console.log(minMax(numbers2)) 17 | console.log(minMax(numbers3)) -------------------------------------------------------------------------------- /98-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dato un arreglo de nombres, obtener la inicial de cada nombre en un nuevo arreglo 2 | 3 | const getIniciales = (nombres) => { 4 | return nombres.map((nombreCompleto) => { 5 | const agruparNombres = nombreCompleto.split(" "); 6 | return agruparNombres 7 | .map((nombresSueltos) => nombresSueltos.at(0)) 8 | .join(""); 9 | }); 10 | }; 11 | 12 | console.log( 13 | getIniciales([ 14 | "Alice Johnson Suarez", 15 | "Bob Brown", 16 | "Charlie Davis", 17 | "David Smith Chavez", 18 | ]) 19 | ); 20 | -------------------------------------------------------------------------------- /113-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribe una función en JavaScript que tome un array de cadenas de texto como entrada. La función debe ordenar las cadenas de texto de manera ascendente según la longitud de las palabras. 2 | 3 | const palabras = ["manzana", "pera", "kiwi", "limon", "uva", "melón", "banana"]; 4 | 5 | const ordenarPorLongitud = (arr) => { 6 | return arr.sort((a, b) => { 7 | if (a.length < b.length) return 1; 8 | if (a.length > b.length) return -1; 9 | return 0; 10 | }); 11 | }; 12 | 13 | console.log(ordenarPorLongitud(palabras)); 14 | -------------------------------------------------------------------------------- /180-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getRockPaperScissor 3 | * @description Devuelve una jugada aleatoria de piedra, papel o tijera 4 | * 5 | * @returns {String} - Devuelve "rock", "paper" o "scissor" 6 | * 7 | * @example 8 | * getRockPaperScissor() // returns "paper" 9 | */ 10 | 11 | const getRockPaperScissor = () => { 12 | let random = Math.floor(Math.random() * 3) +1 // 1 2 3 13 | let obj = { 14 | 1: "piedra", 15 | 2: "papel", 16 | 3: "tijera" 17 | }; 18 | return obj[random] 19 | } 20 | console.log(getRockPaperScissor()) -------------------------------------------------------------------------------- /200-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que dado un objeto con productos y precios, y la cantidad de dinero disponible, devuelva un objeto con dichos productos, teniendo como valor true si puede comprarlo o false sino 2 | 3 | 4 | 5 | const buyProducts = (money, products) => { 6 | let aux = Object.entries(products).map((item) => item[1]>=money ? [item[0],false] : [item[0], true]) 7 | return Object.fromEntries(aux) 8 | } 9 | 10 | const products = { cookies: 60, chocolate: 110, soda: 120, } 11 | const money = 115 12 | console.log(buyProducts(money, products)) -------------------------------------------------------------------------------- /179-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getPercentage 3 | * @description Devuelve el porcentaje correspondiente de un número 4 | * 5 | * @param {number} number - Número a obtener el porcentage 6 | * @param {number} percentage - Porcentaje a obtener 7 | * @returns {Number} 8 | * 9 | * @example 10 | * getPercentage(200, 10) // returns 20 11 | */ 12 | 13 | const getPercentage = (number, percentage) => { 14 | return (number * percentage) / 100; 15 | } 16 | 17 | console.log(getPercentage(200, 10)) // returns 20 18 | console.log(getPercentage(1, 10)) // returns 0.1 -------------------------------------------------------------------------------- /67-ejericicio.js: -------------------------------------------------------------------------------- 1 | // Escriba un programa que imprima los números del 1 al 100. Pero para los múltiplos de tres imprima "Fizz" 2 | //en lugar del número y para los múltiplos de cinco imprima "Buzz".Para números que sean 3 | //múltiplos de tres y cinco, imprima "FizzBuzz". 4 | 5 | for(let i = 1; i<= 100; i++){ 6 | if(i%3 === 0 && i%5 === 0){ 7 | console.log("FizzBuzz") 8 | }else if(i % 3 === 0){ 9 | console.log("Fizz") 10 | }else if(i%5=== 0){ 11 | console.log("Buzz") 12 | }else{ 13 | console.log(i) 14 | } 15 | } 16 | 17 | -------------------------------------------------------------------------------- /195-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que dos objetos como argumentos, y devuelva un objeto que sea la unión de ambos. Es decir, debe contener las propiedades de ambos objetos. Para aquellas propiedades que están compartidas entre ambos, como un objeto no puede tener propiedades repetidas, se debe priorizar el objeto del primer parámetro. 2 | 3 | 4 | 5 | const merge = (obj1, obj2) => { 6 | return {...obj2, ...obj1} 7 | } 8 | 9 | const info1 = { a: 1, b: 2, c: 3 } 10 | const info2 = { d: 4, b: 5 } 11 | console.log(merge(info1, info2)) // returns {a: 1, b: 2, c: 3, d: 4} -------------------------------------------------------------------------------- /47-ejercicio.js: -------------------------------------------------------------------------------- 1 | // convertir un arreglo de millas a km 2 | // regresar el total del arreglo convertido 3 | const convertMilesToKilometers = (miles) =>{ 4 | if(!Array.isArray(miles)) return "Debes ingresar un array" 5 | if(miles.some((mile) => typeof mile !== "number")) return "Debe ser un arreglo de numeros" 6 | return miles.map((mile) => mile* 1.60934).reduce((item,acc) => item + acc,0) 7 | } 8 | 9 | console.log(convertMilesToKilometers([1,2,3])); 10 | console.log(convertMilesToKilometers([1,2,3,4,5])); 11 | console.log(convertMilesToKilometers([1,2,"3",4,5])); -------------------------------------------------------------------------------- /08-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Verifica si el elemento existe dentro del arreglo recibido. 2 | // Retornar true si está, o false si no está. 3 | // Tu código: 4 | function arrayContiene(array, elemento) { 5 | if(!Array.isArray(array)){ 6 | return "El primer argumento debe ser un arreglo" 7 | } 8 | return array.includes(elemento); 9 | } 10 | 11 | console.log(arrayContiene([1, 2, 3], 1)); // true 12 | console.log(arrayContiene([1, 2, 3], 4)); // false*/ 13 | console.log(arrayContiene(3, 4)); 14 | console.log(arrayContiene(["Pedro", "Juan", "Maria"], "Juan")); // true 15 | -------------------------------------------------------------------------------- /48-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado el arr heros: 2 | // agregar el campo id, autoicrmental 3 | // cambiar las llaves "name" a "nombre" 4 | 5 | const heros = [ 6 | { name: 'Spider-Man' }, 7 | { name: 'Thor' }, 8 | { name: 'Black Panther' }, 9 | { name: 'Captain Marvel' }, 10 | { name: 'Silver Surfer' } 11 | ]; 12 | 13 | const cambiarHeros = (heros) =>{ 14 | return heros.map((hero,index) => { 15 | return { 16 | id: index +1, 17 | nombre: hero.name 18 | } 19 | }) 20 | } 21 | 22 | console.log(cambiarHeros(heros)); 23 | -------------------------------------------------------------------------------- /159-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permite ingresar valores separados por espacios, y luego preguntar qué valor se desea averiguar si existe.El programa debe devolver un mensaje diciendo si dicho valor se encuentra dentro de los valores originales o no. 2 | 3 | const verificarValor = (numeros, valor) => { 4 | let arrNumeros = numeros.split(" ").map((item) => Number(item)); 5 | return arrNumeros.includes(valor) 6 | } 7 | 8 | // Ingrese valores: 5 7 99 34 54 2 12 9 | // Ingrese valor a buscar: 54 10 | // return:true 11 | console.log(verificarValor("5 7 99 34 54 2 12", 54)) -------------------------------------------------------------------------------- /19-ejercicio.js: -------------------------------------------------------------------------------- 1 | // La función recibe un arreglo con enteros entre 0 y 200. 2 | // Recorrerlo y retornar un arreglo con todos los valores mayores a 100 (no incluye el 100). 3 | // Tu código: 4 | function mayorACien(array) { 5 | if(!Array.isArray(array)) return "No es un arreglo"; 6 | if(array.some((item) => item < 0 || item > 200)) return "No es un arreglo con valores entre 0 y 200"; 7 | return array.filter(e => e > 100 && e < 200) 8 | } 9 | 10 | console.log(mayorACien([150,196,147,25,14,159])) 11 | console.log(mayorACien([1,2,6,4])) 12 | console.log(mayorACien([-5,522,55])) 13 | -------------------------------------------------------------------------------- /100-ejercicio.js: -------------------------------------------------------------------------------- 1 | // obtener el promedio ponderado 2 | 3 | const cursos = [ 4 | { nombre: "Matemáticas", creditos: 3, calificacion: 90 }, 5 | { nombre: "Historia", creditos: 4, calificacion: 85 }, 6 | { nombre: "Inglés", creditos: 2, calificacion: 88 }, 7 | ]; 8 | 9 | const calcularPromedioPonderado = (cursos) => { 10 | return ( 11 | cursos.reduce( 12 | (acc, curso) => acc + curso.creditos * curso.calificacion, 13 | 0 14 | ) / cursos.reduce((acc, curso) => acc + curso.creditos, 0) 15 | ).toFixed(2); 16 | }; 17 | 18 | console.log(calcularPromedioPonderado(cursos)); 19 | -------------------------------------------------------------------------------- /152-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que pida una estación del año y mostrar en un mensaje la fecha en la que comienza y termina 2 | 3 | const getEstaciones = (mes) => { 4 | switch (mes) { 5 | case "primavera": 6 | return "21 de septiembre a 20 de diciembre"; 7 | case "verano": 8 | return "21 de diciembre a 20 de marzo"; 9 | case "otoño": 10 | return "21 de marzo a 20 de junio"; 11 | case "invierno": 12 | return "21 de junio a 20 de septiembre"; 13 | } 14 | }; 15 | 16 | console.log(getEstaciones("primavera")); 17 | console.log(getEstaciones("otoño")); 18 | -------------------------------------------------------------------------------- /62-ejercicio.js: -------------------------------------------------------------------------------- 1 | // escribir una funcion que verifique si un objeto esta vacio 2 | // Empty values: '', null, NaN, undefined 3 | 4 | const isEmpty = (obj) => { 5 | const values = Object.values(obj) 6 | const vacios = [undefined, null, "", NaN] 7 | return values.every(value => vacios.includes(value)) 8 | 9 | } 10 | 11 | console.log(isEmpty({})) // true 12 | console.log(isEmpty({a: undefined})) // true 13 | console.log(isEmpty({a : ""})) // true 14 | console.log(isEmpty({a :null})) // true 15 | console.log(isEmpty({a: NaN})) // true 16 | 17 | console.log(isEmpty({a:"Hola"})) // false -------------------------------------------------------------------------------- /91-ejercicio.js: -------------------------------------------------------------------------------- 1 | // filtrarLibrosPorAutor debe regresar un nuevo arr con todos los libros del autor pasado por parametro 2 | const libros = [ 3 | { titulo: "Cien años de soledad", autor: "Gabriel García Márquez", paginas: 432 }, 4 | { titulo: "1984", autor: "George Orwell", paginas: 328 }, 5 | { titulo: "Matar un ruiseñor", autor: "Harper Lee", paginas: 281 }, 6 | ]; 7 | 8 | const filtrarLibrosPorAutor = (arrLibros, autor) => { 9 | return arrLibros.filter((libro) => libro.autor === autor) 10 | } 11 | 12 | console.log(filtrarLibrosPorAutor(libros, "Gabriel García Márquez")) -------------------------------------------------------------------------------- /72-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crea una función que devuelva el enésimo número de Fibonacci. 2 | 3 | const NthNumberFibonacci = (n) => { 4 | if(n <=0) return 0; 5 | if(n <=1) return 1; 6 | return NthNumberFibonacci(n-1) + NthNumberFibonacci(n-2); // recursividad, se llama a si misma para obtener el siguiente número de Fibonacci. 7 | } 8 | 9 | console.log(NthNumberFibonacci(10))// 55 10 | console.log(NthNumberFibonacci(6)) // 8 11 | console.log(NthNumberFibonacci(0)) // 0 12 | console.log(NthNumberFibonacci(1)) // 1 13 | console.log(NthNumberFibonacci(2)) // 1 14 | console.log(NthNumberFibonacci(3)) // 2 -------------------------------------------------------------------------------- /167-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que pida ingresar números separados por espacios y luego pregunte por cuánto se desea multiplicar cada número. El programa debe devolver un mensaje con un array donde cada elemento es el resultado del elemento del primer array (en la misma posición) multiplicado por el número ingresado. 2 | 3 | const multiplicarArr = (x, ...arr) => { 4 | return arr.map((item) => item * x); 5 | }; 6 | 7 | // Ingrese números: 5 7 15 22 40 8 | // Ingrese multiplicador: 2 9 | 10 | // El array resultante es: [10, 14, 30, 44, 80] 11 | 12 | console.log(multiplicarArr(2, 5, 7, 15, 22, 40)); 13 | -------------------------------------------------------------------------------- /169-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita ingresar dos listas de valores separados por espacio y muestre en un mensaje si las listas son iguales o no(mismos valores en mismo orden). 2 | 3 | const arrIguales = (arr1, arr2) => { 4 | return JSON.stringify(arr1) === JSON.stringify(arr2); 5 | }; 6 | // Ingrese valores de lista 1: 10 25 6 33 48 105 7 | // Ingrese valores de lista 2: 10 24 6 33 48 105 8 | 9 | // Las listas no son iguales 10 | 11 | console.log(arrIguales([10, 25, 6, 33, 48, 105], [10, 24, 6, 33, 48, 105])); 12 | console.log(arrIguales([10, 25, 6, 33, 48, 105], [10, 25, 6, 33, 48, 105])); 13 | -------------------------------------------------------------------------------- /172-ejercicio.js: -------------------------------------------------------------------------------- 1 | function gusanoHambriento(lista) { 2 | // Buscar la posición de la oruga y la calavera (veneno) 3 | const indiceOruga = lista.indexOf("🐛"); 4 | const indiceVeneno = lista.indexOf("💀"); 5 | 6 | return lista.slice(0, indiceOruga).concat(lista.slice(indiceVeneno + 1)); 7 | } 8 | 9 | console.log( 10 | gusanoHambriento(["🌱", "🌻", "🌱", "🐛", "🌱", "🌸", "🌱", "🌱", "💀", "🌷"]) 11 | ); 12 | // Ingrese plantas y oruga: 🌱🌻🌱🐛🌱🌸🌱🌱💀🌷 13 | // Plantas sobrevivientes: 🌱🌻🌱🌷 14 | console.log( 15 | gusanoHambriento(["🐛", "🌻", "🌱", "🌱", "🌸", "🌱", "🌱", "💀", "🌷"]) 16 | ); 17 | -------------------------------------------------------------------------------- /115-ejercicio.js: -------------------------------------------------------------------------------- 1 | // hacer una funcion que reciba por paremetro un objeto y un array de strings que representan las keys del objeto 2 | // la funcion debe retornar el objeto sin los strings que se encuentren en el array 3 | 4 | const persona = { 5 | nombre: "Cris", 6 | edad:27, 7 | pais:"Bolivia", 8 | profesion:"Desarrollador web" 9 | }; 10 | 11 | const eliminarItemObj = (obj, keys) => { 12 | const newObj = {...obj}; 13 | keys.forEach((key) => { 14 | delete newObj[key]; 15 | },{}) 16 | return newObj; 17 | } 18 | 19 | console.log(eliminarItemObj(persona, ["pais", "edad", "test"])); -------------------------------------------------------------------------------- /114-ejercicio.js: -------------------------------------------------------------------------------- 1 | // hacer una funcion que reciba como parametro un objeto y un arreglo de strings 2 | // la funcion debe regresar los valores del objeto indicados en el arreglo de strings 3 | 4 | const persona = { 5 | nombre: "cris", 6 | edad: 15, 7 | altura: 180, 8 | peso: 80, 9 | }; 10 | 11 | const selectObj = (obj, keys) => { 12 | return keys.reduce((acc, key) => { 13 | if (obj.hasOwnProperty(key)) { 14 | console.log(key); 15 | acc[key] = obj[key]; 16 | return acc; 17 | } 18 | return acc; 19 | }, {}); 20 | }; 21 | 22 | console.log(selectObj(persona, ["nombre", "peso", "test"])); 23 | -------------------------------------------------------------------------------- /87-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escriba una función que tome una cadena y devuelva la extensión del archivo, que es la cadena después del último punto (.) de la cadena. Si no hay ningún punto en la cadena, devuelve una cadena vacía. 2 | 3 | 4 | const extractFileExtension = (fileName) => { 5 | if(!fileName.includes(".")) return " "; 6 | return fileName.split(".").at(-1) 7 | } 8 | 9 | console.log(extractFileExtension("trabajo.exe")) //exe 10 | console.log(extractFileExtension("87-ejercicio.js")) // js 11 | console.log(extractFileExtension("hola.mundo.desde.cris.jpg")) // jpg 12 | console.log(extractFileExtension("hola mundo")) // "" -------------------------------------------------------------------------------- /56-ejercicio.js: -------------------------------------------------------------------------------- 1 | //escribir una funcion que compare dos arreglos y regrese true si son iguales, false si son diferentes 2 | 3 | const isEqual = (firstArray, secondArray) => { 4 | return JSON.stringify(firstArray) === JSON.stringify(secondArray) 5 | } 6 | 7 | const isEqual2 = (firstArray, secondArray) => { 8 | return firstArray.length === secondArray.length && firstArray.every((item, index) => item === secondArray[index]) 9 | } 10 | 11 | console.log(isEqual([1,2,3],[1,2,3])) 12 | console.log(isEqual2([1,2,3],[1,2,3])) 13 | console.log(isEqual2([1,2,3],[1,2,3,4])) 14 | console.log(isEqual([1,2,3],[1,2,3,4])) -------------------------------------------------------------------------------- /01-ejercicio.js: -------------------------------------------------------------------------------- 1 | (() => { 2 | // Retornar el primer elemento del arreglo recibido por parámetro. 3 | const devolverPrimerElemento = (array) => { 4 | if(array.length === 0) return {"message": "El arreglo no puede estar vacio"} 5 | if(!Array.isArray(array)) return {"message": "El parámetro debe ser un arreglo"} 6 | return array[0]; 7 | } 8 | console.log(devolverPrimerElemento([1,2,3,4,5])); 9 | console.log(devolverPrimerElemento([1])); 10 | console.log(devolverPrimerElemento([])); 11 | console.log(devolverPrimerElemento("Hola mundo")); 12 | console.log(devolverPrimerElemento(5)); 13 | console.log(devolverPrimerElemento({})); 14 | })(); -------------------------------------------------------------------------------- /188-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name removeDuplicates 3 | * @description Remueve duplicados de un array 4 | * 5 | * @param {[]} arr - Array con duplicados a remover 6 | * @returns {[]} - El array resultante sin duplicados 7 | * 8 | * @example 9 | * removeDuplicates([4, 5, 10, 4, 10, 2]) // returns [4, 5, 10, 2] 10 | */ 11 | 12 | // no usar Set 13 | const removeDuplicates = (arr) => { 14 | let res = [] 15 | for(let i = 0; i { 9 | return palabras.split(" ").map((item) => item.slice(0,x)) 10 | } 11 | 12 | console.log(recortarPalabras("elefante sociedad chocolate avion america", 4)) -------------------------------------------------------------------------------- /71-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escriba una función que devuelva una nueva matriz de valores verdaderos y falsos basada en la matriz de entrada. La función debería devolver verdadero si el elemento correspondiente es un archivo JavaScript. 2 | 3 | const isJavaScriptFile = (array) => { 4 | return array.map(file => file.endsWith('.js')); 5 | } 6 | 7 | console.log(isJavaScriptFile(['L-B.js', 'L-B.css', 'L-B.html', 'L-B.js'])); 8 | // [true, false, false, true] 9 | console.log(isJavaScriptFile(['L-B.js', 'L-B.js', 'L-B.js', 'L-B.js'])); 10 | // [true, true, true, true] 11 | console.log(isJavaScriptFile(['L-B.css', 'L-B.css', 'L-B.css', 'L-B.css'])); 12 | // [false, false, false, false] -------------------------------------------------------------------------------- /141-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Hacer una función que reciba un array de strings y retorne una string igual a la concatenación de todos sus elementos. 2 | 3 | const concatenar = (arr) => { 4 | return arr.join(""); 5 | }; 6 | 7 | console.log(concatenar(["s", "a", "r", "a", "s", "a"])); // imprime "sarasa" 8 | console.log(concatenar(["h", "o", "l", "a"])); // imprime "hola" 9 | 10 | const concatenar2 = (arr) => { 11 | let res = ""; 12 | for (let i = 0; i < arr.length; i++) { 13 | res += arr[i]; 14 | } 15 | return res; 16 | }; 17 | 18 | console.log(concatenar2(["s", "a", "r", "a", "s", "a"])); // imprime "sarasa" 19 | console.log(concatenar2(["h", "o", "l", "a"])); // imprime "hola" 20 | -------------------------------------------------------------------------------- /09-ejercicio.js: -------------------------------------------------------------------------------- 1 | // El parámetro "arrayOfNums" debe ser un arreglo de números. 2 | // Suma todos los elementos y retorna el resultado. 3 | // Tu código: 4 | function numeroMasGrande(arrayOfNums) { 5 | if(!Array.isArray(arrayOfNums)) return "El parametro debe ser un arreglo" 6 | if(arrayOfNums.some((item) => typeof item !== "number")) return "Los elementos deben ser numeros" 7 | return arrayOfNums.reduce((acc, curr) => acc + curr, 0) 8 | } 9 | 10 | console.log(numeroMasGrande([1,2,3,4,5])); 11 | console.log(numeroMasGrande([])); 12 | console.log(numeroMasGrande([1,2,3,4,"5"])) 13 | console.log(numeroMasGrande(6)) 14 | console.log(numeroMasGrande({})) 15 | console.log(numeroMasGrande(false)) -------------------------------------------------------------------------------- /153-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita elegir entre las operaciones: SUMA, RESTA, DIVISION y MULTIPLICACION, y luego de elegida, ingresar dos números y hacer dicha operación con ella. 2 | 3 | const calculadora = (op, x, y) => { 4 | switch (op) { 5 | case "SUMA": 6 | return x + y; 7 | case "RESTA": 8 | return x - y; 9 | case "MULTIPLICACION": 10 | return x * y; 11 | case "DIVISION": 12 | return y !== 0 ? x / y : "no div 0"; 13 | } 14 | }; 15 | 16 | console.log(calculadora("SUMA", 52, 9)); 17 | console.log(calculadora("MULTIPLICACION", 2, 5)); 18 | console.log(calculadora("DIVISION", 5, 0)); 19 | console.log(calculadora("DIVISION", 10, 5)); 20 | -------------------------------------------------------------------------------- /205-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Los parámetros de búsqueda en una URL son aquellos que vienen después del signo ? y se escriben como parametro=valor, separados por el signo &. Crear una función que dada una URL, devuelva un objeto con cada parámetro como clave con su respectivo valor. 2 | 3 | const parseQueryParams = (url) => { 4 | const myUrl = new URL(url); 5 | let res = {} 6 | myUrl.searchParams.forEach((value, key) => { 7 | res[key] = value 8 | }) 9 | return res; 10 | } 11 | 12 | console.log(parseQueryParams 13 | ("http://www.exercises.com?keyword=objects&language=javascript&level=intermediate")) 14 | // returns { keyword: "objects", language: "javascript", level: "intermediate } -------------------------------------------------------------------------------- /16-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Si todos los elementos del arreglo son iguales, retornar true. 2 | // Caso contrario retornar false. Usar array methods de javascript 3 | // Tu código: 4 | function todosIguales(array) { 5 | if(!Array.isArray(array)) return "Debe ser un arreglo"; 6 | if(array.length === 0) return false 7 | return array.every(element => element === array[0]) 8 | } 9 | 10 | 11 | console.log(todosIguales([1, 1, 1, 1])) // true 12 | console.log(todosIguales([1, 1, 1, 2])) // false 13 | console.log(todosIguales([1, 2])) // false 14 | console.log(todosIguales([1])) // true 15 | console.log(todosIguales([])) // true 16 | console.log(todosIguales(["hola", "hola", "hola", "hola"])) // true 17 | -------------------------------------------------------------------------------- /02-ejericicio.js: -------------------------------------------------------------------------------- 1 | // Retornar el último elemento del arreglo recibido por parámetro. 2 | function devolverUltimoElemento(array) { 3 | if(array.length === 0) { 4 | return "No hay elementos en el array"; 5 | } 6 | if(!Array.isArray(array)) { 7 | return "El parámetro no es un array"; 8 | } 9 | return array.at(-1); 10 | } 11 | 12 | console.log(devolverUltimoElemento([1,2,3,4,5])); 13 | console.log(devolverUltimoElemento(["Hola", "mundo"])); 14 | console.log(devolverUltimoElemento([1])); 15 | console.log(devolverUltimoElemento([])); 16 | console.log(devolverUltimoElemento("Hola mundo")); 17 | console.log(devolverUltimoElemento(5)); 18 | console.log(devolverUltimoElemento({})); -------------------------------------------------------------------------------- /182-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name filterNumbersGreaterThan 3 | * @description Filtra los números de un array que sean mayor a cierto número x dejando solo los que sean menores a este 4 | * 5 | * @param {number[]} numbers - Array de números a filtrar 6 | * @param {number} filter - Número a partir del cuál filtrar los demás números 7 | * @returns {Number[]} - Array de números filtrados menores a {filter} 8 | * 9 | * @example 10 | * filterNumbersGreaterThan([3, 8, 12, 1, 7, 4], 7) // returns [3, 1, 4] 11 | */ 12 | 13 | const filterNumbersGreaterThan = (numbers, filter) => { 14 | return numbers.filter((number) => number { 14 | let res = []; 15 | [...text].forEach((item) => { 16 | if (item.includes(letter)) { 17 | res.push(letter); 18 | } 19 | }); 20 | return res.length; 21 | }; 22 | 23 | console.log(countLetter("a", "javascript")); 24 | -------------------------------------------------------------------------------- /138-ejercicio.js: -------------------------------------------------------------------------------- 1 | // crear una fn contarOcurrencias que cuente cuentas veces se repite una letra en un strign dado 2 | 3 | const contarOcurrencias = (str, letra) => { 4 | return str.split("").filter((item) => item === letra).length; 5 | }; 6 | 7 | console.log(contarOcurrencias("sarasa", "a")); // imprime 3 8 | console.log(contarOcurrencias("sarasa", "z")); // imprime 0 9 | 10 | const contarOcurrencias2 = (str, letra) => { 11 | let contador = 0; 12 | for (let i = 0; i <= str.length; i++) { 13 | if (str[i] === letra) contador++; 14 | } 15 | return contador; 16 | }; 17 | console.log(contarOcurrencias2("sarasa", "a")); // imprime 3 18 | console.log(contarOcurrencias2("sarasa", "z")); // imprime 0 19 | -------------------------------------------------------------------------------- /166-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita ingresar un conjunto de 5 símbolos y determine si son iguales.Si lo son, mostrar un mensaje indicando que se ha ganado.Si se ingresan más de 5 sólo deben evaluarse los primeros 5. 2 | 3 | const tragamonedas = (simbolos) => { 4 | const arrSimbolos = simbolos.slice(0, 5).split(""); 5 | console.log(arrSimbolos) 6 | const res = arrSimbolos.every((item, i, arr) => { 7 | return item === arr[0] // no se usa ternario dentro del every 8 | }) 9 | return res ? "ganaste": "perdiste" 10 | } 11 | 12 | console.log(tragamonedas("&&!*$")) // perdiste 13 | console.log(tragamonedas("&&&&&!")) // ganaste 14 | console.log(tragamonedas("*****")) // ganaste 15 | -------------------------------------------------------------------------------- /160-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permite ingresar valores separados por espacios, y luego preguntar qué valor se desea encontrar el índice. El programa debe devolver un mensaje con el índice del primer elemento que sea igual al buscado, o indicar si no se ha encontrado. 2 | 3 | const encontrarIndice = (numeros, valor) => { 4 | let numerosArray = numeros.split(" ").map((item) => Number(item)); 5 | if(!numerosArray.includes(valor)) return "error" 6 | return numerosArray.findIndex(item => item === valor) 7 | } 8 | 9 | console.log(encontrarIndice("5 7 12 34 54 2 12", 1)) // error 10 | console.log(encontrarIndice("5 7 12 34 54 2 12", 12)) // 2 11 | console.log(encontrarIndice("5 7 12 34 54 2 12", 2)) // 5 -------------------------------------------------------------------------------- /202-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que dado un objeto que contenga niveles de experiencia y puntaje por cada nivel, y un objeto con la cantidad de desafíos realizados por cada nivel, devuelva la cantidad total de experiencia obtenida 2 | 3 | const getXP = (challenges, score) => { 4 | let challengesValues = Object.values(challenges); 5 | let scoreValues = Object.values(score); 6 | let res = 0; 7 | challengesValues.forEach((item, i) => { 8 | res += item * scoreValues[i]; 9 | }); 10 | return res; 11 | }; 12 | 13 | const score = { EASY: 10, MEDIUM: 50, HARD: 100 }; 14 | const challenges = { EASY: 3, MEDIUM: 4, HARD: 2 }; 15 | console.log(getXP(challenges, score)); // returns 430 (3 * 10 + 4 * 50 + 2 * 100) 16 | -------------------------------------------------------------------------------- /04-ejericicio.js: -------------------------------------------------------------------------------- 1 | // El arreglo recibido por parámetro contiene números. 2 | // Retornar un arreglo con los elementos incrementados en +1. 3 | function incrementarPorUno(array) { 4 | if(!Array.isArray(array)) return "El argumento pasado debe ser un arreglo" 5 | if(array.length === 0) return 0 6 | if (array.some((item) => typeof item !== "number")) { 7 | return "Solo se aceptan numeros" 8 | } 9 | return array.map((item) => item + 1) 10 | } 11 | 12 | 13 | console.log(incrementarPorUno([1, 2, 3, 4, 5])); 14 | console.log(incrementarPorUno(["Hola", "mundo"])); 15 | console.log(incrementarPorUno([1])); 16 | console.log(incrementarPorUno([])); 17 | console.log(incrementarPorUno("Hola mundo")); 18 | -------------------------------------------------------------------------------- /data/characters.js: -------------------------------------------------------------------------------- 1 | export const characters = [ 2 | { 3 | name: 'Luke Skywalker', 4 | height: '172', 5 | mass: '77', 6 | eye_color: 'blue', 7 | gender: 'male', 8 | }, 9 | { 10 | name: 'Darth Vader', 11 | height: '202', 12 | mass: '136', 13 | eye_color: 'yellow', 14 | gender: 'male', 15 | }, 16 | { 17 | name: 'Leia Organa', 18 | height: '150', 19 | mass: '49', 20 | eye_color: 'brown', 21 | gender: 'female', 22 | }, 23 | { 24 | name: 'Anakin Skywalker', 25 | height: '188', 26 | mass: '84', 27 | eye_color: 'blue', 28 | gender: 'male', 29 | }, 30 | ]; 31 | -------------------------------------------------------------------------------- /15-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Esta función recibe por parámetro un número. 2 | // Debe retornar true si el entero inicia con 9 y false en otro caso. 3 | // Tu código: 4 | function empiezaConNueve(num) { 5 | if(typeof num !== "number") return "El parametro debe ser un numero"; 6 | const numeroAString = String(num) 7 | const primerDigito = Number(numeroAString[0]); 8 | return primerDigito === 9 9 | } 10 | 11 | console.log(empiezaConNueve(965)) 12 | console.log(empiezaConNueve(65)) 13 | console.log(empiezaConNueve(999)) 14 | console.log(empiezaConNueve(0)) 15 | console.log(empiezaConNueve(9)) 16 | console.log(empiezaConNueve("999")) 17 | console.log(empiezaConNueve([])) 18 | console.log(empiezaConNueve(true)) 19 | -------------------------------------------------------------------------------- /80-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Se le proporciona una matriz con dos cadenas. Escriba una función para verificar que todas las letras presentes en la segunda cadena también estén presentes en la primera cadena, ignorando el caso. La función debería devolver un valor booleano. 2 | 3 | 4 | const compararCadenas = (array) => { 5 | const [cadena1, cadena2] = array; 6 | let cadena1LowerCase = cadena1.toLowerCase(); 7 | let cadena2LowerCase = cadena2.toLowerCase(); 8 | return [...cadena2LowerCase].every(letra => [...cadena1LowerCase].includes(letra)); 9 | } 10 | 11 | console.log(compararCadenas(['hello', 'hey'])) //false 12 | console.log(compararCadenas(['hello', 'hello'])) //true 13 | console.log(compararCadenas(['React', 'cat'])) //true 14 | 15 | -------------------------------------------------------------------------------- /191-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name removeWords 3 | * @description Dado un string y un array de palabras a remover, 4 | * devuelve el string sin las palabras removidas 5 | * 6 | * @param {string} str - Texto a recortar 7 | * @param {string[]} words - Palabras a remover 8 | * @returns {string} - Texto resultante con las palabras removidas 9 | * 10 | * @example 11 | * removeWords("This is a really bad test", ["really", "bad"]) // returns "This is a test" 12 | */ 13 | 14 | const removeWords = (str, words) => { 15 | 16 | let res = str.split(" "); 17 | res = res.filter((item) => !words.includes(item)); 18 | return res.join(" "); 19 | 20 | 21 | } 22 | 23 | console.log(removeWords("This is a really bad test", ["really", "bad"])) -------------------------------------------------------------------------------- /68-ejercicio.js: -------------------------------------------------------------------------------- 1 | //Dadas dos cadenas s1 y s2, escriba una función para que devuelva verdadero si s2 contiene s1. De lo contrario, invierta s2 y verifique si s2 contiene s1. Si es así, devuelve verdadero. Si no, devuelve falso. 2 | 3 | const vertificaString = (s1, s2) => { 4 | if(s2.includes(s1)){ 5 | return true; 6 | }else if(s2.split("").reverse().join("").includes(s1)){ 7 | return true; 8 | }else{ 9 | return false; 10 | } 11 | } 12 | 13 | console.log(vertificaString("cs", "cs")) //true 14 | console.log(vertificaString("cs", "cse")) //true 15 | console.log(vertificaString("cs", "ces")) //false 16 | console.log(vertificaString("cs", "disco")) //true 17 | console.log(vertificaString("cs", "disoc")) //false 18 | -------------------------------------------------------------------------------- /64-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado el arreglo students, regresar un nuevo arreglo con los campos 2 | // name y average con los nombres y el promedio de las notas de cada estudiante 3 | // regresar solo aquellos que tengan un promedio superior a 90 puntos 4 | const students = [ 5 | { name: "Alice", scores: [90, 85, 92] }, 6 | { name: "Bob", scores: [75, 80, 85] }, 7 | { name: "Charlie", scores: [90, 95, 85] }, 8 | { name: "David", scores: [100, 100, 100] } 9 | ]; 10 | 11 | const averageStudets = (arr) => { 12 | return arr.map(({name, scores}) => { 13 | return { 14 | name, 15 | average: scores.reduce((acc, item) =>acc +item,0) / scores.length 16 | } 17 | }).filter(({ average }) => average > 90) 18 | } 19 | 20 | console.log(averageStudets(students)) -------------------------------------------------------------------------------- /117-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un array y un objetivo, regresar un arreglo anidado formando pares de numeros que sumados sena igual al numero objetivo 2 | 3 | function encontrarParejas(arr, objetivo) { 4 | const numIndices = {}; 5 | const parejas = []; 6 | 7 | arr.forEach((num, index) => { 8 | const complemento = objetivo - num; 9 | console.log(complemento) 10 | if (numIndices[complemento] !== undefined) { 11 | 12 | console.log(numIndices, parejas) 13 | parejas.push([complemento, num]); 14 | } 15 | numIndices[num] = index; 16 | }); 17 | 18 | return parejas; 19 | } 20 | 21 | const numeros = [3, 1, 5, 8, 2, 6, 4]; 22 | const objetivo = 9; 23 | console.log(encontrarParejas(numeros, objetivo)) -------------------------------------------------------------------------------- /204-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que dado un string devuelva un objeto con cada palabra que hay y la cantidad de veces que aparece. La función debe ignorar el caso ("JavaScript" y "javascript" cuentan como una misma palabra) y el objeto devuelto debe tener todas sus propiedades en minúscula 2 | 3 | const countWords = (str) => { 4 | let strLower = str.split(" ").map((item) => item.toLowerCase()) 5 | return strLower.reduce((acc, item) => { 6 | if (acc[item]) { 7 | acc[item]++ 8 | } else { 9 | acc[item] = 1 10 | } 11 | return acc; 12 | }, {}) 13 | 14 | } 15 | console.log(countWords("El que compra Pocas capas pocas capas paga")) 16 | // returns { el: 1, que: 1, compra: 1, pocas: 2, capas: 2, paga: 1 } -------------------------------------------------------------------------------- /161-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita saber si Sam y Frodo están juntos. El programa debe permitir ingresar nombres separados por espacios, y mostrar con un mensaje si Sam se encuentra al lado de Frodo, ya sea antes o después. 2 | 3 | const samFrodo = (nombres) => { 4 | let arrNombres = nombres.split(" "); 5 | return arrNombres.some((item, i, arr) => { 6 | if ( 7 | (item === "Sam" && arr[i + 1] === "Frodo") || 8 | (item === "Frodo" && arr[i + 1] === "Sam") 9 | ) { 10 | return true; 11 | } 12 | }); 13 | }; 14 | 15 | console.log(samFrodo("Sam Frodo Legolas")); //true 16 | console.log(samFrodo("Sam Orco Frodo")); //false 17 | console.log(samFrodo("Frodo Sam Gandalf")); //true 18 | console.log(samFrodo("Gandalf Sam Frodo")); //true 19 | -------------------------------------------------------------------------------- /10-ejercicio.js: -------------------------------------------------------------------------------- 1 | // El parámetro "resultadosTest" es un arreglo de números. 2 | // Itera (en un bucle) los elementos del arreglo y devuelve el promedio de las notas. 3 | // Tu código: 4 | function numeroMasGrande(resultadosTest) { 5 | if(!Array.isArray(resultadosTest)) { 6 | return "El parámetro debe ser un arreglo"; 7 | } 8 | if(resultadosTest.some((item) => typeof item !== "number")) { 9 | return "Los elementos deben ser números"; 10 | } 11 | return resultadosTest.reduce((acc, curr) => acc + curr, 0) / resultadosTest.length; 12 | } 13 | 14 | console.log(numeroMasGrande([20, 60, 30])); 15 | console.log(numeroMasGrande([20, 20, 20])); 16 | console.log(numeroMasGrande([20, 60, 30, "hola"])); 17 | console.log(numeroMasGrande([20, 60, 30, 40, 50])); 18 | -------------------------------------------------------------------------------- /123-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribir una función llamada sumarArreglo que reciba tres argumentos: un arreglo de números, la posición inicial y la posición final. La función debe retornar la suma de todos los números dentro del rango (la posición inicial y la posición final, incluyéndolas). 2 | 3 | // Nota: puedes asumir que la posición inicial va a ser menor o igual a la posición final, y que están dentro de los límites del arreglo. 4 | 5 | const sumarArreglo = (arr, inicio, final) => { 6 | if(inicio === 0 && final ===0) return 0; 7 | return arr.slice(inicio, final+1).reduce((acc, item) => acc+item,0) 8 | } 9 | 10 | console.log(sumarArreglo([1, 2, 3], 1, 2)) // 5 11 | console.log(sumarArreglo([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3, 6)) // 22 12 | console.log(sumarArreglo([7, 8, 9], 0, 0)) // 0 -------------------------------------------------------------------------------- /181-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getRockPaperScissorRandomSequence 3 | * @description Devuelve una secuencia aleatoria de jugadas de piedra, papel o tijera, con cierta longitud 4 | * 5 | * @param {number} length - Longitud de la secuencia 6 | * @returns {String[]} 7 | * 8 | * @example 9 | * getRockPaperScissorRandomSequence(4) // returns ["rock", "paper", "rock", "scissor"] 10 | */ 11 | 12 | const getRockPaperScissorRandomSequence = (longitud) => { 13 | const res = []; 14 | const obj = { 15 | 1: "piedra", 16 | 2: "papel", 17 | 3: "tijera", 18 | }; 19 | for (let i = 0; i < longitud; i++) { 20 | let random = Math.floor(Math.random() * 3) + 1; 21 | res.push(obj[random]); 22 | } 23 | return res; 24 | }; 25 | 26 | console.log(getRockPaperScissorRandomSequence(4)); 27 | -------------------------------------------------------------------------------- /132-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribir una función llamada numerosAPalabras que reciba un arreglo de números (cada número en el rango de 0 a 0) y retorne un nuevo arreglo convirtiendo cada número a su versión en palabras. 2 | 3 | const numerosAPalabras = (arr) => { 4 | const obj = { 5 | 0: "cero", 6 | 1: "uno", 7 | 2: "dos", 8 | 3: "tres", 9 | 4: "cuatro", 10 | 5: "cinco", 11 | 6: "seis", 12 | 7: "siete", 13 | 8: "ocho", 14 | 9: "nueve", 15 | } 16 | 17 | return arr.map((numero) => { 18 | return obj[numero] 19 | }) 20 | } 21 | 22 | console.log(numerosAPalabras([0, 1, 2, 3, 4])) // ["cero", "uno", "dos", "tres", "cuatro"] 23 | console.log(numerosAPalabras([5, 6, 7, 8, 9])) // ["cinco", "seis", "siete", "ocho", "nueve"] -------------------------------------------------------------------------------- /12-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Usa la palabra "arr" para multiplicar todos los argumentos y devolver el producto. 2 | // Si no se pasan argumentos retorna 0. Si se pasa un argumento, simplemente retórnalo. 3 | // [PISTA]: "arr" es un arreglo. 4 | // Tu código: 5 | function multiplicarArgumentos(...arr) { 6 | if(!Array.isArray(arr)) { 7 | return "El parámetro debe ser un arreglo y no debe estar vacio"; 8 | } 9 | if(arr.some((item) => typeof item !== "number")) { 10 | return "Los elementos deben ser números"; 11 | } 12 | return arr.length === 0 ? 0 : arr.reduce((acc, curr) => acc * curr); 13 | } 14 | 15 | console.log(multiplicarArgumentos(1,2,3,4,5)) 16 | console.log(multiplicarArgumentos(1)) 17 | console.log(multiplicarArgumentos()) 18 | console.log(multiplicarArgumentos(1, 2, 3, "4")) 19 | -------------------------------------------------------------------------------- /176-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name inRange 3 | * @description Devuelve si un número se encuentra dentro de un rango 4 | * 5 | * @param {number} x - El número a evaluar si se encuentra dentro del rango 6 | * @param {number} min - El límite inferior del rango 7 | * @param {number} max - El límite superior del rango 8 | * @returns {Boolean} Devuelve true si el número {x} se encuentra dentro 9 | * del rango definido por {min} y {max}, false sino 10 | * 11 | * @example 12 | * inRange(-4, 10, 2 ) // returns true 13 | */ 14 | 15 | const inRange = (min, max, x) => { 16 | const numeros = []; 17 | for (let i = min; i <= max; i++) { 18 | numeros.push(i); 19 | } 20 | return numeros.includes(x); 21 | }; 22 | 23 | console.log(inRange(-4, 10, 2)); // true 24 | console.log(inRange(-4, 10, 15)); // true 25 | -------------------------------------------------------------------------------- /133-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribir una función llamada palabrasANumeros que reciba un arreglo de strings y retorne un nuevo arreglo traduciendo cada palabra a su versión numérica (del 0 al 9). Si la palabra no es un número traducir a -1. 2 | 3 | const palabrasANumeros = (arr) => { 4 | const obj = { 5 | cero: 0, 6 | uno: 1, 7 | dos: 2, 8 | tres: 3, 9 | cuatro: 4, 10 | cinco: 5, 11 | seis: 6, 12 | siete: 7, 13 | ocho: 8, 14 | nueve: 9, 15 | }; 16 | 17 | return arr.map((numero) => { 18 | return obj[numero] ?? obj[numero] ?? -1; 19 | }); 20 | }; 21 | 22 | console.log( 23 | palabrasANumeros(["cero", "uno", "dos", "tres", "what?", "cuatro"]) 24 | ); // [0, 1, 2, 3, -1, 4] 25 | console.log(palabrasANumeros(["cinco", "seis", "siete", "ocho", "nueve"])); // [5, 6, 7, 8, 9] 26 | -------------------------------------------------------------------------------- /137-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una funcion que permite intercambiar las posiciones de dos elementos de un arreglo en base a sus índices ej: 2 | 3 | const intercambio = (arr, i, j) => { 4 | let val1 = arr[i]; //9 5 | let val2 = arr[j]; //1 6 | let valAux = val1; 7 | val1 = val2; //1 8 | val2 = valAux //9 9 | arr[i] = val1; 10 | arr[j] = val2; 11 | return arr 12 | } 13 | console.log(intercambio([2, 9, 7, 1, 3], 1, 3)) // [2,1,7,9,3] 14 | console.log(intercambio([20,50,90,70,100], 3,0)) // [70,50,90,20,100] 15 | 16 | const intercambio2 = (arr,i,j) => { 17 | [arr[i], arr[j]] = [arr[j], arr[i]]; 18 | return arr; 19 | } 20 | 21 | console.log(intercambio2([2, 9, 7, 1, 3], 1, 3)) // [2,1,7,9,3] 22 | console.log(intercambio2([20, 50, 90, 70, 100], 3, 0)) // [70,50,90,20,100] 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /05-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Agrega el "elemento" al final del arreglo recibido. 2 | // Retorna el arreglo. 3 | function agregarItemAlComienzoDelArray(array = [], elemento = "") { 4 | validarArreglo(array); 5 | return array.concat(elemento); 6 | } 7 | 8 | const validarArreglo = (array) => { 9 | if(!Array.isArray(array)) { 10 | return('El argumento debe ser un arreglo'); 11 | } 12 | } 13 | 14 | console.log(agregarItemAlComienzoDelArray([1,2,3], [4,5])); 15 | console.log(agregarItemAlComienzoDelArray([1,2,3], 4)); 16 | console.log(agregarItemAlComienzoDelArray([1,2,3], "Hola")); 17 | console.log(agregarItemAlComienzoDelArray([1,2,3], {})); 18 | console.log(agregarItemAlComienzoDelArray([], [])); 19 | console.log(agregarItemAlComienzoDelArray([1,2,3], "Hola mundo")); 20 | console.log(agregarItemAlComienzoDelArray()); 21 | -------------------------------------------------------------------------------- /105-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado una cedena eliminar todas los espacios, puntos y comas 2 | 3 | const elminarEspacios = (cadena) => { 4 | return cadena.split(" ").join("").split(".").join("").split(",").join("") 5 | } 6 | 7 | const elminarEspacios2 = (cadena) => { 8 | const elementos = [" ", ",", "."]; 9 | const res = [...cadena].filter((palabra) => !elementos.includes(palabra)); 10 | return res.join("") 11 | } 12 | 13 | 14 | // console.log(elminarEspacios("Boca vs Fluminense")) // BocavsFluminense 15 | // console.log(elminarEspacios("Hola mundo, me llamo Cris. Soy Programador")) 16 | // // HolamundomellamoCrisSoyProgramador 17 | 18 | console.log(elminarEspacios2("Boca vs Fluminense")) // BocavsFluminense 19 | console.log(elminarEspacios2("Hola mundo, me llamo Cris. Soy Programador")) 20 | // HolamundomellamoCrisSoyProgramador -------------------------------------------------------------------------------- /07-ejercicio.js: -------------------------------------------------------------------------------- 1 | // El argumento "palabras" es un arreglo de strings. 2 | // Retornar un string donde todas las palabras estén concatenadas 3 | // con un espacio entre cada palabra. 4 | // Ejemplo: ['Hello', 'world!'] -> 'Hello world!'. 5 | // Tu código: 6 | function dePalabrasAFrase(palabras) { 7 | if(!Array.isArray(palabras)) { 8 | return('El argumento debe ser un arreglo'); 9 | } 10 | if(palabras.some((item) => typeof item !== "string")){ 11 | return('El arreglo solo debe ser de cadenas'); 12 | } 13 | return palabras.join(" ") 14 | } 15 | 16 | 17 | console.log(dePalabrasAFrase(['Hello', 'world!'])) 18 | console.log(dePalabrasAFrase(["Hola", "mi", "nombre", "es", "Cristian"])) 19 | console.log(dePalabrasAFrase([1,2,3])) 20 | console.log(dePalabrasAFrase({})) 21 | console.log(dePalabrasAFrase("")) 22 | console.log(dePalabrasAFrase(false)) -------------------------------------------------------------------------------- /86-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Implemente una función de JavaScript que tome una matriz de números y devuelva una nueva matriz con los números en orden inverso. 2 | 3 | 4 | const sevenBoom = (array) => { 5 | const arrDesmenusadoString = array.flatMap((item) => String(item).length > 1 ? String(item).split("") : String(item)) 6 | const arrDesmenusadoNumber = arrDesmenusadoString.map((number) => Number(number)) 7 | return arrDesmenusadoNumber.includes(7) ? "Boom!" : "there is no 7 in the array" 8 | } 9 | 10 | console.log(sevenBoom([1, 2, 3, 4, 5, 6, 7])) //➞ "Boom!" 11 | // 7 contains the number seven. 12 | 13 | console.log(sevenBoom([8, 6, 33, 100])) //➞ "there is no 7 in the array" 14 | // None of the items contain 7 within them. 15 | 16 | console.log(sevenBoom([2, 55, 60, 97, 86])) //➞ "Boom!" 17 | // 97 contains the number seven. 18 | 19 | -------------------------------------------------------------------------------- /103-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribe una función llamada reversoPalabra que tome una cadena de palabras como entrada y devuelva una nueva cadena donde cada palabra esté invertida, pero el orden de las palabras se mantenga igual. 2 | 3 | const reversoPalabra = (str) => { 4 | const strArr = str.split(" "); 5 | const salida = strArr.map((palabra) => { 6 | if (!palabra.includes(",")) { 7 | return [...palabra].reverse().join(""); 8 | } else { 9 | let indice = palabra.indexOf(","); 10 | let coma = palabra.at(-1); 11 | let parte1 = palabra.substring(0, indice); 12 | return [...parte1].reverse().join("") + coma; 13 | } 14 | }); 15 | return salida.join(" "); 16 | }; 17 | 18 | console.log(reversoPalabra("Hola, mundo en JavaScript")); 19 | console.log(reversoPalabra("Hola mundo en JavaScript")); 20 | console.log(reversoPalabra("Como estas? yo bien, y tu?")); 21 | -------------------------------------------------------------------------------- /17-ejercicio.js: -------------------------------------------------------------------------------- 1 | // El arreglo contiene algunos meses del año desordenados. Debes recorrerlo, buscar los meses "Enero", 2 | // "Marzo" y "Noviembre", guardarlos en un nuevo arreglo y retornarlo. 3 | // Si alguno de los meses no está, retornar el string: "No se encontraron los meses pedidos". 4 | // Tu código: 5 | function mesesDelAño(array) { 6 | const meses = []; 7 | const mesesBase = ["Enero", "Marzo", "Noviembre"]; 8 | array.forEach(element => { 9 | if(element === "Enero" || element === "Marzo" || element === "Noviembre") meses.push(element) 10 | }); 11 | return (JSON.stringify(meses) === JSON.stringify(mesesBase)) ? meses : "No se encontraron los meses pedidos" 12 | 13 | } 14 | 15 | console.log(mesesDelAño(["Diciembre", "Enero", "Marzo", "Noviembre", "Julio"])) 16 | console.log(mesesDelAño(["Enero", "Julio"])) 17 | console.log(mesesDelAño(["Enero"])) -------------------------------------------------------------------------------- /11-ejercicio.js: -------------------------------------------------------------------------------- 1 | // El parámetro "arrayOfNums" es un arreglo de números. 2 | // Retornar el número más grande. 3 | // Tu código: 4 | function numeroMasGrande(arrayOfNums) { 5 | if(!Array.isArray(arrayOfNums) || arrayOfNums.length === 0) { 6 | return "El parámetro debe ser un arreglo y no debe estar vacio"; 7 | } 8 | if(arrayOfNums.some((item) => typeof item !== "number")) { 9 | return "Los elementos deben ser números"; 10 | } 11 | return Math.max(...arrayOfNums); 12 | } 13 | 14 | console.log(numeroMasGrande([20, 60, 30])); 15 | console.log(numeroMasGrande([20, 20, 20])); 16 | console.log(numeroMasGrande([20, 60, 30, 40, 50])); 17 | console.log(numeroMasGrande([1,2,3,4,5])); 18 | console.log(numeroMasGrande([])); 19 | console.log(numeroMasGrande([1,2,3,4,"5"])) 20 | console.log(numeroMasGrande(6)) 21 | console.log(numeroMasGrande({})) 22 | console.log(numeroMasGrande(false)) -------------------------------------------------------------------------------- /06-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Agrega el "elemento" al comienzo del arreglo recibido. 2 | // Retorna el arreglo. 3 | function agregarItemAlComienzoDelArray(array = [], elemento="") { 4 | validarArreglo(array); 5 | const res = array.unshift(elemento); 6 | return res; 7 | } 8 | 9 | const validarArreglo = (array) => { 10 | if(!Array.isArray(array)) { 11 | return('El argumento debe ser un arreglo'); 12 | } 13 | } 14 | 15 | console.log(agregarItemAlComienzoDelArray([1,2,3], 4)); 16 | console.log(agregarItemAlComienzoDelArray([1,2,3], [4,5])); 17 | console.log(agregarItemAlComienzoDelArray([1,2,3], 4)); 18 | console.log(agregarItemAlComienzoDelArray([1,2,3], "Hola")); 19 | console.log(agregarItemAlComienzoDelArray([1,2,3], {})); 20 | console.log(agregarItemAlComienzoDelArray([], [])); 21 | console.log(agregarItemAlComienzoDelArray([1,2,3], "Hola mundo")); 22 | console.log(agregarItemAlComienzoDelArray()); 23 | -------------------------------------------------------------------------------- /21-ejericicio.js: -------------------------------------------------------------------------------- 1 | // Iterar en un bucle aumentando en 2 el número recibido hasta un límite de 10 veces. 2 | // Guardar cada nuevo valor en un array y retornarlo. 3 | // Cuando el número de iteraciones alcance el valor 5, no se suma ese caso y 4 | // se continua con la siguiente iteración. 5 | // [PISTA]: utiliza el statement 'continue'. 6 | // Tu códig 7 | 8 | function continueStatement(num) { 9 | const arr = []; 10 | for (let i = 1; i <= 10; i++) { 11 | if (i === 5) { 12 | num += 2; // Aumentar num solo si es la quinta iteración 13 | continue; // Saltar la iteración 5 14 | } 15 | num += 2; // Aumentar num en todas las demás iteraciones 16 | arr.push(num); 17 | } 18 | return arr; 19 | } 20 | 21 | console.log(continueStatement(3)) 22 | console.log(continueStatement(6)) 23 | console.log(continueStatement(1)) 24 | console.log(continueStatement(0)) 25 | 26 | -------------------------------------------------------------------------------- /95-ejercicio.js: -------------------------------------------------------------------------------- 1 | // obtener un objeto con el promedio de calificaciones por estudiante 2 | const calificaciones = { 3 | Juan: { 4 | Matemáticas: 90, 5 | Historia: 85, 6 | Ciencias: 92, 7 | }, 8 | Pedro: { 9 | Matemáticas: 88, 10 | Historia: 92, 11 | Ciencias: 89, 12 | }, 13 | Carlos: { 14 | Matemáticas: 95, 15 | Historia: 78, 16 | Ciencias: 88, 17 | }, 18 | }; 19 | 20 | const calcularPromedioPorEstudiante = (objCalificaciones) => { 21 | for (const [nombre, calificaciones] of Object.entries(objCalificaciones)) { 22 | let sumaCalificaciones = 0; 23 | for (const [materia, calificacion] of Object.entries(calificaciones)) { 24 | sumaCalificaciones += calificacion; 25 | } 26 | console.log( 27 | nombre, 28 | sumaCalificaciones / Object.keys(calificaciones).length 29 | ); 30 | } 31 | }; 32 | 33 | calcularPromedioPorEstudiante(calificaciones); 34 | -------------------------------------------------------------------------------- /163-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que permita ingresar una lista de 🐵(monos) y 🍌(bananas). Preguntar luego cuántas bananas come cada mono. Mostrar en un mensaje si hay suficientes bananas para cada mono. 2 | 3 | const monosBananas = (arr, cantidadBanana) => { 4 | let monosArr = arr.filter((item) => item === "mono"); 5 | let bananasArr = arr.filter((item) => item === "banana"); 6 | console.log(monosArr.length, bananasArr.length); 7 | return bananasArr.length >= monosArr.length * cantidadBanana 8 | ? "mono feliz" 9 | : "mono triste"; 10 | }; 11 | 12 | console.log( 13 | monosBananas( 14 | ["mono", "banana", "banana", "banana", "mono", "banana", "mono", "banana"], 15 | 2 16 | ) 17 | ); // mono triste 18 | 19 | console.log( 20 | monosBananas(["mono", "banana", "mono", "banana", "mono", "banana"], 1) 21 | ); // mono feliz 22 | 23 | console.log(monosBananas(["mono", "banana", "banana"], 1)); // mono feliz 24 | -------------------------------------------------------------------------------- /90-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un arr de estudiantes, filtrar aquellos que tengan un promedio mayor a 90 2 | // ordenar los resultados de manera ascendente por nombre 3 | 4 | const estudiantes = [ 5 | { nombre: "Juan", edad: 18, calificaciones: [95, 89, 92, 97] }, 6 | { nombre: "María", edad: 17, calificaciones: [91, 88, 94, 98] }, 7 | { nombre: "Luis", edad: 19, calificaciones: [87, 90, 92, 96] }, 8 | ]; 9 | 10 | // regresar el campo nombrem edad, calificacion y agregar el campo promedio, con el promedio de cada estudiante 11 | 12 | const estudianteSobresaliente = (arr) => { 13 | return arr.map((estudiante) => { 14 | const promedio = estudiante.calificaciones.reduce((acc, calificacion) => acc + calificacion, 0) / estudiante.calificaciones.length; 15 | return { ...estudiante, promedio: promedio }; 16 | }).filter((estudiante) => estudiante.promedio > 90); 17 | } 18 | 19 | console.log(estudianteSobresaliente(estudiantes)); 20 | 21 | -------------------------------------------------------------------------------- /185-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name toHackerSpeak 3 | * @description Convierte un string a "Hacker Speak". 4 | * Para hacerlo, tiene que transformar las "a" en 4, las "e" en 3, las "i" 5 | * en 1, las "o" en 0 y las "s" en 5 6 | * 7 | * @param {string} text 8 | * @returns {String} - El texto convertido a "Hacker Speak" 9 | * 10 | * @example 11 | * toHackerSpeak("I'm a hacker now") // returns "1'm 4 h4ack3r n0w" 12 | */ 13 | 14 | const toHackerSpeak = (text) => { 15 | let textLower = text.toLowerCase(); 16 | const obj = { 17 | a:"4", 18 | e:"3", 19 | i:"1", 20 | o:"0", 21 | s:"5" 22 | }; 23 | let res = ""; 24 | for(let i = 0; i { 4 | const arrPares = arr.filter((item) => item % 2 === 0); 5 | const arrImapres = arr.filter((item) => item % 2 !== 0); 6 | return [arrImapres, arrPares]; 7 | }; 8 | console.log(separarArr([5, 2, 9, 1, 5, 6])); 9 | 10 | const ordenarArr2 = (arr) => { 11 | return [...arr[0].sort((a, b) => b - a), ...arr[1].sort((a, b) => b - a)]; 12 | }; 13 | console.log(ordenarArr2(separarArr([5, 2, 9, 1, 5, 6]))); 14 | -------------------------------------------------------------------------------- /174-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que dado un array 2d de strings, indique cuál es la cantidad de una de sus ítems. El programa debe dar la posibilidad de ingresar qué item se desea buscar 2 | const cuentaItem = (matriz, item) => { 3 | let arr = matriz.flat(); 4 | return Object.groupBy(arr, (fruta) => fruta === item).true.length; 5 | }; 6 | 7 | console.log( 8 | cuentaItem( 9 | [ 10 | ["🍎", "🍏", "🍌", "🍌"], 11 | ["🍌", "🍎"], 12 | ["🍎", "🍏", "🍌"], 13 | ["🍏", "🍌", "🍎", "🍌"], 14 | ], 15 | "🍎" 16 | ) 17 | ); 18 | 19 | console.log( 20 | cuentaItem( 21 | [ 22 | ["🍎", "🍏", "🍌", "🍌"], 23 | ["🍌", "🍎"], 24 | ["🍎", "🍏", "🍌"], 25 | ["🍏", "🍌", "🍎", "🍌"], 26 | ], 27 | "🍏" 28 | ) 29 | ); 30 | 31 | console.log( 32 | cuentaItem( 33 | [ 34 | ["🍎", "🍏", "🍌", "🍌"], 35 | ["🍌", "🍎"], 36 | ["🍎", "🍏", "🍌"], 37 | ["🍏", "🍌", "🍎", "🍌"], 38 | ], 39 | "🍌" 40 | ) 41 | ); 42 | -------------------------------------------------------------------------------- /151-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado n mes en numero imprimer que mes es en string 2 | //Crear un programa que pida al usuario un numero y mostrar en un mensaje el nombre del mes correspondiente. 3 | 4 | const getMes = (numeroMes) => { 5 | switch(numeroMes){ 6 | case 1: 7 | return "Enero"; 8 | case 2: 9 | return "Febrero"; 10 | case 3: 11 | return "Marzo"; 12 | case 4: 13 | return "Abril"; 14 | case 5: 15 | return "Mayo"; 16 | case 6: 17 | return "Junio"; 18 | case 7: 19 | return "Julio"; 20 | case 8: 21 | return "Agosto"; 22 | case 9: 23 | return "Septiembre"; 24 | case 10: 25 | return "Octubre"; 26 | case 11: 27 | return "Noviembre"; 28 | case 12: 29 | return "Diciembre"; 30 | default: 31 | return false; 32 | 33 | } 34 | } 35 | 36 | console.log(getMes(2)) 37 | console.log(getMes(12)) -------------------------------------------------------------------------------- /203-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear una función que dado un string devuelva un objeto con la cantidad de letras, espacios y números que contiene. Cualquier cosa que no sea un número o un espacio cuenta como una letra 2 | 3 | const getSpaces = (str) => { 4 | return [...str].filter((item) => item === " ").length 5 | } 6 | 7 | const getDigits = (str) => { 8 | return [...str].filter((item) => item >= 0 && item <= 9 && item !== " ").length 9 | } 10 | 11 | const getLetters = (str) => { 12 | const digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"] 13 | return [...str].filter((item) => !digits.includes(item) && item !== " ").length 14 | } 15 | 16 | const getStringInfo = (str) => { 17 | return { 18 | LETTERS: getLetters(str), 19 | DIGITS: getDigits(str), 20 | SPACES: getSpaces(str), 21 | } 22 | } 23 | 24 | console.log(getStringInfo("H3ll0 Wor1d")) // returns { LETTERS: 7, DIGITS: 3, SPACES: 1 } 25 | console.log(getStringInfo("Hola 159 mun#do, como? es1as")) // returns { LETTERS: 7, DIGITS: 3, SPACES: 1 } 26 | -------------------------------------------------------------------------------- /20-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Iterar en un bucle aumentando en 2 el número recibido hasta un límite de 10 veces. 2 | // Guardar cada nuevo valor en un arreglo y retornarlo. 3 | // Si en algún momento el valor de la suma de los valores es mayor o igual a 150, parar 4 | // y mostrar el mensaje "interrumpido" 5 | // [PISTA]: utiliza el statement 'break'. 6 | // Tu código 7 | function iterarAumentandoDeDosEnDos(num) { 8 | const arr = [] 9 | for (let i = 0; i < 10; i++) { 10 | num += 2; 11 | arr.push(num); 12 | } 13 | let suma = arr.reduce((item, acc) => acc + item, 0) 14 | if(suma > 150){ 15 | return "interrumpido" 16 | } 17 | return arr; 18 | } 19 | 20 | console.log(iterarAumentandoDeDosEnDos(5)) // [5, 7, 9, 11, 13, 15, 17, 19, 21, 23] 21 | console.log(iterarAumentandoDeDosEnDos(6)) // [6, 8, 10, 12, 14, 16, 18, 20, 22, 24] 22 | console.log(iterarAumentandoDeDosEnDos(1)) // [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] 23 | console.log(iterarAumentandoDeDosEnDos(0)) // [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 24 | 25 | 26 | -------------------------------------------------------------------------------- /49-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado un arreglo de enteros del 1 al 10, hacer: 2 | // * solo los numeros pares 3 | // *los numeros divisibles entre 2 o 5 4 | // * numeros divisibles entre 3 eleverlos al cuadrado 5 | // *generar la suma de los numeros divisibles a 5 y elevarlos al cuadrado 6 | 7 | const soloPares = (arr) => { 8 | return arr.filter((item) => item % 2 === 0) 9 | } 10 | 11 | console.log(soloPares([1,2,3,4,5,6,7,8,9,10])) 12 | 13 | const divisiblesEntre2o5 = (arr) => { 14 | return arr.filter((item) => item % 2 === 0 || item % 5 === 0) 15 | } 16 | 17 | console.log(divisiblesEntre2o5([1,2,3,4,5,6,7,8,9,10])) 18 | 19 | const elevarAlCuadradoDivisible3 = (arr) => { 20 | return arr.filter((item) => item % 3 === 0).map((item) => item ** 2) 21 | } 22 | 23 | console.log(elevarAlCuadradoDivisible3([1,2,3,4,5,6,7,8,9,10])) 24 | 25 | const sumaCuadradaDivisiblesEntre5 = (arr) => { 26 | return arr.filter((item) => item % 5 === 0).reduce((acc, item) => acc + item ** 2, 0) 27 | } 28 | 29 | console.log(sumaCuadradaDivisiblesEntre5([1,2,3,4,5,6,7,8,9,10])) -------------------------------------------------------------------------------- /92-ejercicio.js: -------------------------------------------------------------------------------- 1 | const ventas = [ 2 | { fecha: new Date ("2023-01-05"), monto: 150 }, 3 | { fecha: new Date ("2023-02-15"), monto: 200 }, 4 | { fecha: new Date ("2023-01-22"), monto: 180 }, 5 | { fecha: new Date ("2023-03-10"), monto: 250 }, 6 | ]; 7 | 8 | const getArrayVentasTransform = (arrVentas) => { 9 | return arrVentas.map(({fecha, monto}) => { 10 | return { 11 | fecha: fecha.toLocaleString('es-ES', { month: 'long' }), 12 | monto 13 | } 14 | }) 15 | } 16 | 17 | const agruparPorMeses = (arrVentas) => { 18 | const arrFechasTransform = getArrayVentasTransform(arrVentas) 19 | const agruparPorFecha = Object.groupBy(arrFechasTransform, ({fecha}) => fecha) 20 | return agruparPorFecha 21 | } 22 | 23 | const sumaTotalesPorMes = (obj) => { 24 | return Object.keys(obj).map((mes) => { 25 | const ventas = obj[mes] 26 | const suma = ventas.reduce((acc, current) => acc + current.monto, 0) 27 | return {mes:suma} 28 | }) 29 | } 30 | 31 | console.log(sumaTotalesPorMes(agruparPorMeses(ventas))) -------------------------------------------------------------------------------- /112-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribe una función en JavaScript que tome un array de objetos como entrada. Cada objeto representa un estudiante y tiene las siguientes propiedades: nombre (una cadena de texto) y calificaciones (un array de números). La función debe ordenar el array de objetos en orden ascendente según el promedio de las calificaciones de los estudiantes. 2 | 3 | const estudiantes = [ 4 | { nombre: "Alice", calificaciones: [85, 90, 88] }, 5 | { nombre: "Bob", calificaciones: [92, 89, 95] }, 6 | { nombre: "Charlie", calificaciones: [78, 88, 80] }, 7 | { nombre: "David", calificaciones: [88, 92, 90] }, 8 | ]; 9 | 10 | const ordenarPorCalificacionPromedio = (arr) => { 11 | return arr 12 | .map(({ nombre, calificaciones }) => { 13 | return { 14 | nombre, 15 | calificaciones, 16 | promedio: ( 17 | calificaciones.reduce((acc, item) => acc + item, 0) / 18 | calificaciones.length 19 | ).toFixed(2), 20 | }; 21 | }) 22 | .sort((a, b) => b.promedio - a.promedio); 23 | }; 24 | 25 | console.log(ordenarPorCalificacionPromedio(estudiantes)); 26 | -------------------------------------------------------------------------------- /206-ejercicio.js: -------------------------------------------------------------------------------- 1 | const getSentence = (str) => { 2 | return str.split(".").filter((item) => item !== "").length; 3 | }; 4 | 5 | const getWords = (str) => { 6 | return str.split(" ").length; 7 | }; 8 | 9 | const getLetters = (str) => { 10 | const signos = [ 11 | ".", 12 | ",", 13 | ";", 14 | "-", 15 | "!", 16 | "?", 17 | ":", 18 | "¿", 19 | "¡", 20 | "=", 21 | "+", 22 | "*", 23 | "/", 24 | "%", 25 | "^", 26 | "&", 27 | "$", 28 | "#", 29 | "@", 30 | "~", 31 | "`", 32 | "'", 33 | '"', 34 | "[", 35 | "]", 36 | "{", 37 | "}", 38 | "(", 39 | ")", 40 | "<", 41 | ">", 42 | "_", 43 | "´", 44 | ]; 45 | return str.split("").filter((item) => item !== " " && !signos.includes(item)) 46 | .length; 47 | }; 48 | 49 | const getParagraphInfo = (str) => { 50 | return { 51 | LETTERS: getLetters(str), 52 | WORDS: getWords(str), 53 | SENTENCE: getSentence(str), 54 | }; 55 | }; 56 | 57 | console.log(getParagraphInfo("Do. Or do not. There is no try.]")); 58 | // returns { LETTERS: 21, WORDS: 8, SENTENCE: 3 } 59 | -------------------------------------------------------------------------------- /88-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Dada una cadena s que contiene solo los caracteres '(', ')', '{', '}', '[' y ']', determine si la cadena de entrada es válida. 2 | 3 | const verificarCorchetes = (cadena) => { 4 | let stack = []; 5 | let open = { 6 | "(": ")", 7 | "{": "}", 8 | "[": "]" 9 | } 10 | let close = { 11 | ")": true, 12 | "}": true, 13 | "]": true 14 | } 15 | for (let i = 0; i < cadena.length; i++) { 16 | if (open[cadena[i]]) { 17 | console.log(cadena[i]) 18 | stack.push(cadena[i]); 19 | console.log("stack", stack) 20 | } else if (close[cadena[i]]) { 21 | console.log(cadena[i]) 22 | if (open[stack.pop()] !== cadena[i]) { 23 | return false; 24 | } 25 | } 26 | 27 | } 28 | return stack.length === 0; 29 | 30 | } 31 | 32 | console.log(verificarCorchetes("()")) //true 33 | // console.log(verificarCorchetes("([ ))")) // false 34 | // console.log(verificarCorchetes("{ [) }")) // false 35 | // console.log(verificarCorchetes("Hola como estas (yo estoy bien), [ tu ?")) // false -------------------------------------------------------------------------------- /155-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que pida ingresar usuario y contraseña. El programa debe permitir hasta 3 intentos, cuando el usuario y/o la contraseña sean incorrectos. Si se ingresa correctamente ambos antes de 3 intentos erróneos, debe mostrar un mensaje de bienvenida. Si se ingresan 3 intentos erróneos, debe mostrar un mensaje de error y terminar el programa. El usuario y la contraseña ya deben estar guardadas en variables. 2 | 3 | const input = (mensaje) => { 4 | return prompt(mensaje); 5 | }; 6 | 7 | const login = () => { 8 | let userCorrecto = { 9 | userNombre: "dux", 10 | userPass: "123", 11 | }; 12 | const { userNombre, userPass } = userCorrecto; 13 | 14 | let intentos = 3; 15 | while (intentos > 0) { 16 | let userInput = input("ingrese user"); 17 | let passInput = input("ingrese pass"); 18 | if (userNombre === userInput && userPass === passInput) { 19 | alert("bienvenido"); 20 | break; 21 | } else { 22 | intentos--; 23 | alert("Le quedan " + intentos + " intentos"); 24 | } 25 | } 26 | if (intentos === 0) alert("Lo siento, intentelo mas tarde!"); 27 | }; 28 | 29 | login(); 30 | -------------------------------------------------------------------------------- /165-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que dado una lista de nombres de usuarias separadas por espacios, muestre un mensaje con el status del chat. Las reglas son: 2 | 3 | // Para una usuaria, debe mostrar: nombre usuaria + está conectada 4 | 5 | // Para dos usuarias, debe mostrar: nombre usuaria 1 + y + nombre usuaria 2 + están conectadas 6 | 7 | // Para más de dos usuarias, debe mostrar: nombre usuaria 1, nombre usuaria 2 + y X persona(s) más están conectadas 8 | 9 | const chat = (usuarias) => { 10 | let arrUsuarias = usuarias.split(" "); 11 | console.log(arrUsuarias); 12 | if (arrUsuarias.length === 1) { 13 | return `${arrUsuarias[0]} esta conectada`; 14 | } 15 | if (arrUsuarias.length === 2) { 16 | return `${arrUsuarias[0]}, ${arrUsuarias[1]} estan conectadas`; 17 | } 18 | if (arrUsuarias.length > 2) { 19 | let aux = arrUsuarias.slice(2).length; 20 | return `${arrUsuarias[0]}, ${arrUsuarias[1]} y ${aux} persona(s) mas estan conectadas`; 21 | } 22 | }; 23 | 24 | console.log(chat("Alicia Juana Pepa Carmen")); 25 | console.log(chat("Alicia")); 26 | console.log(chat("Alicia Sofia Ana")); 27 | console.log(chat("Alicia Sofia")); 28 | -------------------------------------------------------------------------------- /136-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribir una función llamada distancia que reciba dos strings y retorne el número de caracteres diferentes (comparando posición por posición). 2 | 3 | // Nota: Puedes asumir que los strings siempre tienen la misma longitud. Sin embargo, si quieres agregarle más dificultad puedes pensar cómo solucionarlo si un string es más largo que el otro (la diferencia entre las longitudes agregaría al resultado). 4 | 5 | const distancia = (str1, str2) => { 6 | if(str1 === str2) return 0 7 | let lenStr1 = str1.length; 8 | let lenStr2 = str2.length; 9 | 10 | let resta =0; 11 | if(lenStr2>lenStr1){ 12 | resta =lenStr2-lenStr1; 13 | }else if(lenStr1>lenStr2){ 14 | resta = lenStr1 - lenStr2; 15 | } 16 | 17 | let diferencias = 0; 18 | for (let i = 0; i < str1.length; i++) { 19 | if (str1[i] !== str2[i]) { 20 | diferencias++; 21 | } 22 | } 23 | return diferencias +resta 24 | } 25 | 26 | // console.log(distancia("hola", "hola")) // 0 27 | console.log(distancia("sol", "tol")) // 1 28 | console.log(distancia("carro", "correr")) // 3 29 | console.log(distancia("doctora", "doctores")) //2 30 | -------------------------------------------------------------------------------- /93-ejercicio.js: -------------------------------------------------------------------------------- 1 | const productos = [ 2 | { nombre: "Laptop", precio: 800, cantidad: 10 }, 3 | { nombre: "Teléfono", precio: 300, cantidad: 20 }, 4 | { nombre: "Tablet", precio: 200, cantidad: 15 }, 5 | ]; 6 | 7 | // incrementar el precio de los productos en el porcentaje dado 8 | const aumentarPrecios = (arrProductos, porcentaje) => { 9 | return arrProductos.map(({nombre, precio, cantidad}) => { 10 | return { 11 | nombre, 12 | cantidad, 13 | precio: precio + (precio * porcentaje) / 100 14 | } 15 | }) 16 | } 17 | console.log(aumentarPrecios(productos, 10)) 18 | 19 | // filtrar por precio dado, menor o igual al precio dado 20 | 21 | const filtrarPorPrecio = (arrProductos, precio) => { 22 | return arrProductos.filter((producto) => producto.precio <=precio) 23 | } 24 | 25 | console.log(filtrarPorPrecio(productos, 250)) 26 | 27 | 28 | // calcular el precio total de todo el inventario 29 | 30 | const calcularValorTotal = (arrProductos) => { 31 | return arrProductos.reduce((acc, current) => (current.cantidad * current.precio) + acc,0) 32 | } 33 | console.log(calcularValorTotal(productos)) -------------------------------------------------------------------------------- /81-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Este programa toma un alfabeto inglés e informa al usuario si el alfabeto dado es una vocal o una constante. 2 | 3 | const veritifcaLetra = (letra) => { 4 | const vocales = ["a", "e", "i", "o", "u"]; 5 | const vocalesMayusculas = ["A", "E", "I", "O", "U"]; 6 | const consonantes = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "ñ", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]; 7 | const consonantesMayusculas = ["B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "Ñ", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]; 8 | if([...vocales, ...vocalesMayusculas].includes(letra)){ 9 | return "Vocal"; 10 | }else if([...consonantes, ...consonantesMayusculas].includes(letra)){ 11 | return "Consonante"; 12 | }else { 13 | return "No es una letra"; 14 | } 15 | } 16 | console.log(veritifcaLetra("a")) // Vocal 17 | console.log(veritifcaLetra("b")) // Consonante 18 | console.log(veritifcaLetra("e")) // Vocal 19 | console.log(veritifcaLetra("z")) // Consonante 20 | console.log(veritifcaLetra("9")) // no es una letra 21 | console.log(veritifcaLetra("/")) // no es una letra 22 | console.log(veritifcaLetra({})) // no es una letra -------------------------------------------------------------------------------- /170-ejercicio.js: -------------------------------------------------------------------------------- 1 | const puntajes = ( 2 | puntajesJugadora1, 3 | nombreJuagadora1, 4 | puntajesJugadora2, 5 | nombreJuagadora2 6 | ) => { 7 | if (puntajesJugadora1.length !== puntajesJugadora2.length) 8 | return "Ambas jugadoras deben tener la misma cantidad de partidas"; 9 | let contadorJugadora1 = 0; 10 | let contadorJugadora2 = 0; 11 | for (let i = 0; i <= puntajesJugadora1.length; i++) { 12 | if (puntajesJugadora1[i] > puntajesJugadora2[i]) { 13 | contadorJugadora1++; 14 | } else if (puntajesJugadora1[i] < puntajesJugadora2[i]) { 15 | contadorJugadora2++; 16 | } 17 | } 18 | return { 19 | [nombreJuagadora1]: contadorJugadora1, 20 | [nombreJuagadora2]: contadorJugadora2, 21 | resultado: `${contadorJugadora1} (${nombreJuagadora1}) vs ${contadorJugadora2} (${nombreJuagadora2})`, 22 | ganadora: 23 | contadorJugadora1 > contadorJugadora2 24 | ? nombreJuagadora1 25 | : nombreJuagadora2, 26 | }; 27 | }; 28 | 29 | console.log(puntajes([5, 6, 3, 1, 8], "Luisa", [8, 2, 4, 2, 3], "Pepa")); 30 | console.log(puntajes([5, 6, 3, 1, 8], "Luisa", [8, 2, 4, 2, 8], "Pepa")); 31 | console.log(puntajes([5, 6, 3, 1, 8, 1], "Luisa", [8, 2, 4, 2, 8], "Pepa")); 32 | -------------------------------------------------------------------------------- /13-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Desarrolla una función que retorne la cantidad de elementos del arreglo cuyo valor sea mayor que 18. 2 | // Tu código: 3 | function cuentoElementos(array) { 4 | const resultado = []; 5 | 6 | for (let i = 0; i < array.length; i++) { 7 | if(item > 18) { 8 | resultado.push(item); 9 | } 10 | } 11 | return resultado.length; 12 | } 13 | 14 | // Desarrolla una función que retorne la cantidad de elementos del arreglo cuyo valor sea mayor que 18. 15 | // Tu código: 16 | function cuentoElementos(array) { 17 | if(!Array.isArray(array)) return "No es un array" 18 | if(array.some((item) => typeof item !== "number")) return "Debe ser un array de numeros" 19 | const resultado = []; 20 | 21 | for (let i = 0; i <= array.length; i++) { 22 | if (array[i] > 18) { 23 | resultado.push(array[i]); 24 | } 25 | } 26 | return resultado.length; 27 | } 28 | 29 | console.log(cuentoElementos([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])) 30 | console.log(cuentoElementos([20,21,22])) 31 | console.log(cuentoElementos([])) 32 | console.log(cuentoElementos({})) 33 | console.log(cuentoElementos(11)) 34 | console.log(cuentoElementos(["Hola"])) -------------------------------------------------------------------------------- /65-ejercicio.js: -------------------------------------------------------------------------------- 1 | // dado el arr products obtener el promedio precios por categoria que sean mayores a 50 2 | const products = [ 3 | { name: "Product 1", price: 20, category: "Electronics" }, 4 | { name: "Product 2", price: 30, category: "Clothes" }, 5 | { name: "Product 3", price: 40, category: "Electronics" }, 6 | { name: "Product 4", price: 50, category: "Clothes" }, 7 | { name: "Product 5", price: 60, category: "Clothes" }, 8 | { name: "Product 6", price: 70, category: "Electronics" }, 9 | { name: "Product 7", price: 80, category: "Clothes" }, 10 | { name: "Product 8", price: 90, category: "Electronics" }, 11 | ]; 12 | 13 | 14 | const productsByCategory = (arr) => { 15 | return Object.groupBy(arr, ({category}) => category) 16 | } 17 | 18 | console.log(productsByCategory(products)) 19 | 20 | const avgPriceByCategory = (obj) => { 21 | return Object.keys(obj).map((category) => { 22 | const prices = obj[category]; 23 | const average = prices.reduce((acc, current) => acc + current.price, 0) / prices.length; 24 | return { category, average }; 25 | }).filter((item) => item.average > 50) 26 | } 27 | 28 | console.log(avgPriceByCategory(productsByCategory(products))) 29 | -------------------------------------------------------------------------------- /14-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Supongamos que los días de la semana se codifican como 1 = Domingo, 2 = Lunes y así sucesivamente. 2 | // Realiza una función que, dado el número del día de la semana, retorne: "Es fin de semana" 3 | // si el día corresponde a "Sábado" o "Domingo", y "Es dia laboral" en caso contrario. 4 | // Tu código: 5 | function diaDeLaSemana(numeroDeDia) { 6 | if(numeroDeDia < 1 || numeroDeDia > 7) return "Debe ser un numero entre 1 y 7"; 7 | if(typeof numeroDeDia !== "number") return "El aprametro debe ser un numero" 8 | const DiasSemana = { 9 | 1:"Domingo", 10 | 2:"Lunes", 11 | 3:"Martes", 12 | 4:"Miercoles", 13 | 5:"Jueves", 14 | 6:"Viernes", 15 | 7:"Sabado" 16 | } 17 | 18 | if(DiasSemana[numeroDeDia] == "Domingo" || DiasSemana[numeroDeDia] == "Sabado"){ 19 | return "Es fin de semana" 20 | }else{ 21 | return "Es dia laboral" 22 | } 23 | } 24 | 25 | console.log(diaDeLaSemana(1)) 26 | console.log(diaDeLaSemana(2)) 27 | console.log(diaDeLaSemana(3)) 28 | console.log(diaDeLaSemana(4)) 29 | console.log(diaDeLaSemana(5)) 30 | console.log(diaDeLaSemana(6)) 31 | console.log(diaDeLaSemana(7)) 32 | console.log(diaDeLaSemana(8)) 33 | console.log(diaDeLaSemana(-1)) 34 | console.log(diaDeLaSemana("hola")) 35 | console.log(diaDeLaSemana(false)) 36 | console.log(diaDeLaSemana([])) 37 | -------------------------------------------------------------------------------- /150-ejercicio.js: -------------------------------------------------------------------------------- 1 | //piedra papel o tijera 2 | const generaJugadaPC = () => { 3 | let random = Math.floor(Math.random() * 3); // 0 1 2 4 | switch (random) { 5 | case 0: 6 | return "piedra"; 7 | case 1: 8 | return "papel"; 9 | case 2: 10 | return "tijera"; 11 | default: 12 | return "Jugada incorrecta"; 13 | } 14 | }; 15 | 16 | const piedraPapelTijera = (jugadaUser) => { 17 | let jugadaPc = generaJugadaPC(); 18 | if (jugadaUser === jugadaPc) 19 | return { user: jugadaUser, pc: jugadaPc, gana: "empate" }; 20 | if (jugadaUser === "piedra" && jugadaPc === "papel") 21 | return { user: jugadaUser, pc: jugadaPc, gana: "gana pc" }; 22 | if (jugadaUser === "piedra" && jugadaPc === "tijera") 23 | return { user: jugadaUser, pc: jugadaPc, gana: "gana user" }; 24 | if (jugadaUser === "papel" && jugadaPc === "piedra") 25 | return { user: jugadaUser, pc: jugadaPc, gana: "gana user" }; 26 | if (jugadaUser === "papel" && jugadaPc === "tijera") 27 | return { user: jugadaUser, pc: jugadaPc, gana: "gana pc" }; 28 | if (jugadaUser === "tijera" && jugadaPc === "piedra") 29 | return { user: jugadaUser, pc: jugadaPc, gana: "gana pc" }; 30 | if (jugadaUser === "tijera" && jugadaPc === "papel") 31 | return { user: jugadaUser, pc: jugadaPc, gana: "gana user" }; 32 | }; 33 | 34 | console.log(piedraPapelTijera("papel")); 35 | -------------------------------------------------------------------------------- /192-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name getRange 3 | * @description Dado dos números, devuelve un array con los números 4 | * enteros sucesivos entre ellos, puede incluir los números iniciales o no 5 | * 6 | * @param {number} a 7 | * @param {number} b 8 | * @param {boolean} [inclusive=true] inclusive // Parámetro opcional, valor por defecto true 9 | * @returns {number[]} - Array de números entre a y b, incluyendo a y b 10 | * 11 | * @example 12 | * getRange(5, 10) // returns [5, 6, 7, 8, 9 ,10] 13 | * getRange(3, -2) // returns [3, 2, 1, 0, -1, -2] 14 | * getRange(-5, -10, false) // returns [-6, -7, -8, -9] 15 | */ 16 | 17 | const getRange = (a, b, inclusive = true) => { 18 | if (a === b) return 0; 19 | const res = []; 20 | if (a < b && inclusive) { 21 | for (let i = a; i <= b; i++) { 22 | res.push(i); 23 | } 24 | } else if (a > b && inclusive) { 25 | for (let i = a; i >= b; i--) { 26 | res.push(i); 27 | } 28 | } 29 | 30 | if (inclusive === false) { 31 | if (a < b) { 32 | for (let i = a - 1; i < b; i++) { 33 | res.push(i); 34 | } 35 | } else if (a > b) { 36 | for (let i = a - 1; i > b; i--) { 37 | res.push(i); 38 | } 39 | } 40 | } 41 | return res; 42 | }; 43 | 44 | console.log(getRange(5, 10)); 45 | console.log(getRange(3, -2)); 46 | console.log(getRange(-5, -10, false)); 47 | -------------------------------------------------------------------------------- /66-ejericicio.js: -------------------------------------------------------------------------------- 1 | // Se le proporciona una serie de objetos que representan una colección de empleados, cada uno con un nombre, salario y departamento. Su tarea es utilizar mapear, filtrar y reducir para calcular el salario promedio de cada departamento y luego devolver una serie de objetos que contengan solo los departamentos que tienen un salario promedio superior a 65000. 2 | 3 | const employees = [ 4 | { name: "John", salary: 50000, department: "IT" }, 5 | { name: "Jane", salary: 60000, department: "HR" }, 6 | { name: "Bob", salary: 55000, department: "IT" }, 7 | { name: "Sophie", salary: 75000, department: "HR" }, 8 | { name: "Mike", salary: 65000, department: "IT" }, 9 | { name: "Emily", salary: 80000, department: "HR" }, 10 | { name: "David", salary: 70000, department: "IT" }, 11 | ]; 12 | 13 | const groupByDepartament = (arr) => { 14 | return Object.groupBy(arr, ({department}) => department) 15 | } 16 | 17 | console.log(groupByDepartament(employees)) 18 | 19 | const avgPriceByCategory = (obj) => { 20 | return Object.keys(obj).map((department) => { 21 | const prices = obj[department]; 22 | const average = prices.reduce((acc, current) => acc + current.salary, 0) / prices.length; 23 | return { department, average }; 24 | }).filter(({average}) => average > 65000) 25 | } 26 | 27 | console.log(avgPriceByCategory(groupByDepartament(employees))) -------------------------------------------------------------------------------- /190-ejercicio.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @name canPlay 3 | * @description Devuelve si dada una mano de Uno y una carta en la mesa, puede jugar o tiene que retirar del mazo. Las cartas 4 | * tienen uno de 4 colores posibles (red, blue, green or yellow) y un número del 1 al 9. Una carta se escribe como un string 5 | * con color y número. Por ejemplo: "yellow 3", "red 6". Se puede jugar si la carta en la mano coincide en color o en número 6 | * con la carta en la mesa 7 | * 8 | * @param {string[]} hand - Array de cartas que tiene en la mano 9 | * @param {string} face - Carta que está en la mesa 10 | * @returns {Boolean} - Devuelve true si puede jugar alguna carta, o false si tiene que retirar del mazo 11 | * 12 | * @example 13 | * canPlay(["yellow 3", "yellow 5", "red 8"], "red 2") // returns true 14 | * canPlay(["yellow 3", "yellow 5", "red 8"], "blue 5") // returns true 15 | * canPlay(["yellow 3", "blue 5", "red 8", "red 9"], "green 4") // returns false 16 | * canPlay(["yellow 3", "red 8"], "green 2") // returns false 17 | */ 18 | 19 | const canPlay = (hand, face) => { 20 | const arrExtendido = hand.map((item) => item.split(" ")).flat(); 21 | let [faceColor, faceNumber] = face.split(" "); 22 | return arrExtendido.includes(faceColor) || arrExtendido.includes(faceNumber); 23 | }; 24 | console.log(canPlay(["yellow 3", "yellow 5", "red 8"], "red 2")); 25 | console.log(canPlay(["yellow 3", "yellow 5", "red 8"], "blue 5")); 26 | console.log(canPlay(["yellow 3", "blue 5", "red 8", "red 9"], "green 4")); 27 | console.log(canPlay(["yellow 3", "red 8"], "green 2")); 28 | -------------------------------------------------------------------------------- /109-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Escribe una función en JavaScript llamada validarContrasena que tome una contraseña como entrada y determine si es válida según ciertos criterios. La contraseña se considera válida si cumple con las siguientes condiciones: 2 | 3 | // Tiene al menos 8 caracteres de longitud. 4 | // Contiene al menos una letra minúscula y una letra mayúscula. 5 | // Contiene al menos un número. 6 | // Contiene al menos un carácter especial de los siguientes: !@#$%^&*()_+[]{}|;:',.<>?. 7 | // La función debe devolver true si la contraseña es válida y false en caso contrario. 8 | 9 | const verificarLongitud = (cadena) => { 10 | return cadena.length >= 8; 11 | } 12 | 13 | const verificarNumero = (cadena) => { 14 | const numeros = [1,2,3,4,5,6,7,8,9,0]; 15 | return numeros.some((item) => cadena.includes(item)) 16 | } 17 | 18 | const verificaCaracterEspecial = (cadena) => { 19 | const caracteres = ['!', '@', '#', '$', '%', ' ', '^', '&', '*', '(', ')', '_', '+', '[', ']', '{', '}', '|', ';', ':', "'", ',', '.', '<', '>', '?']; 20 | return caracteres.some((item) => cadena.includes(item)) 21 | } 22 | 23 | const veriticarLower = (cadena) => { // 97 122 24 | return [...cadena].map((item) => item.codePointAt(0)) 25 | .some((item) => item>=97 && item<=122 ) 26 | } 27 | 28 | const veriticarUpper = (cadena) => { 29 | return [...cadena].map((item) => item.codePointAt(0)) 30 | .some((item) => item >= 65 && item <= 90) 31 | } 32 | 33 | 34 | const validarContrasena = (cadena) => { 35 | return verificarLongitud(cadena) 36 | && verificarNumero(cadena) 37 | && verificaCaracterEspecial(cadena) 38 | && veriticarLower(cadena) 39 | && veriticarUpper(cadena) 40 | } 41 | 42 | console.log(validarContrasena("Radiohead@159")) 43 | 44 | -------------------------------------------------------------------------------- /108-ejercicio.js: -------------------------------------------------------------------------------- 1 | // GENERAR UNA CONTRASEÑA ALEATORIA DE UNA LONGITUD DADA 2 | 3 | // generar un numero aleatorio entre 0 y la longitud de la lista 4 | const getRandom = (arr) => { 5 | return Math.floor(Math.random() * arr.length); 6 | }; 7 | 8 | const generarContrasena = (longitud) => { 9 | const abcLower = [ 10 | "a", 11 | "b", 12 | "c", 13 | "d", 14 | "e", 15 | "f", 16 | "g", 17 | "h", 18 | "i", 19 | "j", 20 | "k", 21 | "l", 22 | "m", 23 | "n", 24 | "o", 25 | "p", 26 | "q", 27 | "r", 28 | "s", 29 | "t", 30 | "u", 31 | "v", 32 | "w", 33 | "x", 34 | "y", 35 | "z", 36 | ]; 37 | const abcUpper = [ 38 | "A", 39 | "B", 40 | "C", 41 | "D", 42 | "E", 43 | "F", 44 | "G", 45 | "H", 46 | "I", 47 | "J", 48 | "K", 49 | "L", 50 | "M", 51 | "N", 52 | "O", 53 | "P", 54 | "Q", 55 | "R", 56 | "S", 57 | "T", 58 | "U", 59 | "V", 60 | "W", 61 | "X", 62 | "Y", 63 | "Z", 64 | ]; 65 | const numbers = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]; 66 | const symbols = [ 67 | "!", 68 | "@", 69 | "#", 70 | "$", 71 | "%", 72 | "&", 73 | "*", 74 | "+", 75 | "-", 76 | "_", 77 | "=", 78 | "?", 79 | ".", 80 | ",", 81 | ";", 82 | ":", 83 | "/", 84 | "|", 85 | "~", 86 | "^", 87 | "<", 88 | ">", 89 | "{", 90 | "}", 91 | "[", 92 | "]", 93 | ]; 94 | const total = [...abcLower, ...abcUpper, ...numbers, ...symbols]; 95 | 96 | let caraacter = ""; 97 | for(let i = 0; i { 11 | return cadena.split(",").map((item) => item.trim()).join("") 12 | } 13 | 14 | console.log(eliminarEspacio(texto)) 15 | 16 | const convertirMinisculas = (cadena) => { 17 | return [...cadena].map((item) => item.toLowerCase()).join("") 18 | } 19 | 20 | console.log(convertirMinisculas(texto)) 21 | 22 | const separarPalabrasNumeros = (cadena) => { 23 | const numeros = cadena.split(",") 24 | .map((item) => item.trim()) 25 | .filter((item) => !isNaN(item)); 26 | const palabras = cadena 27 | .split(",") 28 | .map((item) => item.trim()) 29 | .filter((item) => isNaN(item)); 30 | 31 | return { 32 | numeros, palabras 33 | } 34 | } 35 | 36 | 37 | console.log(separarPalabrasNumeros(texto)) 38 | 39 | const ordenarAlfabeticamente = (cadena) => { 40 | const palabras = cadena 41 | .split(",") 42 | .map((item) => item.trim()) 43 | .filter((item) => isNaN(item)); 44 | return palabras.sort() 45 | } 46 | 47 | console.log(ordenarAlfabeticamente(texto)) 48 | 49 | const sumarNumeros = (cadena) => { 50 | const numeros = cadena.split(",") 51 | .map((item) => item.trim()) 52 | .filter((item) => !isNaN(item)); 53 | return numeros.map((item) => Number(item)).reduce((acc, current) => acc + current,0) 54 | } 55 | console.log(sumarNumeros(texto)) 56 | -------------------------------------------------------------------------------- /154-ejercicio.js: -------------------------------------------------------------------------------- 1 | // Crear un programa que simule un Tamagochi (mascota virtual). Debe tener 4 variables: salud, felicidad, limpieza, energía, cuyos valores pueden ir entre 1 y 10. El programa debe iniciar mostrando un mensaje con el nombre del tamagochi y los valores de cada variable (que son asignados aleatoriamente). Luego, debe mostrar las siguientes posibles acciones a realizar, que modifican los valores de la siguiente forma: 2 | // ALIMENTAR: +3 energía, +2 felicidad 3 | // JUGAR: +2 felicidad, -2 energía, -1 limpieza 4 | // DORMIR: +5 energía, +2 salud, -2 limpieza 5 | // VACUNAR: +5 salud, -6 felicidad 6 | // BAÑAR: +3 salud 7 | // RETAR: -3 felicidad 8 | // ACARICIAR: +4 felicidad 9 | // Cuando el usuario selecciona una, debe mostrar el valor final de las variables. 10 | 11 | const initTamagochi = () => { 12 | return Math.floor(Math.random() * 10) + 1; 13 | }; 14 | 15 | const tamagochi = { 16 | salud: initTamagochi(), 17 | felicidad: initTamagochi(), 18 | limpieza: initTamagochi(), 19 | energia: initTamagochi(), 20 | 21 | alimentar() { 22 | console.log(this.energia); 23 | this.energia += 2; 24 | console.log(this.energia); 25 | this.felicidad += 2; 26 | return { 27 | salud: this.salud, 28 | felicidad: this.felicidad, 29 | limpieza: this.limpieza, 30 | energia: this.energia, 31 | }; 32 | }, 33 | 34 | jugar() { 35 | this.felicidad += 2; 36 | this.energia -= 2; 37 | this.limpieza -= 1; 38 | return { 39 | salud: this.salud, 40 | felicidad: this.felicidad, 41 | limpieza: this.limpieza, 42 | energia: this.energia, 43 | }; 44 | }, 45 | 46 | dormir() { 47 | this.energia += 5; 48 | this.salud += 2; 49 | this.limpieza -= 2; 50 | return { 51 | salud: this.salud, 52 | felicidad: this.felicidad, 53 | limpieza: this.limpieza, 54 | energia: this.energia, 55 | }; 56 | }, 57 | 58 | vacunar() { 59 | this.salud += 5; 60 | this.felicidad -= 6; 61 | return { 62 | salud: this.salud, 63 | felicidad: this.felicidad, 64 | limpieza: this.limpieza, 65 | energia: this.energia, 66 | }; 67 | }, 68 | 69 | bañar() { 70 | this.salud += 3; 71 | return { 72 | salud: this.salud, 73 | felicidad: this.felicidad, 74 | limpieza: this.limpieza, 75 | energia: this.energia, 76 | }; 77 | }, 78 | 79 | retar() { 80 | this.felicidad -= 3; 81 | return { 82 | salud: this.salud, 83 | felicidad: this.felicidad, 84 | limpieza: this.limpieza, 85 | energia: this.energia, 86 | }; 87 | }, 88 | acariciar() { 89 | this.felicidad += 4; 90 | return { 91 | salud: this.salud, 92 | felicidad: this.felicidad, 93 | limpieza: this.limpieza, 94 | energia: this.energia, 95 | }; 96 | }, 97 | }; 98 | 99 | console.log(tamagochi); 100 | console.log(tamagochi.jugar()); 101 | console.log(tamagochi.retar()); 102 | console.log(tamagochi.alimentar()); 103 | --------------------------------------------------------------------------------