Find the Encrypted String

Find the Encrypted String - Problem

String Easy

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

For each character c in s, replace c with the k-th character after c in the string (in a cyclic manner).

Example: If s = "abc" and k = 1, then 'a' is replaced by 'b' (1 position after 'a'), 'b' is replaced by 'c' (1 position after 'b'), and 'c' is replaced by 'a' (1 position after 'c' cyclically).

Return the encrypted string.

Input & Output

Example 1 — Basic Case

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

› Output: "bca"

💡 Note: For each character, replace with the next character: 'a' → 'b' (1 step), 'b' → 'c' (1 step), 'c' → 'a' (1 step, wrapping around)

Example 2 — Larger Step

$ Input: s = "abcdef", k = 2

› Output: "cdefab"

💡 Note: Each character moves 2 positions forward: 'a'→'c', 'b'→'d', 'c'→'e', 'd'→'f', 'e'→'a', 'f'→'b'

Example 3 — Single Character

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

› Output: "x"

💡 Note: With only one character, moving k positions always returns to the same character

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ 10⁴
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use modular arithmetic (i + k) % n to directly calculate the target position for each character, eliminating the need for manual counting. The optimal approach runs in O(n) time and O(n) space.

Common Approaches

✓ Brute Force Character by Character

⏱️ Time: O(n × k) Space: O(n)

Iterate through each character in the string and find the character that is k positions ahead by counting one by one, wrapping around to the beginning when reaching the end.

Optimized with Modular Arithmetic

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

Instead of counting k steps for each character, directly calculate the target position using modular arithmetic: (i + k) % n. This eliminates the need for inner loops.

Brute Force Character by Character — Algorithm Steps

Iterate through each character in the string
For each character, count k positions forward with manual wrapping
Build result string character by character

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with first character, count k steps

Count

Manually increment position k times with wrapping

Repeat

Do this for every character in string

Code -

solution.c — C

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

char* solution(char* s, int k) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    
    for (int i = 0; i < n; i++) {
        // Start from current position and move k steps forward
        int currentPos = i;
        for (int j = 0; j < k; j++) {
            currentPos = (currentPos + 1) % n;
        }
        result[i] = s[currentPos];
    }
    
    result[n] = '\0';
    return result;
}

int main() {
    char s[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

For each of n characters, we potentially iterate k times to find the target position

✓ Linear Growth

Space Complexity

O(n)

Result string requires O(n) space to store the encrypted characters

⚡ Linearithmic Space

33.2K Views

Medium Frequency

~10 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Character by Character — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler