Nicolas Alpargatero
EstudianteJulio Cardenas
EstudianteFrancisco Jesús Eslava Fernández
EstudianteFernando Velasco
EstudianteEduardo Peña Ramos
EstudianteMaga Hernandez
EstudianteEdwin Absalón Martinez Moreno
EstudianteFrancisco Jesús Eslava Fernández
EstudianteCarmen Lucia Castro Ruiz
EstudianteMaga Hernandez
EstudianteEmilio Sala
EstudianteOrlando Sánchez
EstudianteYoné Rocha
EstudianteAndres Caro
EstudianteErick Infante
EstudianteJuan Diego
EstudianteFernando Lavao Orjuela
EstudianteEmmanuel Paiva
EstudianteDiego Cruz
EstudianteFrancisco Pin
EstudianteDaniel Fernando Cjuno Lezama
EstudianteDender Adrian Pernia Valero
EstudianteMarcos Bonifasi
EstudianteEnrique Barrera
EstudianteDespués de solucionarlo lo simplifique a un a línea con dict comprehensions.
Muy elegante. Me gusto!!!
Muy bien, básicamente hice lo mismo pero en 2 lineas
No use dictionary comprehensions:
def count_letters(phrase): d = {} for i in phrase: d[i] = d.get(i, 0) + 1 return d
.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²).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.
Gracias por la aclaración de ambos métodos. Saludos.
y como se mide ese "complejidad", por la cantidad de código?
Despues de los dolores de cabeza, éste es un alivio.
def count_letters(phrase): contarfrecuencia = {i: phrase.count(i) for i in phrase} return (contarfrecuencia)
def count_letters(phrase):
repeticiones = {}
for i in phrase:
if i not in repeticiones:
repeticiones[i] = phrase.count(i)
return repeticiones
i did it again...i am so happy!!
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"))
word = "Hola mundo"
def count_letters(phrase):
count_letters = {}
for letter in phrase:
if letter in count_letters:
count_letters[letter] += 1
else:
count_letters[letter] = 1
return count_letters
print(count_letters(word))
def count_letters(phrase): output = {} for letter in phrase: if letter in output: output[letter] += 1 else: output[letter] = 1 return output
def count_letters(phrase): nuevo_diccionario = {} for letra in phrase: if letra in nuevo_diccionario: nuevo_diccionario[letra] += 1 else: nuevo_diccionario[letra] = 1 return nuevo_diccionario ```def count\_letters(phrase): nuevo\_diccionario = {} for letra in phrase: if letra in nuevo\_diccionario: nuevo\_diccionario\[letra] += 1 else: nuevo\_diccionario\[letra] = 1 return nuevo\_diccionario
Learning Python
def count_letters(phrase): # definimos la funcion letter_count = {} for char in phrase:#Recorrer cada carácter del texto recorre uno a uno if char in letter_count:# Contar cada letra (con condicional) letter_count[char] += 1 else: letter_count[char] = 1 return letter_count # Retornamos el diccionario final
Mi solución
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
Hola comparto mi solucion:
def count_letters(phrase): arreglo_letras = [] resultado = {} for l in phrase: arreglo_letras.append(l) for n in arreglo_letras: resultado[n] = arreglo_letras.count(n) return resultado ```def count\_letters(phrase): arreglo\_letras = \[] resultado = {} for l in phrase: arreglo\_letras.append(l) for n in arreglo\_letras: resultado\[n] = arreglo\_letras.count(n) return resultado
def count_letters(phrase): # Tu código aquí 👈 unique = list(dict.fromkeys(phrase)) conteo = {letra[0]: (tuple(phrase).count(letra)) for letra in unique} return conteo pass ```def count\_letters(phrase): # Tu código aquí 👈 unique = list(dict.fromkeys(phrase)) conteo = {letra\[0]: (tuple(phrase).count(letra)) for letra in unique} return conteo pass
Parece obvio pero no sabia que las claves no se podían duplicar en los diccionarios, a diferencia de las listas :(
Pero por otro lado ahora se me facilitan este tipo de tareas :)
Envío mi solución...
Hola, I just want to share the way I solved it
return {letter: phrase.count(letter) for letter in set([letter for letter in phrase])} ```return {letter: phrase.count(letter) for letter in set(\[letter for letter in phrase])}
al modo de la vieja escuela:
def count_letters(phrase): dict_out={} for character in phrase: if character not in dict_out: dict_out[character] = 1 else: dict_out[character] += 1 return dict_out