Essayez de créer un code de "décryptage" en Python

J'ai essayé de crypter p101-103 du deuxième volume avec Python. Tous cryptent BONJOUR.

1-1. Cryptage de translocation

Entrée
HELLO

s=input()
n=len(s)
l=[]
for i in range(n):
    l.append(str(bin(ord(s[i])))[2:])

m="".join(l)

odd=m[::2]
even=m[1::2]

num=len(even)

for j in range(num):
    print(even[j],end="")
    print(odd[j],end="")
print(odd[-1])

Sortie
01100010001010011001100011000110111

Commencez par convertir en ASCII. C'est correct avec ord (). Unicode et ASCII ont le même alphabet. Ouais.

Les nombres binaires sont difficiles à gérer, donc Si vous utilisez str () pour créer une chaîne de caractères, vous pouvez récupérer le numéro de chaque chiffre. Avec str (bin (ord (s [i]))) [2:], prenez le premier 0b.

Je me suis demandé comment échanger le premier numéro contre le deuxième numéro, J'ai essayé de le traiter qui semble être le problème d'AtCoder.

Il est divisé en nombres impairs et pairs et est émis en alternance.

Puisque impair a un caractère supplémentaire, seul impair [-1] est affiché à la fin. Si l'entrée est un nombre pair d'alphabets, je dois le changer à nouveau, Pour le moment, cette fois.

1-2. Décodage du type d'inversion

Maintenant, au contraire, essayez de renvoyer 01100010001010011001100011000110111 à HELLO.

Entrée
01100010001010011001100011000110111

s=input()
even=s[:-2:2]
odd=s[1::2]

l=[]
n=len(even)
for i in range(n):
    l.append(odd[i])
    l.append(even[i])
l.append(s[-1])

m="".join(l)

num=len(l)//7

for j in range(num):
    print(chr(int(m[7*j:7*(j+1)],2)),end="")

C'est fondamentalement l'opposé du cryptage, donc c'était toujours facile.

Je savais que int ('nombre en notation binaire', 2) était suffisant pour convertir un nombre binaire en un nombre décimal, donc je pouvais l'écrire simplement. Convertir les nombres et les chaînes binaires, octaux et hexadécimaux entre eux avec Python

2-1. Cryptage de translittération

Commencez par convertir le DAVID en code ASCII. 10001001000001101011010010011000100 C'est la clé.

Les règles de cryptage sont -Si chaque élément du texte brut et la clé sont identiques, le texte chiffré sera 0. -Si chaque élément du texte brut et la clé sont différents, le texte chiffré sera 1. C'est une somme logique exclusive (XOR).

Entrée
HELLO DAVID

s=input()
key=input()

n=len(s)

#Conversion ASCII
l_s=[]
l_k=[]

for i in range(n):
    l_s.append(str(bin(ord(s[i])))[2:])
    l_k.append(str(bin(ord(key[i])))[2:])
    
a_s="".join(l_s)
a_k="".join(l_k)

num=len(a_s)
cipher=[]

for j in range(num):
    if a_s[j]==a_k[j]:
        cipher.append("0")
    else:
        cipher.append("1")

print(*cipher,sep="")

Sortie
00011000000100001101000001010001011

2-2. Décodage du type d'inversion

Maintenant, inversement, déplacez 00011000000100001101000001010001011 vers BONJOUR à l'aide de la clé DAVID. Si le code et les éléments clés sont identiques, le texte brut sera 0, et s'ils sont différents, il sera 1. C'est la même chose que lors du cryptage.

Entrée
00011000000100001101000001010001011 DAVID

s=input()
key=input()

n=len(key)

#Convertir la clé en ASCII
l_k=[]

for i in range(n):
    l_k.append(str(bin(ord(key[i])))[2:])
    
k="".join(l_k)

num=len(s)
l_p=[]
for j in range(num):
    if s[j]==k[j]:
        l_p.append("0")
    else:
        l_p.append("1")

p="".join(l_p)

n_p=len(p)//7

for l in range(n_p):
    print(chr(int(p[7*l:7*(l+1)],2)),end="")

Sortie
HELLO