Atbash 密码示例 - 通过互动代码教程学习 Atbash 密码

def atbash_cipher(text):
    """
    Encode/decode text using Atbash cipher
    """
    result = ""
    
    for char in text:
        if char.isalpha():
            # Handle uppercase letters
            if char.isupper():
                # A=0, Z=25, so Z-A = 25-0 = 25
                position = ord(char) - ord('A')
                new_position = 25 - position
                result += chr(ord('A') + new_position)
            # Handle lowercase letters
            else:
                position = ord(char) - ord('a')
                new_position = 25 - position
                result += chr(ord('a') + new_position)
        else:
            # Keep non-alphabetic characters as-is
            result += char
    
    return result

# Example usage
original = "HELLO WORLD"
encoded = atbash_cipher(original)
decoded = atbash_cipher(encoded)  # Atbash is self-inverse

print(f"Original: {original}")
print(f"Encoded:  {encoded}")
print(f"Decoded:  {decoded}")

function atbashCipher(text) {
    /**
     * Encode/decode text using Atbash cipher
     * @param {string} text - Input text to transform
     * @returns {string} - Transformed text
     */
    return text
        .split('')
        .map(char => {
            if (/[A-Z]/.test(char)) {
                // Handle uppercase letters (A=65, Z=90)
                const position = char.charCodeAt(0) - 65;
                const newPosition = 25 - position;
                return String.fromCharCode(65 + newPosition);
            } else if (/[a-z]/.test(char)) {
                // Handle lowercase letters (a=97, z=122)
                const position = char.charCodeAt(0) - 97;
                const newPosition = 25 - position;
                return String.fromCharCode(97 + newPosition);
            }
            // Keep non-alphabetic characters unchanged
            return char;
        })
        .join('');
}

// Example usage with arrow function syntax
const encode = text => atbashCipher(text);
const decode = text => atbashCipher(text); // Same function!

// Test the implementation
const message = "Attack at Dawn";
const encoded = encode(message);
const decoded = decode(encoded);

console.log(`Original: ${message}`);
console.log(`Encoded:  ${encoded}`);
console.log(`Decoded:  ${decoded}`);

import string
from typing import Dict, Optional

class AtbashCipher:
    """
    Advanced Atbash cipher implementation with multiple character sets
    """
    
    def __init__(self, include_numbers: bool = False, include_special: bool = False):
        self.include_numbers = include_numbers
        self.include_special = include_special
        self._create_mappings()
    
    def _create_mappings(self) -> None:
        """Create character mapping dictionaries"""
        self.mappings: Dict[str, str] = {}
        
        # Letters
        upper = string.ascii_uppercase
        lower = string.ascii_lowercase
        self.mappings.update({
            char: upper[25 - i] for i, char in enumerate(upper)
        })
        self.mappings.update({
            char: lower[25 - i] for i, char in enumerate(lower)
        })
        
        # Numbers (optional)
        if self.include_numbers:
            digits = string.digits
            self.mappings.update({
                char: digits[9 - i] for i, char in enumerate(digits)
            })
        
        # Special characters (optional)
        if self.include_special:
            special = '!@#$%^&*()_+-=[]{}|;':",./<>?'
            reversed_special = special[::-1]
            self.mappings.update({
                char: reversed_special[i] for i, char in enumerate(special)
            })
    
    def transform(self, text: str) -> str:
        """Transform text using Atbash cipher"""
        return ''.join(
            self.mappings.get(char, char) for char in text
        )
    
    def encode(self, text: str) -> str:
        """Encode text (alias for transform)"""
        return self.transform(text)
    
    def decode(self, text: str) -> str:
        """Decode text (alias for transform - Atbash is self-inverse)"""
        return self.transform(text)

# Usage examples
cipher = AtbashCipher()
advanced_cipher = AtbashCipher(include_numbers=True, include_special=True)

text = "Hello, World! 123"
print(f"Original: {text}")
print(f"Basic:    {cipher.encode(text)}")
print(f"Advanced: {advanced_cipher.encode(text)}")