5 Best Ways to Implement Atbash Cipher in Python

Rate this post

πŸ’‘ Problem Formulation: Atbash Cipher is a monoalphabetic substitution cipher originally used to encrypt the Hebrew alphabet. It is formed by reversing the alphabet, where the first letter is replaced with the last letter, the second with the second-last, and so forth. If our input is “HELLO” using the English alphabet, the desired output is “SVOOL”. This article solves the problem of creating such a cipher in Python by using various methods.

Method 1: Using ASCII Values

This method utilizes the ASCII values to calculate the corresponding cipher character. For a given letter, the method computes the difference between the ASCII value of the letter and the ASCII value of ‘A’ for uppercase letters or ‘a’ for lowercase letters, then subtracts this value from the ASCII of ‘Z’ or ‘z’ respectively to get the ciphered character.

Here’s an example:

def atbash_cipher(text):
    result = ""
    for char in text:
        if char.isalpha():
            ascii_offset = ord('A') if char.isupper() else ord('a')
            result += chr(ascii_offset + (25 - (ord(char) - ascii_offset)))
        else:
            result += char
    return result

print(atbash_cipher('HELLO'))

Output:

SVOOL

This code snippet defines a function atbash_cipher that takes a string and enciphers it using the Atbash Cipher by leveraging ASCII values. It differentiates between uppercase and lowercase letters, preserving the case of the input text in the output.

Method 2: Using Dictionary Mapping

A dictionary is built to map each letter of the alphabet to its corresponding reverse letter. This method iterates through each letter of the input, replaces it with the value from a pre-defined dictionary, and joins them into the encrypted string.

Here’s an example:

def atbash_cipher(text):
    alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    reversed_alphabet = alphabet[::-1]
    atbash_dict = dict(zip(alphabet, reversed_alphabet))
    result = ''.join(atbash_dict.get(char, char) for char in text.upper())
    return result

print(atbash_cipher('hello'))

Output:

SVOOL

In this code snippet, a function atbash_cipher creates a dictionary mapping of the regular alphabet to its reversed counterpart. This allows for a simple and efficient translation of the input string to its Atbash cipher equivalent, keeping the function concise.

Method 3: Using the str.translate() Method

The str.translate() method in Python performs string substitution using a translation table. In this method, we create two translation tables, one for uppercase and one for lowercase letters, and then use the translate() method to encode the string.

Here’s an example:

def atbash_cipher(text):
    upper_transtable = str.maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'ZYXWVUTSRQPONMLKJIHGFEDCBA')
    lower_transtable = str.maketrans('abcdefghijklmnopqrstuvwxyz', 'zyxwvutsrqponmlkjihgfedcba')
    result = text.translate(upper_transtable).translate(lower_transtable)
    return result

print(atbash_cipher('Hello, World!'))

Output:

Svool, Dliow!

This snippet uses str.translate() providing a direct way to translate each character of the input text. It separately handles uppercase and lowercase translations, which presents a neat encryption without changing the case of the original characters.

Method 4: Using Custom Functions for Character Translation

This method involves defining a custom function that directly calculates the Atbash cipher equivalent for each character by using arithmetic on character ordinals, casting to characters, and handling non-alphabetic characters properly.

Here’s an example:

def atbash_cipher_char(char):
    if char.isupper():
        return chr(155 - ord(char)) if char.isalpha() else char
    elif char.islower():
        return chr(219 - ord(char)) if char.isalpha() else char
    return char

def atbash_cipher(text):
    return ''.join(atbash_cipher_char(char) for char in text)

print(atbash_cipher('Hello, World!'))

Output:

Svool, Dliow!

The code snippet contains a higher-order function atbash_cipher that applies a custom transformation function atbash_cipher_char to each character of the input. This allows for a granular and explicit handling of the encryption process.

Bonus One-Liner Method 5: Using a Lambda and Map Functions

For a swift and terse solution, a lambda function paired with the map function can achieve the Atbash cipher. This one-liner combines the power of Python’s functional programming features to produce an elegant solution.

Here’s an example:

print(''.join(map(lambda x: chr(155 - ord(x)) if x.isupper() else (chr(219 - ord(x)) if x.islower() else x), 'Hello, World!')))

Output:

Svool, Dliow!

The code snippet showcases an immediately-invoked function expression that uses a lambda to cipher each character. Although compact, it lacks readability for those not familiar with lambda functions or map.

Summary/Discussion

  • Method 1: Using ASCII Values. This is a clear method that is easy to understand and manipulate for different alphabets. However, it might not be as Pythonic as other methods.
  • Method 2: Using Dictionary Mapping. This method is Pythonic and readable, but creating a dictionary is not as efficient for large texts when compared to string translation methods.
  • Method 3: Using the str.translate() Method. This method is fast and efficient but might be less clear to someone reading the code for the first time.
  • Method 4: Using Custom Functions for Character Translation. Highly interpretable and modular with the ability to handle special characters. However, it might be overkill for simple use cases.
  • Bonus Method 5: Using a Lambda and Map Functions. Offers a succinct one-liner, which is elegant but potentially hard to debug and maintain.