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)

Lo tuve correcto. solo me equivoqué. Donde iba “number”, yo use “i”. Ja ja. Y problemas con la maldita identación.

# Solución 1: en una línea con Lambda y MAP
"""
numbers = [1, 2, 3, 4]
result = list(map(lambda number: number * 2, numbers))
print(result)
"""

# Solución 2: con una variable DEF para el playground
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)

numbers_1 = [2, 4, 5, 6, 8]
numbers_2 = [1, 1, -2, -3]   

multiply_numbers_v2 = list(map(lambda numer: numer * 2 ,numbers_1))    
print(multiply_numbers_v2)
multiply_numbers_v3 = list(map(lambda numer: numer * 2 ,numbers_2))    
print(multiply_numbers_v3)

esta fue mi solucion, pero el compilador me dice que estoy mal

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

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

Creo que el resultado es mas simple que el ejemplo.

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

💻💡 Comparto mi solución:

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

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

Mi solución:

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

numbers = [1, 2, 3, 4]
response = multiply_numbers(numbers)
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)