ROT13 Encoder/Decoder - Problem

Implement a ROT13 encoder/decoder function that transforms alphabetic characters by shifting them 13 positions in the alphabet. ROT13 is a simple letter substitution cipher that replaces each letter with the letter 13 positions after it in the alphabet.

Key Rules:

Only rotate alphabetic characters (a-z, A-Z)
Preserve case: uppercase letters stay uppercase, lowercase stay lowercase
Keep all non-alphabetic characters unchanged (numbers, spaces, punctuation)
ROT13 is its own inverse: applying it twice returns the original string

For example: 'A' becomes 'N', 'B' becomes 'O', ..., 'N' becomes 'A', 'Z' becomes 'M'

Input & Output

Example 1 — Basic Mixed Case

$ Input: text = "Hello World!"

› Output: "Uryyb Jbeyq!"

💡 Note: H→U, e→r, l→y, l→y, o→b, space stays, W→J, o→b, r→e, l→y, d→q, ! stays unchanged

Example 2 — Numbers and Punctuation

$ Input: text = "Test123!@#"

› Output: "Grfg123!@#"

💡 Note: Only alphabetic characters are rotated: T→G, e→r, s→f, t→g. Numbers and symbols remain unchanged

Example 3 — Wraparound Case

$ Input: text = "XYZ abc"

› Output: "KLM nop"

💡 Note: Shows alphabet wraparound: X→K, Y→L, Z→M, a→n, b→o, c→p

Constraints

1 ≤ text.length ≤ 1000
text contains ASCII characters only
Mix of uppercase, lowercase, numbers, and special characters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

ROT13 is solved using ASCII arithmetic to shift each alphabetic character by 13 positions. The key insight is using (char - base + 13) % 26 for wraparound. Best approach uses direct ASCII math. Time: O(n), Space: O(1)

Common Approaches

✓ ASCII Math Optimization

⏱️ Time: O(n) Space: O(1)

Convert characters to ASCII values, perform mathematical operations to shift by 13 positions, and handle wraparound using modular arithmetic. This eliminates the need for alphabet string lookups.

Character-by-Character with Manual Alphabet Lookup

⏱️ Time: O(n) Space: O(1)

Iterate through each character in the input string. For alphabetic characters, use string operations to find the position in the alphabet, add 13, and wrap around if necessary. Non-alphabetic characters are copied unchanged.

ASCII Math Optimization — Algorithm Steps

Iterate through each character
Check if alphabetic using ASCII ranges
Convert to ASCII, subtract base (A=65 or a=97)
Add 13 and use modulo 26 for wraparound
Convert back to character

Visualization

Tap to expand

Step-by-Step Walkthrough

ASCII Check

Use character ranges to identify type

Math Transform

Apply (char - base + 13) % 26

Convert Back

Add base and convert to character

Result

Build transformed string

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

void solution(char* text, char* result) {
    int len = strlen(text);
    int resultIndex = 0;
    
    for (int i = 0; i < len; i++) {
        char c = text[i];
        
        if (c >= 'A' && c <= 'Z') {
            // Uppercase: A=65, shift by 13 with wraparound
            int shifted = (c - 'A' + 13) % 26;
            result[resultIndex++] = shifted + 'A';
        } else if (c >= 'a' && c <= 'z') {
            // Lowercase: a=97, shift by 13 with wraparound
            int shifted = (c - 'a' + 13) % 26;
            result[resultIndex++] = shifted + 'a';
        } else {
            // Non-alphabetic: keep unchanged
            result[resultIndex++] = c;
        }
    }
    
    result[resultIndex] = '\0';
}

int main() {
    char text[10000];
    char result[10000];
    
    fgets(text, sizeof(text), stdin);
    text[strcspn(text, "\n")] = 0;  // Remove newline
    
    solution(text, result);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant time operations per character

✓ Linear Growth

Space Complexity

O(1)

Only storing result string and temporary variables

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

ROT13 Encoder/Decoder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

ASCII Math Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler