Calcula la cantidad de letras en una oración

Después de solucionarlo lo simplifique a un a línea con dict comprehensions.

.
.
.
.
.
.

No use dictionary comprehensions:

def count_letters(phrase):
  d = {}
  for i in phrase:
    d[i] = d.get(i, 0) + 1
  return d

• Si se utiliza el método .count() se hará un conteo sobre el string por cada char que se recorra en el for del string, quedando entonces un algoritmo de complejidad O(n²).
• Si utilizamos el método dictionary.get() se sumará el valor de cada char en una sola iteración total del string, teniendo una complejidad O(n).

El rendimiento es mejor con el último.
Si bien en este ejemplo tan simple no existe una diferencia notable, será útil tenerlo en cuenta al momento de iterar y crear elementos mucho más grandes y complejos.

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

def count_letters(phrase):
  contarfrecuencia = {i: phrase.count(i) for i in phrase}
  return (contarfrecuencia)

Despues de los dolores de cabeza, éste es un alivio.

.
.
.

def count_letters(phrase):
    appereances = {}
    
    for char in phrase:
        appereances[char] = appereances.get(char, 0) +1
        
    return appereances

*
*
*
*
*

def count_letters(phrase):
    result = {}
    for letter in phrase:
        if letter not in result:
            result[letter] = 1
        else:
            result[letter] = result[letter] + 1
    return result

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

def count_letters(phrase):
  letters = { letter:phrase.count(letter) for letter in phrase }
  return letters

print(count_letters("Hola mundo"))

.
.
.

def count_letters(phrase):
  texto = {}
  for letra in phrase:
    texto[letra] = phrase.count(letra)
  # print(texto)
  return texto
frase= "Hola Mundo"
count_letters(frase)

Mi codigo:
def find_largest_palindrome(words):
palindromo_dict = {}
for word in words:
if word == word[::-1]:
palindromo_dict[word] = len(word)
word = max(palindromo_dict, key=palindromo_dict.get)
if word == None:
word = “No hay Palindromo” + word
else:
word = “El Palindromo mas largo de la lista es :” + word
return word

result = find_largest_palindrome([“racecar”, “level”, “world”, “hello”])
print(result)

mI solucion, con lo poco que se de python:
def count_letters(phrase):
letters = {}
letters_list = []

for i in phrase:
letters_list.append(i)
for i in letters_list:
letters[i] = letters_list.count(i)
return letters

result = count_letters(“HOla mundo”)
print("El resultado es: ",result )

def count_letters(phrase):
  # Tu código aquí 👈
  letras = tuple(letritas for letritas in phrase)
  conteo = {letters: letras.count(letters) for letters in letras}
  return conteo

res = count_letters("Hola mundo")
print(res)

def count_letters(frase):
    # Tu código aquí 👈
    diccionario = {}
    for letra in frase:
        if letra in diccionario:
            diccionario[letra] += 1
        else: 
            diccionario[letra] = 1
    return diccionario

def count_letters(phrase):
  
  letras = []
  cantidad = []

  for letra in phrase:
    letras.append(letra)
    cantidad.append(tuple(letras).count(letra))

  return dict(zip(letras, cantidad))

print(count_letters("Hola mundo"))

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

def count_letters(phrase):
  result = {}
  for i in phrase:
   if i in result:
    result[i] += 1
   else: 
    result[i] = 1
  return result 

.
.
.
.
.
.
.
.
.
.

def count_letters(phrase):
  letters = {}
  for letter in phrase:
    if letter in letters.keys():
      pass
    else:
      number = phrase.count(letter)
      letters.update({letter: number})
  return letters

def count_letters(phrase):
  # Tu código aquí 👈
  veces = {}
  for i in phrase:
    if i in veces :
      veces[i] += 1
    else:
      veces[i] = 1
  return veces

ejemplo = count_letters("Hola mundo")
print(ejemplo)

Listo!!

Frase = input(“Ingrese frase o palabra:”)
def calcular(Frase):
i = 0
Resultado = {}
Letras = len(Frase)
for i in range(0,Letras):
Letra = Frase[i]
cant = Frase.count(Letra)
Resultado.update({Letra:cant})
print(Resultado)
calcular(Frase)

def count_letters(phrase):
    letras = {letra: phrase.count(letra) for letra in phrase}
    return letras

solución:

def count_letters(phrase):
    #creando el diccionario
    dictresultfinal={ 
    }
    #creando la lista
    listletters=[]

    listletters=[propletters for propletters in phrase]
    dictresultfinal={propletters: listletters.count(propletters) for propletters in listletters}
     
    return dictresultfinal

if __name__ == '__main__':
    response=count_letters("Hola Mundo")
    print(response)

Solución 😄…
.

.
.
.
.

def count_letters(phrase):
  return {
    letter: phrase.count(letter) 
    for letter in phrase
  }

def count_letters(phrase):
  list(phrase)
  letters = {}

  for j in phrase:
    if j not in letters:
      letters[j] = phrase.count(j)

  return letters

.
.
.
.
.
.
.![](

En este tambien lo logre de una, solo motivacion:

def count_letters(phrase):
  characters = {}

  for character in phrase:
    if character in characters: 
        characters[character] += 1
        continue

    characters[character] = 1
  return characters

Del reto anterior vi la solución de Johan Diaz y no pude resistirme a aplicarlo en este reto, ahí les va:

def count_letters(phrase):
  tupla_letras = tuple(i for i in phrase)
  letras = {letra: tupla_letras.count(letra) for letra in tupla_letras}
  return letras

Solución:
.
.
.
.
.
…

En este caso sirve que cada que se vuelve a pasar por una letra que ya está, al ser esta la clave el valor se actualiza porque un diccionario no puede tener dos claves iguales.

def count_letters(phrase):
  return {letter: phrase.count(letter) for letter in phrase}

Este ejercicio quedó muy parecido a mi solución del ejercicio anterior.
.

.
.
.
.
.

def count_letters(phrase):
  phrase_dic = {}
  for i in range(len(phrase)):
    letter = phrase[i]
    if letter in phrase_dic:
      phrase_dic[letter] += 1
    else:
      phrase_dic[letter] = 1
  return phrase_dic

Mi solución:
.
.
.
.
.
.
.
.
.
.

def count_letters(phrase):
  return {letter:phrase.count(letter) for letter in phrase}

.
.
.
.
.
.
.
.
.
.

Mi solución:

def count_letters(phrase):
  counts = {}

  for letter in phrase:
    if letter not in counts:
      counts[letter] = 1
    else:
      counts[letter] += 1

  return counts

Este es mi ejemplo:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def count_letters(phrase):
  # Tu código aquí 👈
  letters = {}
  for i in range(len(phrase)):
    if phrase[i] in letters:
      letters[phrase[i]] += 1
    else:
      letters[phrase[i]] = 1
  return letters

def count_letters(phrase):
  rta = {}
  
  for letra in phrase:
    if letra in rta:
      rta[letra] += 1
    else:
      rta[letra] = 1
  return rta
  


response = count_letters("Hola mundo")
print(response)

No se porque cuando uso mis variables en español le super entiendo y se me hace más fácil

.
.
.
.
.

def contador_de_letras(cadena_de_texto):
  dict_letras = {} # aquí nos crea el dict

  for letra in cadena_de_texto:
    if letra in dict_letras:
      # aqui indice_de_letra va a apuntar al indice 1, luego al 2, 3, 4...
      dict_letras[letra] += 1

    else:
      # aqui como al principio es 0 
      dict_letras[letra] = 1

  return dict_letras

respuesta = contador_de_letras("Hola Mundo")
print("\n Diccionario en formato fila: \n")
print(respuesta)

print("\n en formato columna: \n")
for llave, valor in respuesta.items():

  print(llave, "=>", valor)

~/python-reto21dias$ python 17_count_letters.py

Diccionario en formato fila:

{‘H’: 1, ‘o’: 2, ‘l’: 1, ‘a’: 1, ’ ': 1, ‘M’: 1, ‘u’: 1, ‘n’: 1, ‘d’: 1}

en formato columna:

H => 1
o => 2
l => 1
a => 1
=> 1
M => 1
u => 1
n => 1
d => 1
~/python-reto21dias$

def count_letters(phrase):

    phrase_dic = {}

    for letter in phrase:
        phrase_dic[letter] = phrase_dic.get(letter, 0) + 1

    return phrase_dic
    pass

Esta estructura no la conozco, tendré que seguir con las clases de Python

Mi aporte

.
.
.
.
.

def count_letters(phrase):
    letras = [letra for letra in phrase]
    cant_letra = {}
    
    for letra in letras:

        if letra not in cant_letra:
            cant_letra[letra] = 0

        cant_letra[letra] += 1
    
    resultado = cant_letra

    return resultado
    pass


resultado = count_letters('Hola MundoH')
print(resultado) 

Dict comprehension es un camino de ida… súper legible y fácil de implementar

.
.
.
.
.
.
.
.
.
.

.

def count_letters(phrase):
  dict_letters = {letter:phrase.count(letter) for letter in phrase }
  return dict_letters

def count_letters(phrase):
  phrase = list(phrase)
  contador_letras = {}

  for letter in phrase:
    contar = phrase.count(letter)
    contador_letras[letter] = contar
  return contador_letras

# EJECUCIÓN
resultado = count_letters('Hola Mundo')
for clave, valor in resultado.items():
  print(f'{clave}: {valor}') 

Esta la recuerdo de una clase del segundo curso que nos recomendaron 😄

def count_letters(phrase):
  return {c: phrase.count(c) for c in phrase}

Estan cheveres los ejercicios

def count_letters(phrase):
  return {
    letter: phrase.count(letter) for letter in phrase
  }

print(count_letters("Hola mundo"))

Aqui mi solucion importando el modulo collections
.
.
.
.
.
.
.

from collections import Counter

def count_letters(phrase):
  # Tu código aquí 👈
  return dict(Counter(phrase))

Mi solucion:
*
*
*
*
*
*
*
*
*

def count_letters(phrase):
  # Tu código aquí 👈
  list_letters = {}
  for letter in phrase:
    if letter in list_letters:
      list_letters[letter] = list_letters[letter] +1
    else:
      list_letters[letter]=1  
  pass
  return list_letters

def count_letters(phrase):
  diccionario ={}
  for i in phrase:
      if i not in diccionario.keys():
          diccionario[i]=1
      else:
          diccionario[i]=diccionario[i]+1
  return diccionario

–

–

def count_letters(phrase):
  # Tu código aquí 👈
  return {f'{letter}':phrase.count(letter) for letter in phrase}

o
o
o
o
o
o

def count_letters(phrase):
  diccionario = {}
  for letra in phrase:
    if letra in diccionario:
      diccionario[letra] += 1
    else:
      diccionario[letra] = 1              
   
  return diccionario
  
print(count_letters("Hola mundo"))  

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

def count_letters(phrase):
  result = {}
  for letter in phrase:
    print(letter)
    if letter in result:
      result[letter] += 1
    else:
      result[letter] = 1
  return result

*
*
*
*
*
*
*
*
*

Es muy parecido al ejercicio anterior, pero más sencillo. Quería hacer una pequeña observación, en el nombre de la función. Creo que debió ser “count_characters”, ya que en realidad estamos haciendo un conteo de los diferentes caracteres que hay dentro del array 😃. Solamente es una cosita que quería comentar y ver si aporta. Después de mucho texto, dejo mi código jeje, espero que les sirva:

def count_letters(phrase):
  returning_dictionary = {}

  for character in phrase:
    if not (character in returning_dictionary):
      returning_dictionary.update({
        character: 1
      })
    else:
      returning_dictionary[character] += 1
  
  return returning_dictionary 

.
.
.
.
.

def count_letters(phrase):
  # Tu código aquí 👈
  counter = {}
  for letter in phrase:
    if letter in counter:
      counter[letter] += 1
    else:
      counter[letter] = 1 
  return counter