Encrypt And Decrypt Strings - Leetcode Solution

The Encrypt and Decrypt Strings problem on LeetCode requires us to implement two functions, encrypt and decrypt, that will take a message string as input and return an encrypted/decrypted string.

The encryption algorithm is as follows:

• Split the message string into two parts: one with the even-indexed characters, and one with the odd-indexed characters.
• Concatenate the two parts in reverse order.
• Replace each character with its ASCII code (in decimal) representation.

The decryption algorithm is the reverse of the encryption algorithm:

• Convert each ASCII code back to its character representation.
• Split the resulting string in half.
• Reverse the order of each half.
• Interleave the two halves to get the original message.

Here is a detailed solution to this problem:

class Solution:
    def encrypt(self, message: str) -> str:
        # Step 1: Split message into even- and odd-indexed characters
        even = ""
        odd = ""
        for i in range(len(message)):
            if i % 2 == 0:
                even += message[i]
            else:
                odd += message[i]
        # Step 2: Concatenate the two parts in reverse order
        encrypted = odd + even
        # Step 3: Replace each character with its ASCII code
        ascii_encrypted = ""
        for char in encrypted:
            ascii_encrypted += str(ord(char))
            ascii_encrypted += " " # Add a space between ASCII codes
        return ascii_encrypted.strip() # Remove trailing space

    def decrypt(self, message: str) -> str:
        # Step 1: Convert ASCII codes back to characters
        ascii_decrypted = message.split() # Split by spaces
        decrypted = ""
        for code in ascii_decrypted:
            decrypted += chr(int(code))
        # Step 2: Split the resulting string in half
        mid = len(decrypted) // 2
        left = decrypted[:mid]
        right = decrypted[mid:]
        # Step 3: Reverse the order of each half
        left = left[::-1]
        right = right[::-1]
        # Step 4: Interleave the two halves to get the original message
        original = ""
        for i in range(mid):
            original += left[i]
            original += right[i]
        # If message has odd length, add the last character from the right half
        if len(decrypted) % 2 != 0:
            original += right[-1]
        return original

In the encrypt function:

• We create two empty strings, even and odd, and iterate over the characters in the input message string.
• If the index is even, we add the character to even, and if it is odd, we add it to odd.
• We concatenate the two parts in reverse order to get the encrypted string.
• Finally, we replace each character with its ASCII code representation using the ord function, and add a space between each code.

In the decrypt function:

• We split the input message string by spaces to get a list of ASCII codes.
• We convert each code back to its character representation using the chr function, and concatenate the characters to get the decrypted string.
• We split the decrypted string in half at the midpoint, using integer division to get two equal-length halves (if the decrypted string has odd length, the last character will be in the right half).
• We reverse the order of each half using the [::-1] notation.
• We interleave the two halves by iterating over the indices from 0 to mid-1, adding the character from the left and right halves at each index to the original string.
• Finally, if the decrypted string has odd length, we add the last character from the right half to the original string.

1