Find the Encrypted String - Practice Coding Problems

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

Understanding the Visualization

Input

Original string s and shift amount k

Process

Each character moves k positions forward with wrapping

Output

Encrypted string with shifted characters

Key Takeaway

🎯 Key Insight: Use modular arithmetic (i + k) % n to directly calculate target positions without manual counting

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

Approach	Time	Space	Notes
✓ Optimized with Modular Arithmetic	O(n)	O(n)	Use modular arithmetic to directly calculate target positions
Brute Force Character by Character	O(n × k)	O(n)	For each character, manually count k positions forward with wrapping

Optimized with Modular Arithmetic — Algorithm Steps

Iterate through each character once
Calculate target position directly: (i + k) % n
Build result string using calculated positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Formula

Use (i + k) % n to find target position

Calculate

Apply formula for each character position

Build

Construct result string with calculated characters

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++) {
        // Directly calculate target position using modular arithmetic
        int targetPos = (i + k) % n;
        result[i] = s[targetPos];
    }
    
    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)

Single pass through string with O(1) position calculation for each character

✓ 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

Optimized with Modular Arithmetic — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler