Discussion :

[azer136]

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)

[Viand0x]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[wiztricks]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Delbor]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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é

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[wiztricks]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[azer136]

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

[Delbor]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[azer136]

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)

[Viand0x]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[Delbor]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)