cipher.py

import string
import sys

def main():
    input_text:str = str(sys.argv[1]) if len(sys.argv) > 1 else "Seems like the code is working"
    print_steps:bool = bool(sys.argv[2]) if len(sys.argv) > 2 else False
    encrypted:str = charstring_zlib(bin_to_chars(make_fake_binary(split_text(input_text.lower())), "X", "Y"))
    print("Input: ", input_text)
    print("Encrypted: ", encrypted)
    print("Decrypted: ", decrypt(encrypted))

def split_text(text:string) -> list:
    text_list:list = []
    for i in range(text.__len__()):
        text_list.append(text[i])
    return text_list

def make_fake_binary(text_list:list) -> list:
    alphabet = string.ascii_lowercase + " "
    mapping = {
        letter: format(i, "05b") 
        for i, letter in enumerate(alphabet)}
    binary_list:list = []
    for l in text_list:
        binary_list.append(mapping[l])
    return binary_list

def bin_to_chars(bin_list:list, c1:string, c2:string) -> string:
    combined = "".join(bin_list)
    last_letter:string = "0"
    count:int = 0
    result:string = ""
    for i in combined:
        if (i == last_letter):
            count += 1
        else:
            char = c1 if last_letter == "0" else c2
            count_str = "" if count == 1 else str(count)
            result += count_str + char
            count = 1
            last_letter = i
    char = c1 if last_letter == "0" else c2
    count_str = "" if count == 1 else str(count)
    result += count_str + char
    return result

def charstring_zlib(text:string) -> string:
    mapping = {
    "XY": "A",
    "YX": "B",
    "YXY": "C",
    "XYX": "D",
    "3Y": "E",
    "2Y": "F",
    "2X": "G",
    "3X": "H",
    "4X": "I",
    "5X": "J",
    }
    result:string = ""
    latest_pattern:string = ""
    for i in range(text.__len__()):
        latest_pattern += text[i]
        if latest_pattern in mapping.keys():
            result += mapping[latest_pattern]
            latest_pattern = ""
        else:
            for n in range(latest_pattern.__len__() - 2):
                p = latest_pattern[n+1:]
                if p in mapping.keys():
                    result += latest_pattern.removesuffix(p)
                    result += mapping[p]
                    latest_pattern = ""
    return result

# def decrypt(encrypted: str) -> str:
#     mapping = {
#     "XY": "A",
#     "YX": "B",
#     "YXY": "C",
#     "XYX": "D",
#     "3Y": "E",
#     "2Y": "F",
#     "2X": "G",
#     "3X": "H",
#     "4X": "I",
#     "5X": "J",
#     }
#     decrypted:str = ""
#     for i in range(len(encrypted)):
#         ch = encrypted[i]
#         if ch in mapping.values():
#             decrypted += list(mapping.keys())[list(mapping.values()).index(ch)]
#         else:
#             decrypted += ch
#     encrypted = decrypted
#     decrypted = ""
#     while len(encrypted) > 0:
#         # if encrypted[0].isdigit():
#         #     count = int(encrypted[0])
#         #     char = encrypted[1]
#         #     decrypted += char * count
#         #     encrypted = encrypted[2:]
#         if encrypted[0].isdigit():
#             j = 0
#             while j < len(encrypted) and encrypted[j].isdigit():
#                 j += 1
#             count = int(encrypted[:j])
#             char = encrypted[j]
#             decrypted += char * count
#             encrypted = encrypted[j+1:]
#         else:
#             decrypted += encrypted[0]
#             encrypted = encrypted[1:]
#     result = ""
#     for ch in decrypted:
#         if ch == "X":
#             result += "0"
#         else:
#             result += "1"
#     decrypted = result
#     alphabet = string.ascii_lowercase + " "
#     mapping = {format(i, "05b"): letter for i, letter in enumerate(alphabet)}
#     chunks = [decrypted[i:i+5] for i in range(0, len(decrypted), 5)]
#     return "".join(mapping.get(chunk, "?") for chunk in chunks)

def decrypt(encrypted: str) -> str:
    mapping = {
        "XY": "A",
        "YX": "B",
        "YXY": "C",
        "XYX": "D",
        "3Y": "E",
        "2Y": "F",
        "2X": "G",
        "3X": "H",
        "4X": "I",
        "5X": "J",
    }

    # 1) Undo charstring_zlib (A..J -> XY / YX / etc.)
    decrypted = ""
    for ch in encrypted:
        if ch in mapping.values():
            decrypted += list(mapping.keys())[list(mapping.values()).index(ch)]
        else:
            decrypted += ch

    # 2) RLE decode with multi-digit counts
    encrypted = decrypted
    decrypted = ""
    while len(encrypted) > 0:
        if encrypted[0].isdigit():
            j = 0
            while j < len(encrypted) and encrypted[j].isdigit():
                j += 1
            count = int(encrypted[:j])
            char = encrypted[j]
            decrypted += char * count
            encrypted = encrypted[j+1:]
        else:
            decrypted += encrypted[0]
            encrypted = encrypted[1:]

    # 3) Map X/Y -> 0/1
    result = ""
    for ch in decrypted:
        if ch == "X":
            result += "0"
        else:
            result += "1"
    decrypted = result

    # 4) Trim to full 5-bit chunks only
    usable_len = (len(decrypted) // 5) * 5
    decrypted = decrypted[:usable_len]

    # 5) 5-bit -> letters
    alphabet = string.ascii_lowercase + " "
    mapping = {format(i, "05b"): letter for i, letter in enumerate(alphabet)}
    chunks = [decrypted[i:i+5] for i in range(0, len(decrypted), 5)]
    return "".join(mapping[chunk] for chunk in chunks)


main()