No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende Ingl茅s, Programaci贸n, AI, Ciberseguridad y mucho m谩s.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

3 D铆as
2 Hrs
5 Min
20 Seg

Playground: multiplica todos los elementos por dos

5/28

Aportes 124

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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 a programar y bas谩ndome en algunos comentarios de otros compa帽eros, lo logr茅 resolver as铆, al menos al darle analizar me sali贸 que si estaba resuelto.

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});> 
As铆 me quedo, el ejercicio fue simple, por lo general siempre me ayudo con los comentarios pero se ve que estoy aprendiendo ajaja 馃拋馃徑鈥嶁檧锔 ![](https://static.platzi.com/media/user_upload/image-bcd0a352-93a9-416d-847b-2fc0bab65182.jpg)
```js export function multiplyElements(numeros) { return numeros.map(numero=> numero * 2); } ```
Como lo hice, fuera del ambiente que tiene platzi ```js const numbers = [2,4,5,6,8] const numeros = numbers.map(item => item * 2) console.log(numeros) ```const numbers = \[2,4,5,6,8]聽 聽const numeros = numbers.map(item => item \* 2)聽 聽console.log(numeros)
Otra forma en la que hice mi codigo ```js const numbers = [2,4,5,6,8] const numeros = numbers.map(item => item * 2) console.log(numeros) ```const numbers = \[2,4,5,6,8]聽 聽const numeros = numbers.map(item => item \* 2)聽 聽console.log(numeros)
Lo tengo bien solo que no sabia como funcionaba el ambiente para probar mi codigo, pero ya comprendi igual esta es mi solucion const numbers = \[2,4,5,6,8]聽 聽const numeros = numbers.map(item => item \* 2)聽 聽console.log(numeros)```js const numbers = [2,4,5,6,8] const numeros = numbers.map(item => item * 2) console.log(numeros) ```
Hola dejo por ac谩 mi soluci贸n creo que es una de las que menos code utiliza,export function multiplyElements(array) {聽 聽return array.map (n => n\*2)}![]() si alguien la hizo mas corta me encantar铆a verlo```js export function multiplyElements(array) { return array.map (n => n*2) } ```.

Mi solucion:

export function multiplyElements(array) {
   // Tu c贸digo aqu铆 馃憟
   return array.map(num => num * 2)
}

Estas actividades son las mejores ```js export function multiplyElements(array) { // Tu c贸digo aqu铆 馃憟 return array.map(item => item * 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);
}
SPOILERexport function multiplyElements(array) {聽 聽return array.map((element) => element \* 2)} ```js export function multiplyElements(array) { return array.map((element) => element * 2) } ```
Me encantan estos desaf铆os pero odio que escriban la soluci贸n en los comentarios. Eso atrasa a los compa帽eros.

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)
}
```js function multiplyElements(array) { return array.map(num => num*2) } ```
Hola aqui mi solucion ```js const example = [2, 4, 5, 6, 8]; const example2 = [1, 1, -2, -3]; export function multiplyElements(prevArray) { let newArray = prevArray.map(item => item * 2); console.log("Input: ", prevArray); console.log("Output: ", newArray) return newArray }; /////guardada en constantes por si se nesecita usar el nuevo array const newExample1 = multiplyElements(example); const newExample2 = multiplyElements(example2); ```

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鈥ejo 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

Es la primera vez en los cursos de platzi que encuentro este recurso, excelente, deberian ampliarlo a todos los cursos, e incluso dar opcion para ver los enunciados en ingles.

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

Super son 15 retos, intentare hacerlos todos

Comparto mi soluci贸n

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

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

muy severo. amor esta nueva funcion de playground.

//Retorna solo palabras de 4 letras
function solution(array) {
return array.filter(item => item.length >= 4)
};
por si les sirva a alguien !!

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

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

};

console.log('Solution: ', array);
console.log('Output: ', solution([2,4,5,6]));
const numbers = [2, 4, 6, 8, 10];

const solutions = (array) => array.map((number) => number * 2);

console.log(solutions(numbers));

les comparto la forma en que solucione los retos de arrays como un pro, saludos;

 function solution(arrayA, arrayB) {
            return arrayA.concat(arrayB);
        };

        function solution(array) {
            return array.flat();
        };

        function solution(lines) {
            const array = lines.map(line => line.split(" "))
            return array.flat().length;
        };

        function solution(array) {
            return array.sort((n1, n2) => n1 - n2).reverse();
        };

        function solution(array) {
            return array.sort((a, b) => a.length - b.length);
        };

        function solution(array) {
            const otro = array.sort((a, b) => a.dateOfBirth - b.dateOfBirth).reverse();
            return otro.map(o => o.name);
        };

        function solution(array) {
            const outro = array.map(a => a.split(" "));
            const ordenados = outro.sort((a, b) => a[1].localeCompare(b[1]));
            return ordenados.map(o => o.join(" "));
        };

        function solution(array) {
            const filter = array.filter((item, index) => {
                return array.indexOf(item) === index;
            })
            return filter.sort((a,b) => a-b);
        };

        function solution(array) {
            return array.reduce((obj, item) => {
                if (obj[item]) {
                    obj[item] += 1;
                } else {
                    obj[item] = 1;
                }
                return obj;
            }, {});
        }

        function solution(array, newElement) {
            const newArray = array.map(a => a);
            newArray.push(newElement);
            return newArray;
        };

        function solution(array, index, newValue) {
            const newArray = array.map(a => a);
            newArray.splice(index, 1, newValue);
            return newArray;
        };

        function solution(array, index) {
            const newArray = array.map(a => a);
            newArray.splice(index, 1);
            return newArray;
        };
undefined