Versuchen Sie, in Python einen "Entschlüsselungs" -Code zu erstellen

Ich habe versucht, p101-103 des zweiten Volumes mit Python zu verschlüsseln. Alle verschlüsseln HALLO.

1-1. Translokationsverschlüsselung

Eingabe
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])

Ausgabe
01100010001010011001100011000110111

Konvertieren Sie zunächst in ASCII. Dies ist in Ordnung mit ord (). Unicode und ASCII haben das gleiche Alphabet. Ja.

Binärzahlen sind daher schwer zu handhaben Wenn Sie mit str () eine Zeichenfolge erstellen, können Sie die Nummer jeder Ziffer abrufen. Nehmen Sie mit str (bin (ord (s [i]))) [2:] die führende 0b.

Ich fragte mich, wie ich die erste Nummer gegen die zweite Nummer austauschen sollte. Ich habe versucht, es zu verarbeiten, das das A-Problem von AtCoder zu sein scheint.

Es wird in ungerade und gerade Zahlen unterteilt und abwechselnd ausgegeben.

Da ungerade ein weiteres Zeichen hat, wird am Ende nur ungerade [-1] ausgegeben. Wenn die Eingabe eine gerade Anzahl von Alphabeten ist, muss ich sie erneut ändern, Diesmal vorerst.

1-2. Dekodieren des Inversionstyps

Versuchen Sie nun im Gegenteil, 01100010001010011001100011000110111 an HALLO zurückzugeben.

Eingabe
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="")

Es ist im Grunde das Gegenteil von Verschlüsselung, also war es immer noch einfach.

Ich wusste, dass int ('Zahl in Binärnotation', 2) ausreicht, um eine Binärzahl wieder in eine Dezimalzahl umzuwandeln, damit ich sie einfach schreiben kann. Konvertieren Sie Binär-, Oktal- und Hexadezimalzahlen und Zeichenfolgen mit Python ineinander

2-1. Transliterationsverschlüsselung

Konvertieren Sie zunächst die DAVID in ASCII-Code. 10001001000001101011010010011000100 Das ist der Schlüssel.

Die Regeln für die Verschlüsselung sind -Wenn jedes Element des Klartextes und der Schlüssel gleich sind, ist der Chiffretext 0. -Wenn jedes Element des Klartextes und der Schlüssel unterschiedlich sind, ist der Chiffretext 1. Es ist eine exklusive logische Summe (XOR).

Eingabe
HELLO DAVID

s=input()
key=input()

n=len(s)

#ASCII-Konvertierung
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="")

Ausgabe
00011000000100001101000001010001011

2-2 Dekodieren des Inversionstyps

Verschieben Sie nun umgekehrt 00011000000100001101000001010001011 mit dem Schlüssel DAVID zurück zu HALLO. Wenn der Code und die Schlüsselelemente identisch sind, ist der Klartext 0, und wenn sie unterschiedlich sind, ist es 1. Es ist das gleiche wie beim Verschlüsseln.

Eingabe
00011000000100001101000001010001011 DAVID

s=input()
key=input()

n=len(key)

#Schlüssel in ASCII konvertieren
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="")

Ausgabe
HELLO