Vous pouvez obtenir le mot le plus long d'une liste de mots avec max () et en fournissant une fonction-clé de len .

Vous pouvez créer un autre bucket pour les mots "vides" et triez tous vos mots dans les seaux en utilisant une boucle for et en les indexant dans vos seaux avec len(word):

[None, ['1'], ['10'], ['100', 'out'], ['1000', 'this', 'work'], ['10000'], 
       ['100000', 'should'], ['1000000', 'somehow'], ['10000000'], 
       ['100000000'], ['1000000000']]

Sortie:

# create some demo strings and add some other words
words = [ str(10**k) for k in range(10)]
words.extend(["this","should","work","out","somehow"])

print(words)  # ['1', '10', '100', '1000', '10000', '100000', '1000000', '10000000',
              #  '100000000', '1000000000', 'this', 'should', 'work', 'out', 'somehow']

longest = len(max(words,key=len)) # get the length of the longest word

# create a empty bucket for "" and one bucket for length 1 up to longest
bins = [None] + [ [] for _ in range(longest+1)]  

# loop over words and put then in the bin at index len(word)
for w in words:
    bins[len(w)].append(w)

print(bins)

Doku:

• max (iterable, key = len) li >
• len ()
• range ()

buckets = [0] * longest # cela fera une liste de la taille la plus longue

Ensuite, faites une liste dans chaque élément et j'utilise le premier élément de la liste pour garder un nombre de ce compartiment.

pour i dans la plage (la plus longue): buckets [i] = [0]

Ensuite, vous devez ajouter les mots aux buckets.

pour L en mots: buckets [len (L)] [0] + = 1 # augmentation du nombre de ce bucket buckets [len (L)]. append (L) # Ajout du mot à ce bucket

Voici un exemple:

longest = 10
words = ['this', 'that', 'foremost']
buckets = [0] * longest # this will make a list of longest size 
for i in range(longest):
   buckets[i] = [0]
for L in words:
   buckets[len(L)][0] += 1 # increasing the count of that bucket
   buckets[len(L)].append(L) # Adding the word to that bucket 

Pour accéder à l'un des comptages, il n'y a que buckets [number] [0] et pour accéder à tous les mots, vous bouclez ce compte en commençant par buckets [number] [1] code >.

Comme je l'ai déjà mentionné dans un commentaire, j'ai utilisé un dictionnaire pour résoudre ce problème.

Ici, vous n'avez pas besoin de vous soucier de créer une liste vide en utilisant une fonction externe car nous ne connaissons pas la longueur réelle.

Vous pouvez donc essayer comme ça.

Vous pouvez visiter https://rextester.com/ZQKA28350 pour exécuter le code en ligne.

def add_words_to_bucket(words): 
    d = {}

    for word in words: 
        l = len(word)
        if l in d: 
            d[l].append(word) 
        else: 
            i = 0
            while l >= 0 and not l in d:
                if not i: 
                    d[l] = [word]
                else: 
                    d[l] = []
                l = l - 1
                i += 1
    return d

def get_as_list(d): 
    bucket = [d[i] for i in range(0, len(d))]
    return bucket


words = ["a",  "git", "go", "py", "java", "paper", "ruby", "r"]
d = add_words_to_bucket(words) 
bucket = get_as_list(d)
print(d) # {0: [], 1: ['a', 'r'], 2: ['go', 'py'], 3: ['git'], 4: ['java', 'ruby'], 5: ['paper']}
print(bucket) # [[], ['a', 'r'], ['go', 'py'], ['git'], ['java', 'ruby'], ['paper']]


words2 = ["a",  "git", "go", "py", "", "java", "paper", "ruby", "r","TheIpMan", ""]
d2 = add_words_to_bucket(words2)
bucket2 = get_as_list(d2)
print(d2) # {0: ['', ''], 1: ['a', 'r'], 2: ['go', 'py'], 3: ['git'], 4: ['java', 'ruby'], 5: ['paper'], 6: [], 7: [], 8: ['TheIpMan']}
print(bucket2) # [['', ''], ['a', 'r'], ['go', 'py'], ['git'], ['java', 'ruby'], ['paper'], [], [], ['TheIpMan']]

Cela devrait faire l'affaire:

>>>words = ['hi', 'my', 'friend', 'how', 'are', 'you']
>>>bucket_words_by_length(words)
[[], [], ['my', 'hi'], ['you', 'how', 'are'], [], [], ['friend']]

Par exemple,

def bucket_words_by_length(words):
    d = {}
    [d.setdefault(len(word), []).append(word) for word in words]
    buckets = [d.get(k, []) for k in range(max(d.keys()) + 1)]
    return buckets

Cette implémentation construit d'abord un dictionnaire avec des longueurs comme clés et une liste des mots de longueur correspondante comme ses valeurs. Ensuite, il parcourt toutes les longueurs en produisant une liste vide si aucun mot n'est de cette longueur et en produisant autrement la liste de mots.