Find the Encrypted String - Practice Coding Problems

Find the Encrypted String - Problem

String Easy

Find the Encrypted String is a cyclic character shifting problem that simulates a basic encryption algorithm.

You are given a string s and an integer k. Your task is to encrypt the string using a cyclic shifting algorithm:

For each character c at position i in string s
Replace c with the character that is k positions ahead in the same string
If we go beyond the end of the string, wrap around to the beginning (cyclic behavior)

Example: If s = "abc" and k = 1, then:

'a' at index 0 → replace with character at index (0 + 1) % 3 = 1 → 'b'
'b' at index 1 → replace with character at index (1 + 1) % 3 = 2 → 'c'
'c' at index 2 → replace with character at index (2 + 1) % 3 = 0 → 'a'

Result: "bca"

Return the encrypted string.

Input & Output

example_1.py — Basic Encryption

$ Input: s = "dart", k = 3

› Output: "tdar"

💡 Note: Each character shifts 3 positions forward: d(0)→t(3), a(1)→d(0), r(2)→a(1), t(3)→r(2). The modulo operation handles the wrapping.

example_2.py — Single Character Wrap

$ Input: s = "aaa", k = 1

› Output: "aaa"

💡 Note: All characters are the same, so shifting by any amount within the string length produces the same result.

example_3.py — Large Shift Value

$ Input: s = "abc", k = 4

› Output: "bca"

💡 Note: k=4 is equivalent to k=1 (since 4%3=1) for a string of length 3. So a→b, b→c, c→a.

Constraints

1 ≤ s.length ≤ 100
0 ≤ k ≤ 10⁵
s consists only of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Arrange in Circle

Visualize the string characters arranged in a circle

Apply Shift Formula

For each position i, calculate (i + k) % length

Build Result

Collect characters from their new positions to form encrypted string

Key Takeaway

🎯 Key Insight: Modular arithmetic `(i + k) % n` directly computes the target position, making the algorithm efficient and eliminating the need for manual iteration through the circular structure.

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal solution uses modular arithmetic to directly calculate each character's new position with O(n) time complexity. The key insight is that position i maps to position (i + k) % n, eliminating the need for manual counting or complex loops.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character-by-Character Traversal)	O(n)	O(n)	For each character, manually count k steps forward with wrapping

Brute Force (Character-by-Character Traversal) — Algorithm Steps

Initialize an empty result string
For each character at position i in the original string
Start from position i and count k steps forward
If we exceed string length, wrap around using modulo
Append the character at the final position to result
Return the encrypted string

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with string s and shift value k

Calculate Positions

For each position i, calculate (i + k) % n

Build Result

Create encrypted string using the calculated positions

Code -

solution.c — C

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

char* getEncryptedString(char* s, int k) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    result[n] = '\0';
    
    for (int i = 0; i < n; i++) {
        // Calculate the new position after k steps (with wrapping)
        int newPos = (i + k) % n;
        result[i] = s[newPos];
    }
    
    return result;
}

int main() {
    char s[1001];
    int k;
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = '\0';
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    scanf("%d", &k);
    char* result = getEncryptedString(s, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each character once and use constant-time modular arithmetic

✓ Linear Growth

Space Complexity

O(n)

We create a new string to store the encrypted result

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~8 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Character-by-Character Traversal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler