Implement Base64 Encoding in Python

Base64 encoding is a widely used method to represent binary data in an ASCII string format. This is crucial for transmitting data over mediums that are designed to handle text, such as email or certain network protocols. Your task is to implement a Python function that performs Base64 encoding.

Problem Description

You need to write a Python function base64_encode(data) that takes a string as input and returns its Base64 encoded representation. The function should adhere to the standard Base64 encoding algorithm.

Key Requirements:

The input data will be a string containing characters that can be interpreted as bytes (e.g., ASCII or UTF-8 encoded strings).
The output should be a string representing the Base64 encoded version of the input.
The encoding process involves grouping input bytes into chunks of 3, converting each chunk into 4 Base64 characters, and handling padding if the input length is not a multiple of 3.

Expected Behavior:

The function should correctly encode arbitrary byte sequences into Base64.

Edge Cases to Consider:

Empty input string.
Input strings whose lengths are not multiples of 3.

Examples

Example 1:

Input: "hello"
Output: "aGVsbG8="
Explanation:
The input string "hello" has 5 bytes.
'h' (01101000) 'e' (01100101) 'l' (01101100) -> 011010 000110 010101 101100 -> 26 6 21 44 -> 'a' 'G' 'V' 's'
'l' (01101100) 'o' (01101111) -> 011011 000110 1111xx -> 27 6 111 (needs padding)
For 'l' (01101100) and 'o' (01101111):
01101100 01101111
Combine into 24 bits: 01101100 01101111 00000000
Split into 4 groups of 6 bits: 011011 000110 111100 000000
These are 27, 6, 60, 0.
In Base64 alphabet, these correspond to 'b', 'G', '8', 'A'.
Since we had 2 input bytes, we need 2 padding characters '=='.
So, the second part becomes "bGc4PQ==" or similar depending on exact padding interpretation.
The standard process is:
"hello" -> bytes: [104, 101, 108, 108, 111]
Group into 3s:
[104, 101, 108] -> 01101000 01100101 01101100
-> 011010 (26) 000110 (6) 010101 (21) 101100 (44) -> 'a', 'G', 'V', 's'

[108, 111] -> 01101100 01101111
Pad with a zero byte: [108, 111, 0] -> 01101100 01101111 00000000
-> 011011 (27) 000110 (6) 111100 (60) 000000 (0) -> 'b', 'G', '8', 'A'
Wait, that's not right. Let's follow the standard algorithm precisely.

"hello" (5 bytes)
1. Convert to bytes: b'hello'
2. Group into 3-byte chunks:
   - Chunk 1: b'hel' -> 0x68, 0x65, 0x6c
   - Chunk 2: b'lo'  -> 0x6c, 0x6f
3. For each chunk, convert to a 24-bit integer:
   - Chunk 1 (0x68656c): 01101000 01100101 01101100
   - Chunk 2 (0x6c6f): 01101100 01101111
4. Split each 24-bit integer into four 6-bit integers:
   - From Chunk 1:
     011010 (26) -> 'a'
     000110 (6)  -> 'G'
     010101 (21) -> 'V'
     101100 (44) -> 's'
   - From Chunk 2: Pad with zero bytes to make it 3 bytes. 0x6c6f -> 0x6c6f00
     011011 (27) -> 'b'
     000110 (6)  -> 'G'
     111100 (60) -> '8'
     000000 (0)  -> 'A'
     This is where the padding logic comes in. If the last group has only 1 byte, we use two padding characters. If it has 2 bytes, we use one padding character.

Let's retry Example 1 with the correct padding logic:
Input: "hello" (5 bytes)

1.  Convert to bytes: `b'hello'`
2.  Group into 3-byte chunks. The last chunk will be shorter.
    *   Chunk 1: `b'hel'` (3 bytes)
    *   Chunk 2: `b'lo'` (2 bytes)

3.  Process Chunk 1 (`b'hel'`):
    *   Binary representation: `01101000 01100101 01101100`
    *   Split into four 6-bit groups: `011010` (26), `000110` (6), `010101` (21), `101100` (44)
    *   Map to Base64 characters: `a`, `G`, `V`, `s`

4.  Process Chunk 2 (`b'lo'`):
    *   Binary representation: `01101100 01101111`
    *   Pad with a zero byte to make it 3 bytes: `01101100 01101111 00000000`
    *   Split into four 6-bit groups: `011011` (27), `000110` (6), `111100` (60), `000000` (0)
    *   Map to Base64 characters: `b`, `G`, `8`, `A`
    *   Since the original chunk had only 2 bytes, the last Base64 character ('A') is a result of padding and should be replaced by `=`. The character before that ('8') is also a result of padding the last 6 bits and should be replaced by `=`.

    Wait, the standard says:
    If input has 2 bytes, output 3 characters + 1 padding.
    If input has 1 byte, output 2 characters + 2 padding.

    Let's follow the spec for chunking:
    Input: "hello" (5 bytes)

    1.  Convert to bytes: `b'hello'`
    2.  Take 3 bytes at a time:
        *   `b'hel'` -> `01101000 01100101 01101100`
            *   6-bit groups: `011010` (26), `000110` (6), `010101` (21), `101100` (44)
            *   Base64: `a`, `G`, `V`, `s`

        *   `b'lo'` -> `01101100 01101111` (2 bytes remaining)
            *   Combine into 16 bits: `01101100 01101111`
            *   Pad with zeros to make 24 bits: `01101100 01101111 00000000`
            *   Split into 6-bit groups: `011011` (27), `000110` (6), `111100` (60), `000000` (0)
            *   Map to Base64 characters: `b`, `G`, `8`, `A`.
            *   Since the original input chunk was 2 bytes, the last output character ('A', derived from the `000000` bits which were all padding) is replaced by `=`. The character before that ('8') is also derived from the padding (the last 6 bits of the 24-bit number being 000000).
            *   Thus, the output for this 2-byte input is 3 characters + 1 padding: `b`, `G`, `8`, `=`.

    Combining: `aGVsbG8=`

    This matches standard Base64 behavior. The "hello" example requires careful handling of the last group's padding.

**Example 2:**

Input: "abc" Output: "YWJj" Explanation: 'a' (01100001) 'b' (01100010) 'c' (01110000) -> 011000 010110 001001 110000 -> 24 22 9 48 -> 'Y', 'W', 'J', 'j'


**Example 3:**

Input: "" Output: "" Explanation: An empty input string results in an empty output string.


## Constraints

*   The input `data` will be a string.
*   The length of the input string can be between 0 and 1024 characters.
*   The function should be reasonably efficient for the given constraints.

## Notes

*   The Base64 alphabet consists of 64 characters: `A-Z`, `a-z`, `0-9`, `+`, and `/`.
*   Padding is represented by the `=` character.
*   You will need to convert the input string into its byte representation. For Python 3, strings are Unicode, so you'll need to encode them (e.g., using `.encode('utf-8')`) before processing bytes.
*   Think about how to group bits. Each 3 bytes (24 bits) become 4 Base64 characters (each using 6 bits).

Problem Description

Key Requirements:

The input data will be a string containing characters that can be interpreted as bytes (e.g., ASCII or UTF-8 encoded strings).

The output should be a string representing the Base64 encoded version of the input.

The encoding process involves grouping input bytes into chunks of 3, converting each chunk into 4 Base64 characters, and handling padding if the input length is not a multiple of 3.

Expected Behavior:

The function should correctly encode arbitrary byte sequences into Base64.

Edge Cases to Consider:

Empty input string.

Input strings whose lengths are not multiples of 3.

Examples

Example 1:

Input: "hello" Output: "aGVsbG8=" Explanation: The input string "hello" has 5 bytes. 'h' (01101000) 'e' (01100101) 'l' (01101100) -> 011010 000110 010101 101100 -> 26 6 21 44 -> 'a' 'G' 'V' 's' 'l' (01101100) 'o' (01101111) -> 011011 000110 1111xx -> 27 6 111 (needs padding) For 'l' (01101100) and 'o' (01101111): 01101100 01101111 Combine into 24 bits: 01101100 01101111 00000000 Split into 4 groups of 6 bits: 011011 000110 111100 000000 These are 27, 6, 60, 0. In Base64 alphabet, these correspond to 'b', 'G', '8', 'A'. Since we had 2 input bytes, we need 2 padding characters '=='. So, the second part becomes "bGc4PQ==" or similar depending on exact padding interpretation. The standard process is: "hello" -> bytes: [104, 101, 108, 108, 111] Group into 3s: [104, 101, 108] -> 01101000 01100101 01101100 -> 011010 (26) 000110 (6) 010101 (21) 101100 (44) -> 'a', 'G', 'V', 's' [108, 111] -> 01101100 01101111 Pad with a zero byte: [108, 111, 0] -> 01101100 01101111 00000000 -> 011011 (27) 000110 (6) 111100 (60) 000000 (0) -> 'b', 'G', '8', 'A' Wait, that's not right. Let's follow the standard algorithm precisely. "hello" (5 bytes) 1. Convert to bytes: b'hello' 2. Group into 3-byte chunks: - Chunk 1: b'hel' -> 0x68, 0x65, 0x6c - Chunk 2: b'lo' -> 0x6c, 0x6f 3. For each chunk, convert to a 24-bit integer: - Chunk 1 (0x68656c): 01101000 01100101 01101100 - Chunk 2 (0x6c6f): 01101100 01101111 4. Split each 24-bit integer into four 6-bit integers: - From Chunk 1: 011010 (26) -> 'a' 000110 (6) -> 'G' 010101 (21) -> 'V' 101100 (44) -> 's' - From Chunk 2: Pad with zero bytes to make it 3 bytes. 0x6c6f -> 0x6c6f00 011011 (27) -> 'b' 000110 (6) -> 'G' 111100 (60) -> '8' 000000 (0) -> 'A' This is where the padding logic comes in. If the last group has only 1 byte, we use two padding characters. If it has 2 bytes, we use one padding character. Let's retry Example 1 with the correct padding logic: Input: "hello" (5 bytes) 1. Convert to bytes: `b'hello'` 2. Group into 3-byte chunks. The last chunk will be shorter. * Chunk 1: `b'hel'` (3 bytes) * Chunk 2: `b'lo'` (2 bytes) 3. Process Chunk 1 (`b'hel'`): * Binary representation: `01101000 01100101 01101100` * Split into four 6-bit groups: `011010` (26), `000110` (6), `010101` (21), `101100` (44) * Map to Base64 characters: `a`, `G`, `V`, `s` 4. Process Chunk 2 (`b'lo'`): * Binary representation: `01101100 01101111` * Pad with a zero byte to make it 3 bytes: `01101100 01101111 00000000` * Split into four 6-bit groups: `011011` (27), `000110` (6), `111100` (60), `000000` (0) * Map to Base64 characters: `b`, `G`, `8`, `A` * Since the original chunk had only 2 bytes, the last Base64 character ('A') is a result of padding and should be replaced by `=`. The character before that ('8') is also a result of padding the last 6 bits and should be replaced by `=`. Wait, the standard says: If input has 2 bytes, output 3 characters + 1 padding. If input has 1 byte, output 2 characters + 2 padding. Let's follow the spec for chunking: Input: "hello" (5 bytes) 1. Convert to bytes: `b'hello'` 2. Take 3 bytes at a time: * `b'hel'` -> `01101000 01100101 01101100` * 6-bit groups: `011010` (26), `000110` (6), `010101` (21), `101100` (44) * Base64: `a`, `G`, `V`, `s` * `b'lo'` -> `01101100 01101111` (2 bytes remaining) * Combine into 16 bits: `01101100 01101111` * Pad with zeros to make 24 bits: `01101100 01101111 00000000` * Split into 6-bit groups: `011011` (27), `000110` (6), `111100` (60), `000000` (0) * Map to Base64 characters: `b`, `G`, `8`, `A`. * Since the original input chunk was 2 bytes, the last output character ('A', derived from the `000000` bits which were all padding) is replaced by `=`. The character before that ('8') is also derived from the padding (the last 6 bits of the 24-bit number being 000000). * Thus, the output for this 2-byte input is 3 characters + 1 padding: `b`, `G`, `8`, `=`. Combining: `aGVsbG8=` This matches standard Base64 behavior. The "hello" example requires careful handling of the last group's padding. **Example 2:**

Input: "abc" Output: "YWJj" Explanation: 'a' (01100001) 'b' (01100010) 'c' (01110000) -> 011000 010110 001001 110000 -> 24 22 9 48 -> 'Y', 'W', 'J', 'j'

**Example 3:**

Input: "" Output: "" Explanation: An empty input string results in an empty output string.

## Constraints * The input `data` will be a string. * The length of the input string can be between 0 and 1024 characters. * The function should be reasonably efficient for the given constraints. ## Notes * The Base64 alphabet consists of 64 characters: `A-Z`, `a-z`, `0-9`, `+`, and `/`. * Padding is represented by the `=` character. * You will need to convert the input string into its byte representation. For Python 3, strings are Unicode, so you'll need to encode them (e.g., using `.encode('utf-8')`) before processing bytes. * Think about how to group bits. Each 3 bytes (24 bits) become 4 Base64 characters (each using 6 bits).