Playground: multiplica todos los elementos por dos

Me encantan estos desafios, hacen que un curso principalmente teórico se vuelva más dinamico. y me permite practicar lo aprendido más allá de memorizar conceptos.

Deberian empezar a colocar este tipo de desafios en todos los cursos de programación de Platzi, permite ser más dinámico el curso, así como practicar en tiempo real lo aprendido. Es como si uno estuviera realmente en un salón de clases con el profesor.

Apenas voy aprendiendo pero quise que se visualice en html y así me quedó

Reto

function solution(array) {
	return array.map(item => item * 2);
}; 

const array = [2,4,5,6];
const solutionArray = solution(array);

console.log(solutionArray);

como solo pidieron que retorrnara los numeros multiplicados por 2 no vi necesario crear una variable, pense en solo enviarle el array como parametro a la funcion y al mismo tiempo imprimirlo de una vez.

function solution(array) {
	return array.map(num => num * 2);
}; 
console.log(solution([2, 4, 5, 6]));

Bravo por esta nueva manera de interactuar con los cursos de platzi!

esta opción era lo que le faltaba a platzi 😄

Primera vez que veo un desafío interactivo en la plataforma! Muy bueno! Deberían hacerlo más seguido.

Muy interesante esta nueva seccion! 😄 Sigan asi mejorando la plataforma

Está genial el nuevo feature

no se me ocurrio otra forma de hacer el reto, que con la forma que mostro el profe.

creo que no doy uno en esto 😦

const num = [2, 4, 5, 6];

const num2 = num.map(item => item*2 );

console.log(num2);

Mi solución:

const solution = [2, 4, 5, 6];
const array = solution.map(item => item * 2);
console.log(array);

En la salida del ejemplo 2 muestra como Output: [1, 1, -4, -6] aunque mi resultado es [ 2, 2, -4, -6 ], pero como dice cada elemento multiplicado por 2 y ademas valido mi solucion asumo un error en la guia.
Ejemplo 1:

Input: [2, 4, 5, 6, 8]
Output: [4, 8, 10, 12, 16]

Ejemplo 2:

Input: [1, 1, -2, -3]
Output: [1, 1, -4, -6]

Escudo anti spoiler
🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️
⬇️
⬇️
⬇️
⬇️
⬇️
⬇️
⬇️

const numbers = [2, 4, 5, 6, 8]


export function multiplyElements (array) {
   // Tu código aquí 👈
  let result =[];
  for (let element of array){
    result.push( element*element)
  }
  return result
}
// inicializar la variable
multiplyElements(numbers)

Mi solucion al reto

Imagen generada con ray.so

export const multiplyElements = array => array.map(i=> i*2);

Estoy volviendo a tomar el curso y definitivamente estas pruebas lo hacen aun mas completo

Mi aporte 😃

function solution(array) {
	return array.map((number) => {
		 return number*2
	 })
}; 

<const newNumbers = numbers2.map(item => { return item * 2});> 

Es el mismo ejemplo que propoponen en MDN, si alguien no la conoce todavía es un momento perfecto para echarle un vistazo 👀👌🏼

Mi solucion:

export function multiplyElements(array) {
   // Tu código aquí 👈
   return array.map(num => num * 2)
}

aca esta el resultado 😃

export function multiplyElements(array) {
  return array.map(e => e * 2)
}
multiplyElements([2, 4, 5, 6, 8]) 

Ahora si tendremos para practicar bastante con estos ejemplos

export function multiplyElements(array) {
  return array.map(item => item * 2);
}

reto solucionado

export function multiplyElements(array) {
   // Tu código aquí 👈
   return array.map((num) => {
      return num * 2
   })
}

Solución:

export function multiplyElements(array) {
  return array.map((num) => num * 2);
}

export function multiplyElements(array) {
 return array.map(number => (number*2))}

Mi solución
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function multiplyElements(array) {
   // Tu código aquí 👈
   return array.map(number => number*2)
}

Mi solución

function multiplyElements(array) {
  return array.map(item => item * 2);
}

Esta fue mi solucion:

export function multiplyElements(array) {
   return array.map(number => number * 2)
}

export function multiplyElements(array) {
const multipliedArray = array.map(element => element * 2);
return multipliedArray;
}

Aquí mi solución:

export function multiplyElements(array) {
// Tu código aquí 👈
let output = [];
output = array.map(element => {
return element * 2
})
return output;
}

Esta fue mi solución 💚

Pueden probarla aqui:

export function multiplyElements(array) {
  return array.map(number => number * 2)
}

<code> const array = [2, 4, 5, 6, 8];

function multiplyElements() {
    // Tu código aquí 👈   
    return array.map(item => item * 2);
 }

 console.log(multiplyElements(array));

Esta fue mi solución.

export function multiplyElements(array) {
   // Tu código aquí 👈
   const mutiplicaArray = array.map((item) => item * 2);
   return mutiplicaArray
} 

Mi respuesta

function multiplyElements(array) {

   let mult = array.map(item => item * 2)

   return mult

}
console.log(multiplyElements([2, 4, 6, 8, 10]))

export function multiplyElements(array) {
   // Tu código aquí 👈
   const multi = array.map(numero => numero * 2)
   return multi

}

Mi solución:

function multiplyElements(array) {
    // Tu código aquí 👈
    return newArray = array.map(e => (e*2))
 }
 
 console.log(multiplyElements([2, 4, 5, 6, 8]))

Mi solución al reto:

export function multiplyElements(array) {
   return array.map(arr => arr * 2)
}

Solution

export function multiplyElements(array) {
   // Tu código aquí 👈
   return array.map(n => n * 2);
}

multiplyElements([2, 4, 5, 6, 8])
multiplyElements([1, 1, -4, -6])

export function multiplyElements(array) {
const letters = [25, 58, 12, 5];
const nuevoarray = letters.map((item) => item * 2);
}
console.log(nuevoarray);

poder resolver los desafíos me enorgullece

export function multiplyElements(array) {
   // Tu código aquí 👈
   return array.map(item => item * 2)

}

Primera vez que me topo con este tipo de actividades en Platzi y me encantaron, quisiera ver más de este tipo de actividades en más cursos. Por cierto…dejo mi aporte jaja

export function multiplyElements(array) {
   return array.map(num => num * 2);
}

Nose usar estos retos, siempre los hago y le doy correr pruebas y se queda parado, luego los hago en mi VSC y me sale la respuesta esperada.

export function multiplyElements(array) {
return array.map(i => i * 2)
}

const multiplyElements = (array)=> {
   return array.map(multi => multi * 2);
}
array = [2, 4, 5, 6, 8];
multiplyElements(array)

// [ 2, 4, 5, 6, 8 ]
// [ 4, 8, 10, 12, 16 ]

Con la herramienta RUN.JS
https://runjs.app/

El compilador es demasiado lento

mi solución:

export function multiplyElements(array) {
   return array.map(item => item * 2)
}

Mi solucion!

export function multiplyElements(array) {
   // Tu código aquí 👈

   const newArray = array.map(item => item * 2);
   return newArray;
}

Solucion

function multiplyElements(array) {
    return array.map(x => x*2)
}

Código JavaScript:

function multiplicar(array, base) {
   return array.map(item => item * base);
}
multiplicar([1,2,3,4,5,6,7,8,9,10], 2);

Adjunto mi solución 😄 .

export function multiplyElements(array) {
   return array.map((element, index, arr) =>
      Number(element) * 2
   );
}

export function multiplyElements(array) {
   return array.map((element) => element * 2);
}

de las 3 maneras

const numbers = [1, 2, 3, 4, 5,];
for (let index = 0; index < numbers.length; index++) {
    const element = numbers[index] * 2;
    console.log(element);
}

//con foreach
numbers.forEach(numbers => {
    console.log(numbers * 2);
});
//con map


const newNumber= numbers.map(item => item * 2);
console.log(newNumber);

Ejercicio resuelto con for, while, do-while, forEach y map 😉

const numbers = [1, 2, 3, 4, 5]

// Con for
const array1 = []
for (let i = 0; i < numbers.length; i++) {
    array1.push(numbers[i] * 2)
}
console.log("Con for", array1)

// Con while
let i = 0
const array2 = []
while(i < numbers.length){
    array2[i] = numbers[i] * 2; i++
}
console.log("Con while", array2)

// Con dowhile
i = 0
const array3 = []
do{
    array3[i] = numbers[i] * 2; i++
}
while(i < numbers.length)
console.log("Con do-while", array3)

// Con forEach
const array4 = []
numbers.forEach(number => array4.push(number * 2))
console.log("Con forEach", array4)

// Con map
const array5 = numbers.map(number => number * 2) 
console.log("Con map", array5)

Lo único que faltaría es retornar el arreglo para que quede como una función

Resultado:
Con for [ 2, 4, 6, 8, 10 ]
Con while [ 2, 4, 6, 8, 10 ]
Con do-while [ 2, 4, 6, 8, 10 ]
Con forEach [ 2, 4, 6, 8, 10 ]
Con map [ 2, 4, 6, 8, 10 ]

export function multiplyElements(array) {
return array.map(item => item * 2)
}

jaja me encanto este desafio

export function multiplyElements(array) {
   return array.map(n => n * 2)
}

es divertido usar asi los arrays

export function multiplyElements(array) {
   return array.map((num) => num*2)
}

Lo realicé de dos maneras:
Usando el forEach

export function multiplyElements(array) {
   let newarray = []
   array.forEach(item => newarray.push(item*=2))
   return newarray
}

y usando el .map

export function multiplyElements(array) {
   return (array.map(item=> item*2))
   // Tu código aquí 👈
}

export function multiplyElements(array) {
   // Tu código aquí 👈
   const numMultiplied  = array.map(num => { return num * 2 });

   return numMultiplied;
}

<code> 

export function multiplyElements(array) {
   return array.map(ele=>ele*2)
   // Tu código aquí 👈
}

![](

ezzzzz

export function multiplyElements(array) {
   return array.map(num => num*2);
}

export function multiplyElements(array) {
   return array.map(item=>item*2)
}

Me parece genial que hay puesto este playground para realizar los ejercicios primera vez que lo estoy probando y esta genial.

export function multiplyElements(array) {
   // Tu código aquí 👈
   return array.map(item => (item * 2));
}```

Yo lo Solucione asi :

let newData = []
function multiplyElements(array) {
newData = array.map(item => {
return item * 2
})
}

multiplyElements([2, 4, 5, 6, 8]);
console.log(newData)
// salida : [4,8,10,12, 16]

Ejemplo con forEach

function multiplyElements(array) {
    const elements = array.map(item => item * 2);

    return elements
    
}

const resultado = multiplyElements([2, 4, 5, 6, 8]);
console.log(resultado)

Ejemplo con For

function multiplyElements(array) {
    let arrayCopia = []
    for (let index = 0; index < array.length; index++) {
        const element = array[index] * 2;
        arrayCopia.push(element)
        
    }
    return arrayCopia;
}

const resultado = multiplyElements([2, 4, 5, 6, 8]);
console.log('esta es la copia', resultado);

function solution(array) {
	return array.map (item => item*2);
}; 

const array = [2,4,5,6]
console.log(solution(array))

function solution(array) {
return array.map (item => item*2);
};

const array = [2,4,5,6]
console.log(solution(array))

guau, que genial, primera vez que veo estos desafios, muy bueno

Lo hice bien pero no sabia como mandarlo, lo probe en VSCODE y me daba bien, me lo marco mal el programa de platzi

Como el requisito es usar la función map, me compliqué al principio creando una variable para el nuevo array. El desafio era más sencillo 😅
Finalmente les comparto mi solución

function solution(array) {
 	// Tu código aquí 👈 
	 return array.map(item => item * 2)
}; 

const array = [2, 4, 5, 6]

solution(array)

Eestaba esperando esta nueva feature de ejercitación desde que empecé a estudiar con Platzi. Me encanta!

Interesante los ejercicios…
function solution(array) {
// Tu código aquí 👈
return array.filter(item=>item.total>=100&&item. Delivered===true)
};

Casi no entiendo lo de las funciones flecha xd por eso tambien lo hice asi:

const numeros=[2,4,5,6];
const newNumeros=[];
for (let i=0;i<numeros.length;i++){
    let item = 2*numeros[i];
    newNumeros[i]=item;
}
console.log(newNumeros);

function solution(arr){
 arr.map((n)=>n*2)
}

es lo mejor que he visto en platzi, cada clase debería tener un ejercicio de este tipo, incluso los exámenes deberían tener ejercicios de este tipo para poder aprobarlos

Deberian hacer mas cursos asi de interactivos, LO AME