Calcula la longitud de las palabras

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
    }

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 = [“apple”, “banana”, “orange”, “grapefruit”,“pear”, “kiwi”]
#Palabras = [“apple”,“banana”,“orange”]
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 ‘word in words’ y la segunda ‘w 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 -> ‘banana’ (tamaño: 6):
.
if len(‘banana’) == len(‘apple’) #no -> 6 != 5
if len(‘banana’) == len(‘banana’) #sí, le suma 1 ->6:1
if len(‘banana’) == len(‘orange’) #sí, le suma 1 -> 6:2
if len(‘banana’) == len(‘grapefruit’) #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([
“apple”,
“banana”,
“orange”,
“grapefruit”,
“pear”,
“kiwi”
]))

print(count_words_by_length([
“apple”,
“banana”,
“orange”
]))

.
.
.
.
.
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