Playgrounds: Multiplica todos los elementos por dos

Esta es la solución que realice:

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    result = list(map(lambda number: number * 2, numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Perdí una vida, y aunque los primeros minutos no entendía porque. Quite los corchetes al valor que se retorna. Volví a correr las pruebas y afortunadamente las aprobé todas:

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    new_list = list(map(lambda x : x * 2, numbers))
    return new_list

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Retorne una list comprehension y me ahorre una linea.

def multiply_numbers(numbers):
    return [x for x in list(map(lambda i: i*2, numbers))]

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

numbers = [1, 2, 3, 4]
response = list(map(lambda x: x*2, numbers))
print(response) 

La libertad que nos da Python para hacer funciones donde queramos es increíble, si quieren, no tienen que hacer nada mas que esto en la linea 3 y con eso, esta solucionado.

return list(map(lambda number: number * 2, numbers))

Siento que esta respuesta es buena por la inmutabilidad

def multiply_numbers(numbers):
    new_list = numbers.copy();
    return list(map(lambda x :x*2,new_list))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(numbers)
print(response)

no me pasaba las pruebas porque no le quitaba los [] en return

Yo escribí esta solución mas corta utilizando list comprehension, en mi VS Code funciona pero acá no 😦

numbers = [1, 2, 3, 4]
response = [number * 2 for number in numbers]
print(response

def multiply_numbers(numbers):
# Escribe tu solución 👇
return list(map(lambda i: i * 2, numbers))

me tarde un rato por que no sabia si teniamos que hacer solo la lista que ya estaba escrita o tambien los ejemplos, aun que estoy orgulloso es la primera vez que lo hago sin ver los aportes xd

Se puede resolver esto en un linea (3 contando el print y la lista inicial)

numbers = [1, 2, 3, 4]
response = list(map(lambda number: number*2, numbers))
print(response)

El Playground no me permitió realizar la ejecución 🙁 pero aquí está mi solución 😁

def multiply_numbers(numbers):
  # Escribe tu solución 👇
  result = list(map(lambda x: x * 2, numbers))
  return result
  
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)

logrado, se puede hacer el return en una linea pero a mi me gusta siempre guardar en variable 😃

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    multipli= list(map(lambda num:num*2,numbers))
    return multipli

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Yo resolvi asi los 2 ejercicios que venian en la guia.

• En el ejemplo 1, multiplique la lista por 2.
• En ejemplo 2, cree una nueva lista, la multiplique por la lista que estaba en la guia ejemplo 2.

#Solucion ejemplo 1
def multiply_numbers_v1(numbers):
    # Escribe tu solución 👇
    list_items = list (map(lambda i: i * 2, numbers))
    return list_items


numbers = [1, 2, 3, 4]
response = multiply_numbers_v1(numbers)
print(response)


#Solucion ejemplo 2
def multiply_numbers_v2(numbers_v1, numbers_v2):
    list_items = list (map(lambda x, y: x * y, numbers_v1 ,numbers_v2))
    return list_items


numbers_v1 = [1, 1, -2, -3]
numbers_v2 = [1, 1, 2, 2]
response = multiply_numbers_v2(numbers_v1, numbers_v2)
print(response)

Simple is better than complex.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    
    #return list(map(lambda number: number * 2, numbers)) # unnecessary map usage
    return [i * 2 for i in numbers]
    

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(lista:list) -> None:
return list(map(lambda number: number*2,lista))

def main():
lista_numeros = [1,2,3,4]
resultado = multiply_numbers(lista_numeros)
print(resultado)

if name==“main”:
main()

Solucion al reto.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    multiply_numbers = list(map(lambda x: x*2, numbers))
    return multiply_numbers

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
# Escribe tu solución 👇🤯
new_list = list(map(lambda number : number * 2, numbers))
return new_list

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Acá estan dos formas en las cuales pude llegar a la solución:

#Código 1

multiply_numbers = lambda numbers: list(map(lambda number: number*2,numbers))

numbers = [1, 1, -2, -3]
response = multiply_numbers(numbers)
print(response)

#Código 2
def multiply_numbers(numbers):
    response = list(map(lambda number: number*2,numbers))
    return response

numbers = [1, 1, -2, -3]
response = multiply_numbers(numbers)
print(response)

Me gusta especialmente la segunda opción. A pesar de que el Código 1 está más resumido, la segunda me parece más detallada.

def multiply_numbers(numbers):
    output=list(map(lambda n:n*2,numbers))
    return output

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Es interesante este reto. Cada vez se ve los ejercicios de python mas sencillos. Eso ayuda a mejorar tu capacidad y estar listo para el data science.

reto

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    num = list(map(lambda i : i * 2, numbers))
    return num
    

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

![]()def multiply\_numbers(numbers):\

# Escribe tu solución 👇\

    return list(map(lambda i : i \* 2, numbers))\

numbers = \[1, 2, 3, 4]response = multiply\_numbers(numbers)print(response)\

Paso 1: Definir la función multiply_numbers(numbers).

• En este paso, estamos creando una función llamada multiply_numbers que acepta una lista de números como entrada. La función aún no hace nada, solo estamos diciendo que vamos a escribir el código que realizará una tarea específica.

pythonCopy code
def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return []

Paso 2: Definir la lista de números.

• Creamos una lista llamada numbers que contiene algunos números, en este caso [1, 2, 3, 4]. Esta es la lista que queremos multiplicar por 2.

pythonCopy code
numbers = [1, 2, 3, 4]

Paso 3: Llamar a la función multiply_numbers(numbers) con la lista de números como argumento.

• En este paso, estamos llamando a la función multiply_numbers() que definimos en el Paso 1. Le estamos pasando la lista de números [1, 2, 3, 4] como argumento. Esto significa que la función recibirá esta lista y realizará alguna operación en ella.

pythonCopy code
response = multiply_numbers(numbers)

Paso 4: Definir la función lambda dentro de map().

• Dentro de la función multiply_numbers(), estamos utilizando la función map() para realizar una operación en cada número de la lista. La función map() toma dos argumentos: una función y una lista (o iterable).

pythonCopy code
multiplied_numbers = list(map(lambda x: x * 2, numbers))

• La parte lambda x: x * 2 es una función pequeña y anónima (sin nombre) llamada una función lambda. Lo que hace es tomar un número x y multiplicarlo por 2. Así que, por ejemplo, si x es 3, la función lambda devuelve 6.

Paso 5: Convertir el resultado en una lista.

• El resultado de map() no es una lista directamente, es un tipo especial de objeto llamado map. Queremos tener los resultados en una lista, por lo que utilizamos list() para convertir ese objeto map en una lista real.

pythonCopy code
multiplied_numbers = list(map(lambda x: x * 2, numbers))

Paso 6: Retornar la lista resultante.

• Finalmente, retornamos la lista resultante que contiene los números multiplicados por 2.

pythonCopy code
return multiplied_numbers

Paso 7: Imprimir la lista resultante.

• Después de llamar a la función multiply_numbers(), tenemos la lista resultante almacenada en la variable response. Ahora, imprimimos esta lista en la pantalla.

pythonCopy code
print(response)

def multiply_numbers(numbers):
    # Utiliza map() con una función lambda para multiplicar cada número por 2
    multiplied_numbers = list(map(lambda x: x * 2, numbers))
    
    return multiplied_numbers

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

mi respuesta a este reto:

def multiply_numbers(numbers):
result = list(map(lambda i: i * 2, numbers))
return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

producto = list(map(lambda x : x*2, numbers))

def multiply_numbers(number):
product = [number *2 for number in numbers]
return product

Me perdía mucho porque no sabia que la función lambda debía ir en la funcion multiply_numbers().
Mi solución ↓↓↓

.
.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.

def multiply_numbers(numbers):
    result = list(map(lambda i: i * 2, numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Con la primera clase de MAPS y entendiendo bien que hace RESULT se puede hacer solo añadiendo una línea de código.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda i: i * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

RETO
Si conservamos los [ ] al retornar la función tendriamos como resultado como se observa en la imagen.

No es necesario incoporarlos ya que de por si la funcion list() retorna una lista.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

ef multiplay_numbers(numbers):
result =list(map(lambda a: a * 5, numbers))
return result

numbers = [1, 2, 3, 4]
response = multiplay_numbers(numbers)
print(response)
mi copia le soy honesto me falta mucho a pesar de mi empeño me aferro mi teta es a prender

def multiply_numbers(numbers):
# Escribe tu solución 👇
multiply = list(map(lambda x : x*2, numbers))
return multiply

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
# Escribe tu solución 👇
return list(map(lambda x: x * 2, numbers))
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    
    return list(map(lambda i:i*2,numbers))
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)```

Mi solución:

def multiplicaciones (numero):
return list(map(lambda x: x *2, numero))
numero = [-1,-1,-3,-4]
resultados = multiplicaciones(numero)
print(resultados)

Esta es mi solucion con lambda y con funcion definida

#Con Funcion definida
def multiply_numbers(numbers):
    return numbers * 2

numbers = [1, 2, 3, 4]
response = list(map(multiply_numbers,numbers))
print(response)

#Con lambda

numbers = [1, 2, 3, 4]
response = list(map(lambda nm : nm * 2,numbers))
print(response)

def multiply_numbers(numbers):
multiplied_numbers = list(map(lambda num: num * 2, numbers))
return multiplied_numbers

numbers = [2, 4, 5, 6, 8]
response = multiply_numbers(numbers)
print(response)

Solo hay que utilizar map y la lambda function como return dentro de la función, recuerden que se trata de aplicar map y lambda function.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
#utilizo map para modificar la lista original
#utilizo una funcion lambda para duplicar cada iteración
    return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

no pasa las pruebas pero funciona ING Portilla

def multiply_numbers(numbers):
# Escribe tu solución 👇
return []

numbers = [1, 2, 3, 4]
response = list(map ( lambda element: element*2, numbers))
print(response)

Esta es mi solución:

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda number: number * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

MI solución:

def multiply_numbers(numbers):
    new_num = numbers.copy()
    new_num = list(map(lambda num: num*2, new_num))
    return new_num

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Todo en el mismo return! Algo que aprendí de Kaggle xd

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda i: i * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Mi solución

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    hola = [element * 2 for element in numbers]
    return hola

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers): 
    # Escribe tu solución 👇
    return list(map(lambda i : i*2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)```

.
.
.
Listo! 🐍👌🏼
.
.
.
.
.

def multiply_numbers(numbers):
    return list(map(lambda x: x*2, numbers))

def multiply_numbers(numbers):
# Escribe tu solución 👇
return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

# Multiplica todos los elementos por dos

# Que bonito se siente el haber hecho esto sólo y a la primera en menos de 2 min =D

def duplicados(lista_numeros): # definimos una funcion llamada duplicados con su parametro lista_numeros
  resultado = list(map(lambda num: num*2, lista_numeros)) # creamos la variable resultado la cual contiene la funcion map que esta misma contiene una funncion lambda que multiplicara por 2 casa numero de la lista_numeros y tambien usamos list para poderimprimirlos como lista
  return resultado # recordemos que si no ponemos list en antes de la fuincion map lo podemos poner aqui antes de resultado para que no nos imprima un valor iterable

# en la solucion lo ponen despues del return solo que ahi ya no creas la variable resultado

# return list(map(lambda num: num*2, lista_numeros))

lista_numeros = [1,2,3,4,5,6] 

respuesta = duplicados(lista_numeros)
print(respuesta) # [2, 4, 6, 8, 10, 12]

.
.
.
.
.
.
.

def multiply_numbers(numbers):
    new = list(map(lambda i: i * 2, numbers))
    return new

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Aquí la mi solución, estos ejercicios son muy buenos para repasar las clases

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda number: number * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Para los que se preguntan del ejemplo 2 del enunciado, se trata de un error de tipeo, todas las pruebas del playground verifican que la lista este multiplicada por 2

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    result = list(map(lambda i : i*2,numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    return list(map(lambda x: x * 2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Esta fue mi solucion ,me costo un poco entenderla pero nada fuera de lo comun

<def multiply_numbers(numbers):
    # Escribe tu solución 👇
    result_1=list(map(lambda x:x*2,numbers))
    return result_1

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)> 

Solución:

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda x : x*2, numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

aqui hice una version super optimizada de la respuesta 😄

multiply_numbers = lambda num: list(map(lambda dat: dat*2, num))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    juan=list(map(lambda x:x*2,numbers))
    return juan

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Para practicar hice un ejercicio con raíz cuadrada:

def raiz_cuadrada(numbers):
  result = list(map(lambda number: number ** (1/2), numbers))
  return result

numbers = [1, 9, 25, 49, 81]
response = raiz_cuadrada(numbers)
print(response)

Me encantan los playgrounds

No m quedó muy claro para que sirve la función multiply_numbers(). Yo la omití y cargué la map function directamente en la definición de la variable response. Al imprimirla y ejecutar me funciona bien, así:

numbers = [1, 2, 3, 4]
response = list(map(lambda i:i*2, numbers))
print(response)

Pero al correr las pruebas me arrojaba error. Entonces me di cuenta de que se me exigía usar la función multiply_numbers() e hice esto:

def multiply_numbers(numbers):
    return list(map(lambda i:i*2, numbers))

numbers = [1, 2, 3, 4]
response = list(map(lambda i:i*2, numbers))
print(response)

La definí pero ni siquiera la llame y ahí sí me aceptó la respuesta .________.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    valorespor2 = list(map(lambda numbers:numbers*2,numbers))
    return valorespor2

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

.
.
.
.
.
.

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda item:item*2,numbers))

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Versión cortísima 😆

multiply_numbers = lambda n: list(map(lambda x : x * 2, n))

interesante lo de ahorrarse una local variable, de todas maneras, funciona. Aunque no lo sentí como reto, pues el profe prácticamente habia dado la solución, pero chévere sirve para practicar el concepto.

asi salio -----> def multiply_numbers(numbers):
new_value = list(map(lambda iterable: iterable * 2 ,numbers))
return new_value

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    operateNumbers = list(map(lambda numbers: numbers * 2, numbers))
    return operateNumbers

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    arreglo= list(map(lambda x: x*2, numbers))
    return arreglo

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    return list(map(lambda x: x * 2, numbers))
    
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

numeros=[1,2,3,4,5]
numero_2=list(map(lambda i:i*2,numeros))
print(numero_2)

Acá la respuesta

Me tardé un poco, estuvo genial este ejercicio

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return [x for x in list(map(lambda i:i*2, numbers))]

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

_solo me guíe del archivo “14_map.py”

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return [x for x in list(map(lambda i: i*2, numbers))]

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

Buenas noches, aqui mi solucion, tomando en cuenta lo dicho en clase de no alterar la variable original, sino crear una copia apartir de ello usando el Map

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    new_list = numbers.copy()
    result= list(map(lambda i:i*2,numbers))
    return result

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

La solucion tambien se puede emplear sin definir la funcion que pone , puede ser asi

numbers = [1, 2, 3, 4]
response = list(map(lambda x: x*2, numbers))
print(response)

usas menos codigo que con metodos primitivos

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    mult = list(map(lambda x: x * 2,numbers))
    return mult

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

def multiply_numbers(numbers):
    # Escribe tu solución 👇
    return list(map(lambda x: x * 2, numbers))
    
numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
print(response)

xD

response = list(map(lambda x: x*2, [x for x in range(1,5)]))
print(response)