changement Caesar Cipher par deux lettres

Question

def main(): 

    cc = (input("Enter Message to Encrypt\n"))#user input 

    shift = int(2) #shift length 

    a=["a","b","c","d","e","f","g","h","i","j","k","l", 
     "m","n","o","p","q","r","s","t","u","v","w","x","y","z"] #reference list 

    newa={} #new shifted reference list 

    for i in range (0,len(a)): 
     newa [a[i]]=a[(i+shift)%len(a)] 
     #adds shifted 2 alaphabet into newalaphabet 
     #% moodulus used to wrap 

     for i in cc: #iterates through cc 
      if i in a: 
        a[i]=cc[i] 
        a[i]=newa[i] 

main() 

donc j'ai besoin d'entrée de l'utilisateur #CC

le changement doit être deux

J'ai utilisé une liste alphabétique

puis décaler l'alphabet par deux pour créer Newa

mais je ne sais pas comment appliquer le nouvel alphabet à l'entrée de mon utilisateur

Answer 1

Itérer à travers la chaîne cc et remplacer tous les alphabets en utilisant la méthode get de newa. Les caractères qui ne sont pas dans le dictionnaire sont laissés en l'état, en les faisant passer par défaut à newa.get lorsque la clé est manquante: peut être utilisé

newa = {} 
for i, x in enumerate(a): 
    newa[x] = a[(i+shift) % len(a)] 

encrypted_text = ''.join(newa.get(i, i) for i in cc) 

Python builtin enumerate en place de range(len(a)) dans ce cas où vous avez besoin de articles en a et leurs indices respectifs.

Answer 2

Utiliser la cartographie pour chaque char, puis joindre à nouveau pour créer le message chiffré:

''.join(map(lambda x: chr((ord(x) - 97 + shift) % 26 + 97) if x in alphabet else x, cc.lower())) 

intégrer comme ça:

import string 
alphabet = string.ascii_lowercase 
cc = input('Enter string to encode: ') 
shift = 2 # could be any number 

encrypted = ''.join(map(lambda x: chr((ord(x) - 97 + shift) % 26 + 97) if x in alphabet else x, cc.lower())) 

cc.lower() pour les lettres à tous les mêmes cas (à carte à l'aide constante ord)

chr((ord(x) - 97 + shift) % 26 + 97):

• obtenir la valeur du nombre moins 97 (0 pour a, 1 pour b, etc.).
• appliquer le décalage (a devient c, etc.).
• moduler par 26 pour empêcher des lettres comme z de dépasser (25 + 2 = 27, 27% 26 = 1 = b).
• ajouter 97 pour porter la lettre à la norme ascii (97 pour a, 98 pour b, etc.) couverture

if x in alphabet else x des signes qui ne sont pas lettre (si vous voulez ignorer utiliser les espaces et la ponctuation if x in alphabet else '' au lieu).

Answer 3

Utilisez un dictionnaire pour carte entrées aux sorties

shifted_a = a[-shift:] + a[:-shift] 
cipher = {a[i]: shifted_a[i] for i in range(len(a))} 
output = ''.join(cipher[char] for char in cc) 

Answer 4

Je voudrais juste construire la table de transition et l'utiliser pour décoder la chaîne.

import string 
shift = 2 
letters = string.ascii_lowercase + string.ascii_uppercase 
transtable = str.maketrans({letters[i]: letters[(i + shift) % len(letters)] 
          for i in range(len(letters))}) 

cc = input('Enter string to encode: ') 
print(cc.translate(transtable)) 

Answer 5

Je vais jeter ma solution là-dedans. Il devrait être assez clair comment cela fonctionne ...

import string 

index_lookup = {letter: index for index, letter in enumerate(string.ascii_lowercase)} 

def caesar_letter(l, shift=2): 
    new_index = index_lookup[l] + shift 
    return string.ascii_lowercase[new_index % len(index_lookup)] 

def caesar_word(s): 
    return ''.join([caesar_letter(letter) for letter in s]) 

Je pense que ce qui précède est mieux pour une meilleure lisibilité, mais si vous êtes opposé aux importations ...

index_lookup = {chr(idx): idx - ord('a') for idx in range(ord('a'), ord('z')+1)} 

...

In [5]: caesar_word('abcdefghijklmnopqrstuvwxyz') 
Out[5]: 'cdefghijklmnopqrstuvwxyzab'