隆Te damos la bienvenida a este reto!

1

Empezando con Python desde 0

D铆a 1

2

Variables, funciones y sintaxis b谩sica

3

Tipos de datos: Numbers, Strings y Diccionarios

4

Playground - Retorna el tipo

D铆a 2

5

Operadores

6

Playground - Calcula la propina

D铆a 3

7

Condicionales

8

Playground - Averigua si un a帽o es bisiesto

9

Ciclos

10

Playground - Dibuja un triangulo usando bucles

D铆a 4

11

Listas

12

Encuentra a los gatitos m谩s famosos

13

Diccionarios

14

Obt茅n el promedio de los estudiantes

15

Tuplas

16

Obten la informaci贸n de los paquetes

D铆a 5

17

Calcula la cantidad de letras en una oraci贸n

18

Encuentra el mayor pal铆ndromo

D铆a 6

19

Sets

20

Encuentre la intersecci贸n de conjuntos

D铆a 7

21

List comprehension

22

Encuentra palabras con dos vocales

23

Dictionary Comprehension

24

Calcula la longitud de las palabras

D铆a 8

25

Funciones Lambda

26

Filtra mensajes de un user espec铆fico

27

Higher order functions

28

Crea tu propio m茅todo map

D铆a 9

29

Manejo de Errores y excepciones

30

Maneja correctamente los errores

31

Maneja las excepciones

D铆a 10

32

Playground - Crea un task manager usando closures

D铆a 11

33

Lectura de archivos de texto y CSV

D铆a 12

34

Programaci贸n orientada a objetos

35

Crea un auto usando clases

D铆a 13

36

Abstracci贸n en Python

37

Playground - Crea un sistema de carrito de compras

38

Encapsulamiento en Python

39

Playground - Encapsula datos de los usuarios

D铆a 14

40

Herencia en Python

41

Playground - Jerarqu铆a de animales usando herencia

D铆a 15

42

Polimorfismo en Python

43

Playground - Implementa un sistema de pagos

D铆a 16

44

Estructuras de datos en Python

45

Playground - Crea tu propia lista en python

46

Hash tables en Python

47

Playground - Implementaci贸n de una HashTable para Contactos

D铆a 17

48

Maps en Python

49

Playground - Crea un task manager con Maps

D铆a 18

50

Singly Linked List en Python

51

Playground - Implementaci贸n de una singly linked list

D铆a 19

52

Stacks en Python

53

Playground - Implementaci贸n de un stack

D铆a 20

54

Queues en Python

55

Playground - Implementaci贸n de una queue

D铆a 21

56

隆Lo lograste!

No tienes acceso a esta clase

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

脷ltima oportunidad para asegurar tu aprendizaje por 1 a帽o a precio especial

Antes: $249

Currency
$189/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

1D
8H
57M
19S

Calcula la longitud de las palabras

24/56

Aportes 47

Preguntas 0

Ordenar por:

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

o inicia sesi贸n.

Hay que escoger entre las dos declaraciones del Zen de python Flat is better than nested. o Explicit is better than implicit. solo por reto escog铆 plano es mejor que anidando 馃悕 porque entre mas larga sea la l铆nea m谩s complicada de captar r谩pido.

.
.

Aqui mi solucion:
.
.
.
.
.
.
.
.
.

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  list_word = [len(word) for word in words]
  return {word: list_word.count(word) for word in list_word}

Soluci贸n鈥
Esto es muy divertido 馃槃
.

.
.
.
.

def count_words_by_length(words):
  return {
    len(word): len([
        item 
        for item in words 
        if len(item) == len(word)
        ]) 
        for word in words
    }



.
.
.
.
.

return {len(word): sum(1 for w in words if len(w) == len(word)) for word in set(words)}

soluci贸n:

def count_words_by_length(words):
    return {len(propword): len([countfruit for countfruit in words if len(propword) == len(countfruit) ]) for propword in words  }

if __name__ == '__main__':
  list01 = [
    "apple",
    "banana",
    "orange",
    "grapefruit",
    "pear",
    "kiwi"
  ]
  response = count_words_by_length(list01)
  print(response)

  list02 = [
    "apple",
    "banana",
    "orange"
  ]
  response = count_words_by_length(list02)
  print(response)

hola esta fue mi soluci贸n:

.
.
.
.
.
.
.
.
.
.
.
def count_words_by_length(words):
result= {len(palabra):len(list(filter(lambda vol:vol if len(palabra) == len(vol) else 0,words))) for palabra in words}
return result

Les comparto mi soluci贸n empleando list comprehension y dictionary comprehension

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  words_by_length = {
    len(word): [
      len(word) for word in words
    ].count(len(word)) for word in words
  }
  return words_by_length
  pass

馃洝锔忦煕★笍Escudo anti-spoilers馃洝锔忦煕★笍

Mi soluci贸n al reto:

def count_words_by_length(words):
  return { 
    len(w): sum(
    1 for i in words 
      if len(i) == len(w))
    for w in words 
  }
def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  result = {}
  for word in words:
    letters = 0
    for letter in word:
      letters += 1
    if letters in result:
      result[letters] += 1
    else:
      result[letters] = 1
  return result
  
words = count_words_by_length(["apple", "ana", "rio"])
print(words)


.
.
.
.
.
.
.
.
.
.

Mi c贸digo:

def count_words_by_length(words):
  count_words = [len(word) for word in words]
  return {word: count_words.count(word) for word in count_words}

Sin diccionario comprehension:

def count_words_by_length(words):
  """Function to count words by length"""
  # Declaro a Dict
  words_by_length = {}

  if not words:
    return words_by_length
    
  # Itero the words list for create the dict with dict comprehension
  for word in words:
    # Calculate len of the word
    len_word = len(word)
    if len_word not in words_by_length:
      words_by_length[len_word] = 1
    else:
      words_by_length[len_word] += 1
  return words_by_length

  # Dictionary comprehension
  # return [words_by_length[len(word)] = 1 if len(word) not in words_by_length else words_by_length[len(word)]+=1 for word in words]


if __name__ == '__main__':
  words = ["apple", "banana", "orange", "grapefruit", "pear", "kiwi"]
  words2 = []

  response = count_words_by_length(words2)
  print(response)

Listo! agregue la funcion map y lambda

Palabras = [鈥渁pple鈥, 鈥渂anana鈥, 鈥渙range鈥, 鈥済rapefruit鈥,鈥減ear鈥, 鈥渒iwi鈥漖
#Palabras = [鈥渁pple鈥,鈥渂anana鈥,鈥渙range鈥漖
def longitudP(Palabras):
Salida = []
for Palabra in Palabras:
Salida.append(len(Palabra))
print(dict(zip(Salida,map(lambda x: Salida.count(x),Salida))))
longitudP(Palabras)

Mi aporte:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  return {len(word): len([total for total in words if len(word) == len(total)]) for word in words}
  pass

Hola a todos, les comparto mi codigo

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

def count_words_by_length(words):
    result = {len(word) : len([fruit for fruit in words if len(word) == len(fruit)]) for word in words}
    return result

Siento que no fue la mejor solcion se puede optimizar pero cumple con el requerimeinto:

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  lenWordsList = [len(word) for word in words]
  fruitDict = { len(word): lenWordsList.count(len(word)) for word in words}
  return fruitDict


.
.
.
.
.
.
.
.
.
.

def count_words_by_length(words):
  words_length = [len(word) for word in words]
  return {len(word): words_length.count(len(word)) for word in words}
def count_words_by_length(words):
    word_lengths=[len(word) for word in words]
    return {length:word_lengths.count(length) for length in word_lengths}


Aqu铆 mi soluci贸n, trate de usar un leguaje y nombrado de variables lo m谩s legible posible. Espero les ayude:

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  lengths = [len(word) for word in words]
  words_by_length = {length:sum(1 for word in words if len(word)==length) for length in lengths} 
  return words_by_length

Este estuvo mas abstracto. Pero me gusto mucho el ejercicio.

def count_words_by_length(words):
  return {len(word): sum([1 if len(word) == len(w) else 0 for w in words]) for word in words}
  pass


.
.
.
.
.
.
.
.
.
.
.

def palabras_con_la_misma_cantidad_de_caracteres(palabras):
  cantidad_de_caracteres = [len(palabra) for palabra in palabras] # aqu铆 se va a crear una lista de palabras que medira la cantidad de caracteres palabra por palabra de los parametros de la funcion
  print('cantidad_de_caracteres =>',cantidad_de_caracteres)
  
  return { palabra: cantidad_de_caracteres.count(palabra) for palabra in cantidad_de_caracteres } # aqui nos va a regresar un diccionario con la llave word y el valor sera la cuenta de cada palabra en la lista de palabras por cada palabra que exista en la lista

respuesta = palabras_con_la_misma_cantidad_de_caracteres([
  "apple",
  "banana",
  "orange",
  "grapefruit",
  "pear",
  "kiwi"
])
print(respuesta)
# cantidad_de_caracteres => [5, 6, 6, 10, 4, 4]
# {5: 1, 6: 2, 10: 1, 4: 2}

Este es mi codigo, pas贸 todas las pruebas:

def count_words_by_length(words):
  return {len(word): sum(1 for w in words if len(w) == len(word)) for word in words}



words_1 = [
    "apple",
    "banana",
    "orange",
    "grapefruit",
    "pear",
    "kiwi"
]

words_2 = [
    "apple",
    "banana",
    "orange"
]

print(count_words_by_length(words_1))  # Output: {5: 2, 6: 2, 7: 1, 10: 1}
print(count_words_by_length(words_2))  # Output: {5: 1, 6: 2}





.
.
.
.
.
.
.

def count_words_by_length(words):
  new_dict = {len(word): sum(1 for w in words if len(w) == len(word)) for word in words}
  return new_dict

result = count_words_by_length([
  "apple",
  "banana",
  "orange",
  "grapefruit",
  "pear",
  "kiwi"
])
print(result)

result = count_words_by_length([
  "apple",
  "banana",
  "orange"
])
print(result)

La diferencia con el ejercicio anterior, es que aqu铆 va primero el sumar y no al final

El output del ejemplo 1 en la gu铆a est谩 mal, lo que deber铆a dar es: {4: 2, 5: 1, 6: 2, 10: 1}
al momento de evaluar la respuesta est谩 bien, pero me confundi贸 un poco al tratar de entender el ejercicio.

Tal vez sea obvio para algunos, pero para aquellos que no le entendieron a la soluci贸n (como yo al principio) aqu铆 una peque帽a explicaci贸n:
.
Clave = tama帽o de la palabra
.
Valor = suma de las veces que esa cantidad de letras se repita en la lista.
.
O sea que son dos listas anidadas. La primera 鈥榳ord in words鈥 y la segunda 鈥榳 in words鈥. Comparando la longitud de la primera palabra (primera lista) con la longitud de todas las palabaras existentes en la lista (segunda lista).
.
Ejemplo:
palabra -> 鈥榖anana鈥 (tama帽o: 6):
.
if len(鈥榖anana鈥) == len(鈥榓pple鈥) #no -> 6 != 5
if len(鈥榖anana鈥) == len(鈥榖anana鈥) #s铆, le suma 1 ->6:1
if len(鈥榖anana鈥) == len(鈥榦range鈥) #s铆, le suma 1 -> 6:2
if len(鈥榖anana鈥) == len(鈥榞rapefruit鈥) #no -> 6 != 10
鈥 y as铆 compara cada palabra con la lista entera.
.
Espero les haya ayudado.


Mi aporte, dos soluciones:

def count_words_by_length(words):
  num = [len(w) for w in words]
  return {n: num.count(n) for n in num}

def count_words_by_length(words):
  dic = {}
  for w in words:
    key = len(w)
    if key not in dic:
      dic[key] = 1
    else:
      dic[key] += 1
  return dic

**
*
*
*
*
*
*
*
*
*
*

ef count_words_by_length(words):
  
  dict = {}
  #Para cada palabra en la lista de palabras
  for word in words:
    # obtener la longitud de la palabra
    length = len(word)

    # si la longitud ya esta incrementamos la cuenta
    if length in dict:
      dict[length] +=1
    # Si la longitud no esta , a帽ade con cuenta uno
    else:
      dict[length] = 1
  # Devolvemos el diccionario
  return(dict)
      


response = count_words_by_length([
  "apple",
  "banana",
  "orange",
  "grapefruit",
  "pear",
  "kiwi"
])
print(response)

response = count_words_by_length([
  "apple",
  "banana",
  "orange"
])
print(response)```
def count_words_by_length(words):
    words_length = [len(word) for word in words]
    words_length_set = set(words_length)
    words_length_dict = {length: words_length.count(length) for length in words_length_set}
    return words_length_dict
    pass

El Zen de Python es claro:
Sparse is better than dense.
Readability counts.

def count_words_by_length(words):
  listado = [len(word) for word in words]
  return {conteo: listado.count(conteo) for conteo in listado}


Mi resultado

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

def count_words_by_length(words):
  cnt = [len(word) for word in words]
  return {key: cnt.count(key) for key in cnt}


.
.
.
.
.
.
.
.

def count_words_by_length(words: list[str]) -> dict[int, int]:
    return {len(word): sum(1 for w in words if len(w) == len(word)) for word in words}

def count_words_by_length(words):
  sizes = [len(word) for word in words]
  return {size:sizes.count(size) for size in sizes}


.
.
Listo! 馃悕馃憣馃徏
.
.
.
.
.
.

def count_words_by_length(words):
  respuesta = {len(palabra): sum(1 for i in words if len(palabra) == len(i) ) for palabra in words}
  return respuesta

List y dict comprehension

.
.
.
.
.
.
.
.

def count_words_by_length(words):
  
  quantity = tuple(len(word) for word in words)

  return {q:quantity.count(q) for q in quantity}


.
.
.
.
.
.

creo que esta mal el ejemplo 1 o no le entend铆

mi aporte
*
*
*
*
*
**
*
*
*
*
*
*
*
*
**

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  salida = {}
  i=1
  palabras = [ len(word) for word in words]
  salida = {len(word): palabras.count(len(word)) for word in words}
  return salida

Mi soluci贸n 馃捇 馃悕


.
.
.
.
.
.
.

def count_words_by_length(words):
  length = [len(word) for word in words]
  words_by_lenght = { 
    len(word): length.count(len(word))
    for word in words 
  }
  return words_by_lenght

En mi caso, no es el m谩s optimizado, pero logr茅 entender el uso del dictionary comprenhension. Espero que les sirva 馃槂

def count_words_by_length(words):
  # Tu c贸digo aqu铆 馃憟
  word_lenght = [len(word) for word in words]
  counts = {}
  for chars in word_lenght:
    counts[chars] = counts.get(chars, 0) + 1
  return counts

Input = [
  "apple",
  "banana",
  "orange",
  "grapefruit",
  "pear",
  "kiwi"
]
Output = count_words_by_length(Input)
print(Output) #Output: {5: 2, 6: 2, 7: 1, 10: 1}

#Ejemplo 2:

Input = [
  "apple",
  "banana",
  "orange"
]
Output = count_words_by_length(Input)
print(Output)  #Output: {5: 1, 6: 2}


o
o
o
o
o
o
o
o
def count_words_by_length(words):
diccionario = {}
for palabra in words:
longitud_palabra = len(palabra)
if longitud_palabra in diccionario:
diccionario[longitud_palabra] += 1
else:
diccionario[longitud_palabra] = 1
return diccionario

print(count_words_by_length([
鈥渁pple鈥,
鈥渂anana鈥,
鈥渙range鈥,
鈥済rapefruit鈥,
鈥減ear鈥,
鈥渒iwi鈥
]))

print(count_words_by_length([
鈥渁pple鈥,
鈥渂anana鈥,
鈥渙range鈥
]))


.
.
.
.
.
normal version

def count_words_by_length(words):
  response = {}
  for word in words:
    key = len(word)
    if key in response:
      response[key] += 1
    else:
      response[key] = 1
  return response

usando dist comprehension

def count_words_by_length(words):
  response = {len(word): sum(1 for w in words if len(w) == len(word)) for word in words}
  return response


*
*
*
*
*

def count_words_by_length(words):
    length_words = [len(word) for word in words]
    quantity_words =[length_words.count(word) for word in length_words]
    result = {a:b for (a,b) in zip(length_words, quantity_words)}
    return result

SPOILER

def count_words_by_length(words):
  output = { len(word): len(list(filter(lambda x: len(x) == len(word), words ))) for word in words }

  return output


.
.

def count_words_by_length(words):
   words_length = [len(word) for word in words]
   return  {num: words_length.count(num)  for num in words_length}
  1. words_length : array contiene longitud de cada palabra
  2. convierto esa longitud num en llave y el valor es contar esa llave en words_length usando la funcion count
undefined