[Bouton d'alimentation - petite pratique quotidienne] 820. Le codage de compression de mots (python)

820. La compression de mot de codage

Liens Sujet: https://leetcode-cn.com/problems/short-encoding-of-words/
Difficulté: Moyenne

Titre description

Étant donné une liste de mots, cette liste sera codé comme un indice chaîne de S et une liste d'index A.

Par exemple, si la liste est ["time", "me", "bell"], nous pouvons être Exprimé en S = "time#bell#"et indexes = [0, 2, 5].

Pour chaque index, on peut indexer de la chaîne S en position pour commencer à lire la chaîne jusqu'à la « #fin », pour restaurer notre liste précédente des mots.

Ensuite, la longueur minimale de la chaîne à la réussite d'une liste de mots donnée pour l'encodage est combien?

Exemples

Entrée: mots = [ "Time", "Me", "cloche"]
Sortie: 10
Description: S = "# # Temps de Bell", index = [0, 2 ,. 5].

rapide

• 1 <= words.length <= 2000
• 1 <= mots [i] .length <= 7
• Chaque mot est en minuscule.

Le code échantillon

J'ai écrit des méthodes, en particulier la violence, bref, doit être trié par ordre décroissant en fonction de la longueur du mot, puis en comparant les lettres d'un mot par la fonction peut être atteint, mais il prend trop de temps, dépasse la limite.
Est donné ci - dessous en se référant à d' autres, l'idée est le même
problème violent résolution: mots en fonction de la longueur de mot du genre, de temps à traversal courte longueur de mot, si la chaîne cible peut être lu complètement le mot, le mot est jeté
complètement lu: la présence du mot sous - chaînes, et « # » à la fin
fonction

• la list.sort (CMP = None, Key = None, inversée = False)
  CMP - paramètres optionnels, le paramètre de tri méthode
  clé - Trier, un seul paramètre
  inverse - l' assemblage, par défaut False (croissant)

• str.find (str1, le début, fin)
  str1 - sous - chaînes
  commencent: fin - Regardez
  si str1 dans str, l' indice de rendement de str1, sinon dans -1

Ce qui suit est une référence à quelqu'un d'autre

class Solution:
    def minimumLengthEncoding(self, words: List[str]) -> int:
        words.sort(key = lambda x: len(x))          #按单词长度排序
        ans = ''                                    #目标字符串
        for i in range(len(words)-1, -1, -1):       #按单词长度从长到短遍历（逆序循环）
            tmp = ans.find(words[i])                #单词是否在目标字符串中，若存在，返回索引
            if tmp == -1:                           #单词不在目标字符串中，添加进去
                ans += words[i] + '#'
            else:                                   #单词在目标字符串中，判断能否完全读取
                x = ans[tmp:].index('#')            #获取单词后第一个“#”索引
                if ans[tmp:tmp+x] != words[i]:      #判断是否能够完全读取，若不能，添加单词
                    ans += words[i] + '#'
        return len(ans)                             #返回目标字符串长度

#参考自：
#作者：pumpkin_daytoy
#链接：https://leetcode-cn.com/problems/short-encoding-of-words/solution/python3-bao-li-qiu-jie-by-pumpkin_daytoy/

Ce qui suit est ma propre écriture (prend trop de temps au-delà de la limite)

class Solution:
    def minimumLengthEncoding(self, words: List[str]) -> int:
        #'''
        S = ''
        if len(words)==1:
            return len(words[0])+1
       

        for k in range(len(words)):
            for t in range(len(words))[k:]:
                if len(words[k])<len(words[t]):
                    temp = words[t]
                    words[t] = words[k]
                    words[k] = temp
        S = words[0] + '#'    
        indexes = [0]
        for word in words[1:]:
            i = 0
            flag = False
            j = 0
            while True:
                char = word[j]
                if char == S[i]:
                    if j == 0:
                        flag = True
                    i += 1
                    j += 1
                else:
                    if S[i] != word[0]:
                        i += 1
                    if flag == True:
                        j = 0
                        flag = False
                        # break
                if j == len(word):
                    if i <= len(S)-1:
                        indexes.append(i-j)
                        break
                elif j < len(word) and i == len(S)-1:
                    S = S + word + '#'
                    break
                # if j == len(word) or i == len(S):
                #     break
        return len(S)
        #'''