trie en python

Question

J'essaie d'apprendre python et de bien m'aligner sur les algorithmes. C'est ma première langue.

par exemple: prendre « bagages » et le tri dans « aabeggg »

string = "baggage" 
count = [0] * len(string) 

for x in string: 
    num_value = ord(x) 
    count[num_value] += 1 

Je pense que le début est un ci-dessus ... mais je ne suis pas vraiment comment s'y prendre sorte à ce sujet.

Answer 1

collections.Counter est un excellent moyen de résoudre ce problème, mais voici un moyen d'obtenir vous un peu plus loin dans la direction que vous vous dirigez

string = "baggage" 
count = [0] * 256 # This should be big enough to hold counters for every 8 bit character 

for x in string: 
    num_value = ord(x) 
    count[num_value] += 1 

for i in range(256): # loop through all the possible 8 numbers 
    if count[i]: 
     print chr(i)*count[i] 

# you can join them all back into a string like this 
newstr = ''.join(chr(i)*c for i,c in enumerate(count)) 

Answer 2

Jetons un coup d'œil à votre code ici.

string = "baggage" 
count = [0] * len(string) 
# count is now [0,0,0,0,0,0,0] 

for x in string: 
    num_value = ord(x) 
    # ord(x) gives you the ascii number value of a character x 
    # So for example ord('b') = 98 
    count[num_value] += 1 
    # error here since count[98] isn't set. 

Pablo vous a donné une solution rapide. J'en écrirai un en utilisant un dictionnaire qui pourrait être plus explicite.

string = "baggage" 
count = {} 

for c in string: 
    if c in count: 
     count[c] += 1 
    else: 
     count[c] = 1 

print ''.join(count[c]*c for c in sorted(count)) 

Answer 3

Utilisez un collections.Counter:

from collections import Counter 
string = 'baggage' 
c = Counter(string) 
result = ''.join(c[x]*x for x in sorted(c.keys())) 

Il fonctionne comme suit:

• Counter fait exactement ce que vous essayez d'atteindre avec count[num_value] += 1
• sorted(c.keys()) vous donne les personnages triés ordre
• c[x]*x est une chaîne composée de c[x] copies du charbon x
• ''.join(...) rejoint chacune des chaînes résultant en une seule