Playgrounds: Retorna solo palabras de 4 letras y más

Que buenas que están estas prácticas. Todos los cursos deberían tenerlas! 🙌😎

Esta es la solución que realice:

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda numLetters: len(numLetters) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Resumen de for, list comprehension, filter y lambda.

# list
words = ['amor', 'sol', 'piedra', 'día']
#cuenta el numero de elementos de words
print(f'List number of words \n{len(words)}')

#realiza un for que cuenta la candidad de letras en la lista words y realiza un append a la lista numbers_wods
numbers_letters = []
for i in words:
    numbers_letters.append(len(i))    
print(f'List number letters in numbers_letters\n{numbers_letters}')

#list comprehension del paso anterior
numbers_letters_v2 = [len(i) for i in words]
print(f'List number letters in numbers_letters_v2 \n{numbers_letters_v2}')

#utilizar filter y lambda para el paso anterior 
def filter_by_length(words):
    numbers_letters_v3 = list(filter(lambda i:len(i) >= 4, words))
    return numbers_letters_v3

print(f'Result of filter_by_length \n{filter_by_length(words)}')

Me gusta la simpleza

def filter_by_length(words):
   return list(filter(lambda word : len(word) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
print(filter_by_length(words))

Esta es mi solución 😃

def filter_by_length(words):
   # Escribe tu solución 👇
   palabra = list(filter(lambda x : len(x) >= 4, words))
   return palabra

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

En este ejercicio y el pasado, intenté reducir al máximo el numero de lineas y en mi editor funciona perfecto, alguien sabe por qué acá no me corre? 😦

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = list(filter(lambda word: len(word)>=4, words))
print(response)

Siguiendo un comentario que mencione el ejercicio anterior podemos hacerlo de forma muy resumida:

words = ['amor', 'sol', 'piedra', 'día']
response = list(filter(lambda x: len(x)>=4, words))

print(response)

def filter_by_length(words):
   # Escribe tu solución 👇
   result = list(filter(lambda text : len(text) >= 4 , words))
   return result

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

<# Retorna solo palabras de 4 letras y más, reto playground

def filter_by_length(words):
  words = list(filter(lambda i: len(i) >= 4, words))
  return words
  
words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)
> 

filter trabaja con dos partes, la primera una “funcion”, y la segunda un iterable, en este caso, words. En la primera parte el lambda recibe el nombre del iterador (en este caso word) y FILTRA (no confundir con MAP) con la condicional len(word)>=4.

La solucion es:

def filter_by_length(words):

Escribe tu solución 👇

result=list(filter(lambda word:len(word)>=4, words))
return result

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   return list(filter(lambda x : len(x)>=4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   # Escribe tu solución 👇
   result = list(filter(lambda word: len(word) >= 4, words))
   return result

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   # Escribe tu solución 👇
   new_list = list(filter(lambda i : len(i) >= 4, words))
   return new_list

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Mi solución

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda word: len(word)>=4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Las dos funcionan:

return list(filter(lambda word: len(word) >= 4, words))

return [word for word in words if len(word) >= 4]

Mi solucion al reto.

def filter_by_length(words):
   # Escribe tu solución 👇
   filter_words = list(filter(lambda word: len(word) >= 4, words))
   return filter_words

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

increible, reto…

utilice un for para analisar mas detalle como resolverlo con lambda.

words = ['love', 'amazing', 'wonderful', 'paper']

for word in words:
    if len(word) <= 5:
        print(word)

new_words = list(filter(lambda word: len(word) <= 5, words))
print(new_words)
print(', '.join(map(str, new_words)))
print()

def filter_by_length(words):
   resultado = list(filter(lambda i : len(i) >= 4 ,words ))
   return resultado

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   output=list(filter(lambda word:len(word)>=4,words))
   return output

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Me gusto el ejercicio a resolver. Aqui siento que estoy aprendiendo mas acerca de este lenguaje. A seguir mejorando.

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda numLetters: len(numLetters) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

solucion reto

def filter_by_length(words):
   # Escribe tu solución 👇
   num = list(filter(lambda i : len(i) >= 4, words))
   return num

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)```

def filter_by_length(words):
    # Utiliza filter() con una función lambda para filtrar las palabras por longitud
    filtered_words = list(filter(lambda word: len(word) >= 4, words))
    
    return filtered_words

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Paso 1: Definir la función filter_by_length(words).

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

En este paso, estamos creando una función llamada filter_by_length que acepta una lista de palabras 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.

Paso 2: Definición de la lista de palabras.

pythonCopy code
words = ['amor', 'sol', 'piedra', 'día']

En este paso, estamos definiendo una lista llamada words que contiene algunas palabras. Esta es la lista que queremos filtrar para obtener palabras con 4 o más letras.

Paso 3: Llamar a la función filter_by_length(words) con la lista de palabras como argumento.

pythonCopy code
response = filter_by_length(words)

En este paso, estamos llamando a la función filter_by_length() que definimos en el Paso 1. Le estamos pasando la lista de palabras [amor', 'sol', 'piedra', 'día'] como argumento. Esto significa que la función recibirá esta lista y realizará alguna operación en ella.

Paso 4: Utilizar filter() junto con una función lambda para filtrar las palabras.

pythonCopy code
filtered_words = list(filter(lambda word: len(word) >= 4, words))

Aquí, estamos utilizando la función filter() para crear una nueva lista llamada filtered_words. La función filter() se aplica a cada elemento de la lista words. La función lambda lambda word: len(word) >= 4 verifica si la longitud de cada palabra word es mayor o igual a 4. En otras palabras, estamos filtrando las palabras que tienen 4 letras o más.

Luego, convertimos el objeto filter en una lista utilizando list() para obtener la lista de palabras que cumplen con la condición.

Paso 5: Retornar la lista filtrada.

pythonCopy code
return filtered_words

En este paso, estamos retornando la lista filtered_words que contiene las palabras que tienen 4 o más letras.

Paso 6: Imprimir la lista resultante.

pythonCopy code
print(response)

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

<code> 
def filter_by_length(words):
   # Escribe tu solución 👇
   wordsLenMayor4 = list(filter(lambda items : len(items) >= 4, words))
   return wordsLenMayor4 

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):

Escribe tu solución 👇

wordsLenMayor4 = list(filter(lambda items : len(items) >= 4, words))
return wordsLenMayor4

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

<code> 

Esta es mi solución

Estuvo muy similiar al anterior playground. Aqui de jo la solución:

.
.
.
.
.
.
.
.
.
.
.
.
.
.

codigo ↓↓↓

def filter_by_length(words):
   return list(filter(lambda word: len(word) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   
   return list(filter(lambda x:len(x)>=4,words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)```

Mi solución:

def filter_by_length(words):

Escribe tu solución 👇

return list(filter(lambda item:len(item)>=4, words))

#words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
words =[‘rosa’, ‘gol’, ‘pez’, ‘día’, ‘gafas’]
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   word = list(filter(lambda x :len(x)>=4 , words))
   return word

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Resumí el código y funciona perfectamente pero el test me da error, con cosas que no entiendo

words = ['amor', 'sol', 'piedra', 'día']
response= list(filter(lambda word:len(word) >= 4,words))
print(response)

Necesito que todos los cursos de Programación tengan estas prácticas !

Vaya que me hizo pensar!

def filter_by_length(words):
   # Escribe tu solución 👇
   new_word = list(filter(lambda x:len(x)>=4, words))
   return new_word

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Comparto el ejercicio

def filter_by_length(words):
   """Function filter by length"""
   filtered = list(filter(lambda word: len(word) >= 4, words))
   return filtered

words = ['amor', 'sol', 'piedra', 'día']
# words = ['rosa', 'gol', 'pez', 'día', 'gafas']

response = filter_by_length(words)
print(response)

Comparto mi aporte,

Si tienes un error de syntaxis, verifica usar los simbolos correctos, como () en vez de []. Al menos a mi me pasó.

def filter_by_length(words):
   # Escribe tu solución 👇
   #creo una lista
   #utilizo el filtro
   #Creo una lambda function
   #Para cada word, si el largo de word es mayour o igual a cuatro, dentro
   #de words, agrega word
   return list(filter(lambda word: len(word) >= 4, words))
         

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Mi aporte 😃

def filter_by_length(words):
        filter_of_words = list(filter(lambda word: len(word) >= 4, words))
        return filter_of_words

    words = ['amor', 'sol', 'piedra', 'día']
    response = filter_by_length(words)
    print(response)

def filter_by_length(words):
    filtrando = list(filter(lambda x: len(x) >= 4, words))
    return filtrando

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Mi solución:

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda words: len(words) > 3, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

😁

def filter_by_length(words):
   # Escribe tu solución 👇
   result = list(filter(lambda words: len(words) >= 4, words))
   return result

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda word: len(word) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Esta es la solucion que hice de forma ordenada

def filter_by_length(words):
   filt=list(filter(lambda item:len(item) >= 4,words))
   return filt

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Aquí está mi solución :

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda word: len(word) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Esta es mi solución:

def filter_by_length(words):
    # Escribe tu solución 👇
    words_len = list(filter(lambda x: len(x) >= 4, words))
    return words_len


words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   # Escribe tu solución 👇
   resultado = list(filter(lambda palabra: len(palabra)>=4, words))
   return resultado

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Estas prácticas ayudan mucho a entender este tema y repasar conceptos anteriores, por ejemplo, el uso de lambda functions

def filter_by_length(words):

Escribe tu solución 👇

return list(filter(lambda x: len(x) >= 4, words))

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

que emoción cada vez se me dificulta menos esto =D

Estte es mi codigo

<def filter_by_length(words):
   # Escribe tu solución 👇
   result=list(filter(lambda x:len(x)>=4,words))
   return result

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)
print(len(response))> 

mi solucion:

<def filter_by_length(words):
   filtro= list(filter(lambda word: len(word)>=4, words))
   return filtro> 

def filter_by_length(words):
    # Utilizamos filter() para filtrar las palabras usando una función lambda
    # La función lambda devuelve True si la longitud de la palabra es 4 o más
    result = list(filter(lambda word: len(word) >= 4, words))
    return result

# Ejemplo de uso
lista_palabras = ["casa", "perro", "árbol", "gato", "sol", "flor", "mesa"]
resultado_filtrado = filter_by_length(lista_palabras)
print(resultado_filtrado)  # Salida: ['casa', 'perro', 'árbol', 'flor', 'mesa']

['casa', 'perro', 'árbol', 'gato', 'flor', 'mesa']

test_words

test_empty

¡Felicidades, todas las pruebas pasaron!

.
.
.
.
.
.
.

def filter_by_length(words):
   new_word = list(filter(lambda item: len(item) >= 4, words))
   return new_word

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Aquí mi solución, excelentes ejercicios

def filter_by_length(words):
   # Escribe tu solución 👇
   
   return list(filter(lambda item: len(item) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Esta es mi solución

def filter_by_length(words):
result = list(filter(lambda i: len(i)>=4,words))
return result

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

Aqui mi solucion:

def filter_by_length(words):
   fourLatter = list(filter(lambda letter: len(letter) >= 4, words))
   return fourLatter

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

My solution:

def filter_by_length(words):

Escribe tu solución 👇

solution = list(filter(lambda word: len(word) >= 4, words))
return solution

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

Buen día muchachos , acá les dejo mi código para que lo revisen y se guíen de el

<def filter_by_length(words):
   # Escribe tu solución 👇
   result = list(filter(lambda x:len(x)>=4,words))
   return result

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)> 

Aqui les dejo esta solucion que realice

def filter_by_length(words):
   return list(filter(lambda word: len(word) >= 4, words))
words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   words = list(filter(lambda word: len(word) >= 4, words))
   return words

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Mi solución usando list comprehension y operador star.

def filter_by_length(words):
   # Escribe tu solución 👇
   return [*filter(lambda word: len(word) >= 4, words)]

Gracias por el curso, me ha encantado!.

COMPAÑEROS, lo hice asi:

words = ['amor', 'sol', 'piedra', 'día']
response = list(filter(lambda i: len(i) > 3, words))
print(response)

IMPRIME

['amor', 'piedra']

PERO NO ME LO ACEPTA :C
QUE HAGOO?

Solución:

def filter_by_length(words):
   # Escribe tu solución 👇
   return list(filter(lambda x : len(x) >= 4, words))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

mi interpretacion de la respuesta

filter_by_length = lambda dat: list(filter(lambda dat: len(dat) >= 4, dat))

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Este es mi aporte

def filter_by_length(words):

Escribe tu solución 👇

return list(filter(lambda letras: len(letras)>=4, words))

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

def filter_by_length(words):
filtered_words = list(filter(lambda x: len(x) >= 4, words))
return filtered_words

words1 = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
print(filter_by_length(words1)) # Output: [‘amor’, ‘piedra’]

words2 = [‘rosa’, ‘gol’, ‘pez’, ‘día’, ‘gafas’]
print(filter_by_length(words2)) # Output: [‘rosa’, ‘gafas’]

Esta es mi solucion al ejercicio, espero puedan guiarse de esta, respondo cualquier duda y sugerencia

def filter_by_length(words):
   # Escribe tu solución 👇
   lista_filtrada = list(filter(lambda item: len(item)>=4, words))
   return lista_filtrada

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

.
.
.
.
.
.
.
.
.
.

def filter_by_length(words):
   # Escribe tu solución 👇
   resultado = list(filter(lambda item:len(item)>3,words))
   return resultado

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):
   # Escribe tu solución 👇
    filtrado = filter(lambda words:len(words)>=4,words)
    return list(filtrado)

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

def filter_by_length(words):

Escribe tu solución 👇

result = list(filter(lambda item: len(item) >= 4, words))
return result

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

Hola! 😁
Esta es mi solución 👇

mi humilde aporte quizas pueda mejorar :
def filter_by_length(words):
return list(filter(lambda words : len(words) >= 4,words))

words = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
response = filter_by_length(words)
print(response)

El profe todo bonito deja la pista en el mismo enunciado 🐍

Esto salio asi :

def filter_by_length(words):
   filter_words = list(filter(lambda iterato:len(iterato)>=4,words))
   return filter_words

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)

Mi aporte al reto:

words1 = ['amor', 'sol', 'piedra', 'día']
new_list = list(filter(lambda x: len(x) >= 4, words1))
print(new_list)

def filter_by_length(words):
   # Escribe tu solución 👇
   verificacion = list(filter(lambda words: len(words) >= 4, words))
   return verificacion

words = ['amor', 'sol', 'piedra', 'día']
response = filter_by_length(words)
print(response)