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