Il te suffit de créer un dict qui pour chaque lettre associe le nombre de fois où elle est répétée. Puis par la suite tu itères sur ton dict et tu supprimes les lettres dont dict[lettre] >= n .
Edit : il y a mieux à faire que ce que j'ai proposé. Je pensais que tu parlais de lettres non consécutives
Il te suffit de créer un dict qui pour chaque lettre associe le nombre de fois où elle est répétée. Puis par la suite tu itères sur ton dict et tu supprimes les lettres dont dict[lettre] >= n .
C'est ça que je ne sais pas faire justement... un exemple ?
comment ferais tu pour enlever une seule lettre dans ta chaine ?
je ferai une boucle pour vérifier chaque lettre une par une et réécrire la chaine de caractère sans ces lettres.
def suppression(c, s):
"""str * str -> str
Hypothèse: len(c) == 1
retourne la sous-chaîne de s dans laquelle toutes
les occurrences du caractère c ont été supprimées."""
# r : str
r = '' # la chaîne résultat
# d : str (caractère courant)
for d in s:
if d != c:
r = r + d # ne pas supprimer, donc ajouter au résultat
# sinon ne rien faire (supprimer) car on a trouvé une occurrence de c
return r
La solution la plus simple serait d'itérer sur tous les caractères de ta chaîne, pour les insérer dans une nouvelle. Tout en conservant une variable contenant le caractère précédent : ainsi, si le caractère de l'itération est égal au caractère précédent, il n'est pas ajouté à la nouvelle chaîne.
La solution la plus simple serait d'itérer sur tous les caractères de ta chaîne, pour les insérer dans une nouvelle. Tout en conservant une variable contenant le caractère précédent : ainsi, si le caractère de l'itération est égal au caractère précédent, il n'est pas ajouté à la nouvelle chaîne.
Peut-être que je ne comprends pas bien le terme itération, mais il ne faut le faire que si le caractère ne se répète que n fois, argument donné au départ. Donc ta solution de marche pas ?
def foo(m, n) :
new = ""
i = 0
while i < len(m) :
if len(set(m[i:i+n])) == 1 :
new += m[i]
i += n
else :
new += m[i]
i += 1
return new
Par contre je trouve ça moche. Je préfère nettement la solution avec la regex.
Edit : En plus je viens de me rendre compte que ça ne marche comme il faut en fin de string. A revoir donc.
Redit :
def foo(m, n) :
new = ""
i = 0
while i < len(m) :
if i+n < len(m)+1 and len(set(m[i:i+n])) == 1 :
new += m[i]
i += n
else :
new += m[i]
i += 1
return new
def foo(m, n) :
new = ""
i = 0
while i < len(m) :
if len(set(m[i:i+n])) == 1 :
new += m[i]
i += n
else :
new += m[i]
i += 1
return new
Par contre je trouve ça moche. Je préfère nettement la solution avec la regex.
Edit : En plus je viens de me rendre compte que ça ne marche comme il faut en fin de string. A revoir donc.
Redit :
def foo(m, n) :
new = ""
i = 0
while i < len(m) :
if i+n < len(m)+1 and len(set(m[i:i+n])) == 1 :
new += m[i]
i += n
else :
new += m[i]
i += 1
return new
- Edité par Jevanni il y a environ 1 heure
Super ça marche, je vais étudier ça calmement demain, merci !
Il est important de pouvoir morceler ton problème en sous-problèmes. C'est une compétence capitale qui te servira en programmation mais dans d'autres disciplines aussi.
Pour résoudre le problème, tu dois pouvoir itérer sur chaque lettre de la chaîne de caractère. Itérer veut simplement dire prendre tour à tour un caractère de la chaîne de caractères. Lorsque tu as un caractère, tu aimerais compter combien de fois ce caractère se répète à partir de la position où tu te trouves dans la chaîne. Clairement ce n'est pas quelque chose de trivial à faire, donc c'est un sous-problème. Et généralement qui dit sous-problème dit que la solution à ce sous-problème pourrait s'écrire sous la forme d'une fonction. Appelons cette fonction repetition. On se demande ce qu'elle doit faire. Idéalement on lui donne notre chaîne, la position où on se trouve dans la chaîne et le nombre de répétitions désirées. En retour la fonction nous dit juste s'il y a répétition ou pas, autrement dit elle retourne juste True ou False. Lorsque je fabrique cette fonction, dans ma tête je garde à l'esprit l'endroit d'où j'appellerai ma fonction, et je me demande ce qu'elle devrait faire pour me faciliter le travail. Une autre manière de voir la chose est de se dire : imaginons que cette fonction existe déjà. Comment j'imagine l'appeler et qu'est-ce que je m'imagine qu'elle retourne pour que ça m'arrange. Comme expliqué plus haut, on est dans notre chaîne de caractères, on considère un caractère en particulier (et donc on se trouve à un endroit précis de la chaîne déterminé par un indice unique) et on voudrait savoir si oui on non ce caractère continue à se répéter X fois (5 fois dans ton exemple).
On a ainsi déterminé que notre fonction aurait la forme repetition(mot, position, nbre_repetition). Donc on oublie 2 secondes notre problème global et on attaque le sous problème. Avec le mot coooool si je suis à l'indice 1 (le premier o) et je cherche 5 répétitions, ma fonction doit me retourner True. Je te laisse tenter de résoudre ce problème. Il semble évident qu'il va falloir regarder ce qui se trouve comme caractère en position mot[position] et qu'il va falloir comparer ça avec les lettres suivantes mot[position+1], ..., mot[position+4] . Aussi il faudra s'assurer qu'il existe bien des lettres à ces positions là. Imagine que tu considères la dernière lettre de la chaîne. Il est évident qu'elle ne peut pas se répéter X fois vu que c'est la dernière.
Revenons à notre problème global. Donc on itère sur chaque caractère. On vérifie s'il se répète X fois. Si oui, que faire ? Si non, que faire ? Voyons voir...
S'il se répète on veut conserver le premier caractère et sauter les caractères suivants de répétition. Autrement dit on voudra faire avancer notre indice dans la chaine de nbre_repetition. En prenant l'exemple de coooool, si on a notre indice sur le premier o, donc il vaut 1 et qu'on sait que le o se répète 5 fois, on veut maintenant se placer sur le l. Son indice est 6 (on part de 0 !) Pour aller de 1 à 6 on a bien ajouté 5, qui est le nombre de répétitions recherchées.
S'il ne se répète pas, on veut conserver ce caractère et passer simplement au suivant.
Donc j'observe que dans les deux cas, je conserve le caractère considéré. Ca veut dire que je le fais quelque soit le résultat de la fonction repetition. Donc on conserver le caractère en premier, et ensuite on appelle notre fonction repetition. Selon qu'elle retoure True ou False, on vient de décrire ce qu'on fera.
Merci beaucoup Dan737, j'ai essayé de suivre ton plan sans créer de fonction supplémentaire, je ne suis pas loin, un conseil ?
def debegaie(s, n):
""" str * int -> str
hypothèse : (len(s) > 0) and (n > 0)
"""
# motfinal : str vide
motfinal = ''
# l : (int) nombre de caractères de s
l = len(s)
temp = 0
#Itération
for i in range(0, (l-n)):
compteur = 1
motfinal = motfinal + s[i + temp]
print (motfinal)
# Vérification si les n lettres suivantes sont identiques
for z in range(1, n):
if s[i] != s[i+z]:
compteur = compteur
else:
compteur = compteur + 1
if compteur == n:
temp = n - 1
print('temp',temp)
else:
temp = 0
print('temp',temp)
return motfinal
Supprimer les caractères répétés
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique