Python decryption of Caesar Cipher

Question

Given this ciphertext from a Caesar cipher:

fxeyaxklqxhkltkxqebobxtbobxplxjykvxfaflqpxfkxqebxtloiaxrkqfixfxpqyoqbaxrpfkdxqebxfkqbokbq

The task is to decrypt it without being given the key.

My solution:

napis = "fxeyaxklqxhkltkxqebobxtbobxplxjykvxfaflqpxfkxqebxtloiaxrkqfixfxpqyoqbaxrpfkdxqebxfkqbokbq".upper()
ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "
napis = [ALPHABET.index(i) for i in napis]

for x in range(0,4):
    wynik = [ALPHABET[i+x] if i+x<len(ALPHABET) else ALPHABET[i+x-len(ALPHABET)] for i in napis]
    print("".join(wynik))

output:

FXEYAXKLQXHKLTKXQEBOBXTBOBXPLXJYKVXFAFLQPXFKXQEBXTLOIAXRKQFIXFXPQYOQBAXRPFKDXQEBXFKQBOKBQ
GYFZBYLMRYILMULYRFCPCYUCPCYQMYKZLWYGBGMRQYGLYRFCYUMPJBYSLRGJYGYQRZPRCBYSQGLEYRFCYGLRCPLCR
HZG CZMNSZJMNVMZSGDQDZVDQDZRNZL MXZHCHNSRZHMZSGDZVNQKCZTMSHKZHZRS QSDCZTRHMFZSGDZHMSDQMDS
I HAD NOT KNOWN THERE WERE SO MANY IDIOTS IN THE WORLD UNTIL I STARTED USING THE INTERNET

Answer 1

• Don't use meaningless names like "napis" and "wynik".
• x and i are meaningful in some contexts, but not for what you're using them, so use better names for those as well.
• You could take advantage of negative indices, i.e., remove ALPHABET[i+x] if i+x<len(ALPHABET) else and just use ALPHABET[i+x-len(ALPHABET)]. Or, more generally, ALPHABET[(i+x) % len(ALPHABET)].
• You could assume that spaces are the most frequent characters and do x = ALPHABET.index(' ') - max(napis, key=napis.count) instead of the loop.

Answer 2

It seems like your current solution would require the person to look through all the possible decryptions and decide which one is right. That could work ok, but it might not be necessary. It could be possible for the program to figure it out itself.

Here’s an example of superb rain’s idea to assume the decryption with the most spaces is the correct one:

import string

encrypted_text = "fxeyaxklqxhkltkxqebobxtbobxplxjykvxfaflqpxfkxqebxtloiaxrkqfixfxpqyoqbaxrpfkdxqebxfkqbokbq"

ch_list = string.ascii_lowercase + ' '

def translation_maker(offset, ch_list):
    
    translation_dict = dict()
    
    for ind, ch in enumerate(ch_list):
        translation_dict[ch] = ch_list[(ind + offset) % len(ch_list)]
    
    return str.maketrans(translation_dict)

def translation_generator(text, ch_list):
    
    for ind in range(len(ch_list)):
        for offset in range(len(ch_list)):
            yield text.translate(translation_maker(offset, ch_list))
    
likely_decryption = max(translation_generator(encrypted_text, ch_list), key=lambda x: x.count(' '))

print(likely_decryption)
# a lot of this could be one-lined, but it might maybe considered less readable
# e.g.:
"""
likely_decryption = max(
    (
        encrypted_text.translate(str.maketrans(
            {
                ch: ch_list[(ind + offset) % len(ch_list)]
                for ind, ch in enumerate(ch_list)
            }))
        for offset in range(len(ch_list))
    ),
    key=lambda x: x.count(' '))
"""

It prints the correct string in this case.

A different thing you could do is have a big set with every word in the English language, and assume the correct decryption is the one that has the most matches with the set after you split it by space. It would be mostly the same, but the lambda function would be changed to this: key=lambda x: sum(word in word_set for word in x.split()))

This might be slower even when disregarding the creation of the word set, and it would obviously use more memory, but it would be more unlikely to give a wrong result.