Caesar Cipher - Problem

Implement the Caesar Cipher encryption algorithm that shifts each letter in a message by a given number of positions in the alphabet.

Given a string message and an integer shift, return the encrypted message where each letter is shifted by shift positions. When shifting goes past 'z', it wraps around to 'a' (and similarly for uppercase letters).

Requirements:

Only alphabetic characters (a-z, A-Z) should be shifted
Non-alphabetic characters (spaces, punctuation, numbers) remain unchanged
Preserve the original case (uppercase/lowercase)
Handle both positive and negative shift values

Input & Output

Example 1 — Basic Positive Shift

$ Input: message = "Hello", shift = 3

› Output: Khoor

💡 Note: Each letter shifts forward by 3: H→K, e→h, l→o, l→o, o→r. Non-alphabetic characters remain unchanged.

Example 2 — Wrapping Around Alphabet

$ Input: message = "xyz", shift = 3

› Output: abc

💡 Note: When shift goes past 'z', it wraps to 'a': x→a, y→b, z→c. Demonstrates alphabet wrapping.

Example 3 — Mixed Case with Punctuation

$ Input: message = "Hello, World!", shift = 1

› Output: Ifmmp, Xpsme!

💡 Note: Preserves case and punctuation: H→I, e→f, l→m, comma and space unchanged, W→X, etc.

Constraints

1 ≤ message.length ≤ 1000
-100 ≤ shift ≤ 100
Message contains printable ASCII characters

Visualization

Tap to expand

Asked in

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

The key insight is using ASCII arithmetic with modulo 26 to handle alphabet wrapping automatically. Convert each letter to 0-25 range, apply shift with modulo, then convert back to character. Best approach uses ASCII Arithmetic for clean, efficient character transformation. Time: O(n), Space: O(1)

Common Approaches

✓ ASCII Arithmetic with Modulo

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

Convert characters to ASCII values, apply mathematical operations for shifting, and use modulo to handle alphabet wrapping automatically.

Character-by-Character Counting

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

For each character, determine if it's alphabetic, then count through the alphabet positions to apply the shift, wrapping around when necessary.

ASCII Arithmetic with Modulo — Algorithm Steps

Step 1: Iterate through message characters
Step 2: Convert alphabetic characters to 0-25 range
Step 3: Apply shift using modulo arithmetic for wrapping
Step 4: Convert back to character and build result

Visualization

Tap to expand

Step-by-Step Walkthrough

ASCII Conversion

Convert character to ASCII and normalize to 0-25

Modulo Math

Apply shift with modulo 26 for automatic wrapping

Back to Char

Convert result back to character

Code -

solution.c — C

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

void solution(char* message, int shift, char* result) {
    int len = strlen(message);
    for (int i = 0; i < len; i++) {
        char c = message[i];
        if (c >= 'A' && c <= 'Z') {
            result[i] = (c - 'A' + shift + 26) % 26 + 'A';
        } else if (c >= 'a' && c <= 'z') {
            result[i] = (c - 'a' + shift + 26) % 26 + 'a';
        } else {
            result[i] = c;
        }
    }
    result[len] = '\0';
}

int main() {
    char message[1000];
    int shift;
    char result[1000];
    
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = 0;
    scanf("%d", &shift);
    
    solution(message, shift, result);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through message characters

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Caesar Cipher - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

ASCII Arithmetic with Modulo — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler