Problème de code césar

Voila pour mon épreuve de bac, en ISN (Informatique et Sciences du Numériques), j'ai du créer un programme avec python: Le code césar. Il consiste à coder un mot en décalant chaque lettres dans l'alphabet avec un décalage donné. Par exemple a devient d avec un décalage de 3, coco devient frfr avec le meme décalage.
Bref, mon programme décale les lettres mais je n'arrive pas à en faire un mot, mes lettres sont indépendantes. Pouvez-vous m'aidez ?

minuscules = 'abcdefghijklmnopqrstuvwxyz'
MSG=input('message à coder: ')
print(len(MSG))
dcl=int(input('nombre de décalage: '))
n=0


while n < len(MSG):
toto=str(MSG)
popo=str(minuscules)
lettr=toto[n]
lettre=minuscules.index(lettr)+dcl
rempl=popo[lettre]
print(rempl)
n=n+1

print(MSG)

tu y es presque, tu calcul à chaque foi la nouvelle lettre que tu stock dans "rempl". Pour retourner le nouveau mot il te suffit soit de stocker ces lettres:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

minuscules = 'abcdefghijklmnopqrstuvwxyz' MSG=input('message à coder: ') print(len(MSG)) dcl=int(input('nombre de décalage: ')) n=0   toto=str(MSG) popo=str(minuscules) nouveauMot = ""   while n < len(MSG): lettr=toto[n] lettre=minuscules.index(lettr)+dcl rempl=popo[lettre] nouveauMot += rempl n=n+1   print(MSG) print(nouveauMot)

---

Salut,

Si vous dites "decaler mot" c'est construire un nouveau mot en décalant chaque lettre, il serait bon de définir deux fonctions:
decaler_mot(mot, n) et decaler_lettre(lettre, n).
On écrira simplement:

Code:

---

1 2 3 4 5

def decaler_mot(mot, n): nouveau_mot = '' for c in mot: nouveau_mot += decaler_lettre(c, n) return nouveau_mot

---

Pour decaler_lettre, la difficulté sera la gestion des dernières lettres.
Pour mettre au point les instructions de cette fonctions, vous pouvez utiliser la console:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

>>> LETTRES = 'abc' >>> c = 'a' >>> n = 1 >>> ix = LETTRES.index(c) >>> LETTRES[ix + n] 'b' >>> c = 'c' >>> ix = LETTRES.index(c) >>> LETTRES[ix + n] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: string index out of range

---

Il faut "decaler" modulo la longueur de LETTRES:

Code:

---

1 2 3 4

>>> ix = LETTRES.index(c) >>> ix = (ix + n) % len(LETTRES) >>> LETTRES[ix] 'a'

---

Une fois que vous pensez avoir compris la suite d'instructions, vous pouvez l'emballer dans la fonction decaler_lettre:

Code:

---

1 2 3 4 5 6

>>> def decaler_lettre(lettre, n): ... ix = LETTRES.index(lettre) ... ix = (ix + n) % len(LETTRES) ... return LETTRES[ix] ... >>>

---

Puis vous testez:

Code:

---

1 2 3 4 5

>>> decaler_lettre('a', 1) 'b' >>> decaler_lettre('c', 1) 'a' >>>

---

Et maintenant on peut regarder ce que ca fait avec des mots:

Code:

---

1 2 3

>>> decaler_mot('abc', 1) 'bca' >>>

---

et ajouter la saisie d'un mot par l'utilisateur.
C'est pas complique.
Il suffit juste de découper le problème en petits bouts qu'on pourra assembler.

- W

Juste pour le fun, il y a même moyen de le faire en une ligne. Il faut bien dire que ce n'est pas très lisible :calim2:

Code:

---

1 2 3 4 5 6 7

decale_mot = lambda mot, dec, minuscules: "".join([minuscules[(minuscules.index(lettre) + decalage) % len(minuscules)] for lettre in mot])   print decale_mot("coco", 3, 'abcdefghijklmnopqrstuvwxyz')   ## frfr

---

Pire encore, dans le genre illisible, on peut faire la même chose en s'appuyant sur 'ord' (qui retourne un entier représentant un caractère) et 'chr' (qui retourne un caractère représentant un entier). Avantage: on ne doit même pas passer la liste de minuscules en argument. Un grand pas pour l'humanité :aie:

Code:

---

1 2 3 4

decale_mot = lambda mot, dec: "".join([chr((((ord(lettre) + dec) - ord("a")) % (ord("z") - ord("a") + 1)) + ord("a")) for lettre in mot])   print decale_mot("coco", 3)

---

C'est aussi pythonique qu'un crocodile :weird:

Salut,

Tout dépend de ce qu'on souhaite apprendre: "programmer" en général ou faire un pari du style "le plus vite", le plus court", "le plus pythonique". Sur un vélo, çà donnerait sans les mains, sans les pieds,... mais au début, c'est plus laborieux, moins ludique et attention aux bobos si on tombe.

Une moins mauvaise solution est d'utiliser maketrans:

Code:

---

1 2 3 4 5 6 7 8 9

>>> from string import maketrans >>> >>> encode = lambda w, n, L: w.translate(maketrans(L, L[n:]+L[:n])) >>> alphabet = 'abc' >>> print encode('abc', 1, alphabet) bca >>> print encode('bca', 1, alphabet) cab >>>

---

Mais c'est un autre algo. que l'on trouvera facilement lorsqu’après avoir appris les "bases", on comprendra l'intérêt d'aller farfouiller dans les possibilités des librairies "standards".
- W

Merci à tout le monde,
mais vu qu'on doit utilisé que des fonction que nous avons déjà vu en cours,
autant dire (str, index ...), je vais du coup utilisé la solution de Viand0x, qui me parait la plus simple,
par rapport a ce que me demande mes professeurs.
En tout cas, merci à tous pour vos réponses :)

La solution de Viand0x est en effet basée sur la tienne mais elle est incorrecte. Tiens compte de ce que signalait wiztricks et essaye avec "zoo" par exemple, ou"xylophone" et tu auras un "IndexError: string index out of range".

En d'autres termes, si tu décales par exemple "y" de 2, "y" se trouvant à l'index 24 de la liste tu obtiendras un index égale à 24 + 2 c'est à dire 26, un index qui n'existe pas dans la liste des minuscules qui comporte 26 éléments indexés de 0 à 25 (26 est donc "out of range").

La solution la plus directe est de faire (24 + 2) % 26 , ce qui donne 0 donc la lettre "a".

Tu peux obtenir le même résultat avec une fonction du style:

Code:

---

1 2 3 4 5 6 7 8

def get_index(i): while i >= 26: i = i - 26 return i   print get_index(26) ##0

---

Merci Delbor, je me suis inspiré de c que tu m'a expliquer pour faire la meme chose avec quelque chose de ultra basique, qui fasse pas cramer, quand je passerais les oraux. :p
Cependant il me reste un problème j'aimerait que l'espace se conserve, et donc ne pas être obliger qu'il se décale en devant l'intégrer dans ma liste alphabet ( et donc avoir 27 lettre. Donc si je décale "lait chaud" de 1 il me donne "mbjq dibve" et non "mbjqadibve"

minuscules = 'abcdefghijklmnopqrstuvwxyz'
MSG=input('message à coder: ')
print(len(MSG))
dcl=int(input('nombre de décalage: '))
if dcl > 25 :
dcl= dcl%26
else :
dcl=dcl
print(dcl)
n=0

toto=str(MSG)
popo=str(minuscules)
nouveauMot = ""

while n < len(MSG):
lettr=toto[n]
lettre=minuscules.index(lettr)+dcl
if lettre > 25:
lettre=lettre - 26
else :
lettre=lettre
rempl=popo[lettre]
nouveauMot += rempl
n=n+1

print(nouveauMot)

En effet j'avais simplement essayé sans voir le bug du fait de mes choix de mots et de décalage...

Pour conclure ces nombreuses propositions, une solution simple proche de ta proposition devient simplement:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

minuscules = 'abcdefghijklmnopqrstuvwxyz' MSG=input('message à coder: ') print(len(MSG)) dcl=int(input('nombre de décalage: ')) n=0   toto=str(MSG) popo=str(minuscules) nouveauMot = ""   while n < len(MSG): lettr=toto[n] lettre=(minuscules.index(lettr)+dcl)%26 rempl=popo[lettre] nouveauMot += rempl n=n+1   print(MSG) print(nouveauMot)

---

Avec l'implantation du %26 de Deldor =)

Si tu veux conserver les espaces teste simplement avant le traitement si ta lettre est un espace...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

minuscules = 'abcdefghijklmnopqrstuvwxyz' MSG=input('message à coder: ') print(len(MSG)) dcl=int(input('nombre de décalage: ')) n=0   toto=str(MSG) popo=str(minuscules) nouveauMot = ""   while n < len(MSG): lettr=toto[n] rempl = ' ' if lettr != ' ': lettre=(minuscules.index(lettr)+dcl)%26 rempl=popo[lettre] nouveauMot += rempl n=n+1   print(MSG) print(nouveauMot)

---

J'ajouterais que 'toto' et 'popo' sont inutiles. Tu peux faire la même chose sur MSG et minuscules directement.

Et en python on utilise plutôt "for ... in ..." que "while".

Ce qui donnerait quelque chose du genre:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

minuscules = 'abcdefghijklmnopqrstuvwxyz' message = input('message à coder: ') decalage = int(input('nombre de décalage: '))   nouveau_mot = ""   for lettre in message: if lettre in minuscules: # Si le lettre est dans la liste des minuscules, on décale index_nouvelle_lettre = (minuscules.index(lettre) + decalage) % 26 remplacement = minuscules[index_nouvelle_lettre] else: # La lettre n'est pas dans la liste des minuscules (cas de " " ou de ","), on ne fait rien remplacement = lettre   nouveau_mot += remplacement   print(message) print(nouveauMot)

---