String Transformation - Practice Coding Problems

String Transformation - Problem

String Transformation Through Rotations

You are given two strings s and t of equal length n. Your goal is to transform string s into string t using exactly k operations.

Operation: Remove a suffix of s of length l (where 0 < l < n) and append it to the beginning of s.

Example: If s = "abcd", you can:
• Remove suffix "d" → "dabc"
• Remove suffix "cd" → "cdab"
• Remove suffix "bcd" → "bcda"

Challenge: Count the number of ways to transform s into t in exactly k operations. Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Transformation

$ Input: s = "abcd", t = "cdab", k = 2

› Output: 1

💡 Note: One way: "abcd" → (remove "cd") → "cdab" → (remove "b") → "bcda" → (remove "bcd") → "cdab". We need exactly 2 operations, and there's exactly 1 sequence that works.

example_2.py — Multiple Paths

$ Input: s = "abc", t = "bca", k = 2

› Output: 1

💡 Note: From "abc" to "bca" in 2 operations: "abc" → (remove "c") → "cab" → (remove "ab") → "bca". Only one valid path exists.

example_3.py — Impossible Case

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

› Output: 0

💡 Note: String t is not a rotation of string s, so no sequence of operations can transform s into t.

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each possible rotation of the string becomes a node in our graph

Define Transitions

From each node, we can reach n-1 other nodes through valid suffix operations

Dynamic Programming

Count paths of length exactly k from source to target using DP table

Optimization

For large k, use matrix exponentiation to achieve O(n³ log k) complexity

Key Takeaway

🎯 Key Insight: Transform the string rotation problem into a graph where each rotation is a state, then use dynamic programming to count exactly k-length paths from source to target state.

Time & Space Complexity

Time Complexity

⏱️

O(n² * k)

n states, each transition takes O(n), repeated k times

⚠ Quadratic Growth

Space Complexity

O(n * k)

DP table storing ways to reach each of n states in each of k steps

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
1 ≤ k ≤ 1000
n == s.length == t.length
s and t consist of only lowercase English letters

Asked in

G Google 42 f Meta 28 ⊞ Microsoft 24 a Amazon 18

The optimal approach uses dynamic programming to model this as a graph path counting problem. Each rotation of the string represents a state, and we count the number of k-length paths from the source state to the target state. This avoids the exponential complexity of brute force while handling the constraint of exactly k operations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with State Compression	O(n² * k)	O(n * k)	Use DP to count paths between rotation states efficiently
Brute Force Recursive Enumeration	O((n-1)^k)	O(k * n)	Try all possible sequences of k operations recursively

Dynamic Programming with State Compression — Algorithm Steps

Generate all possible rotations of string s (there are n rotations)
Find which rotation corresponds to target string t
Build transition matrix: from each rotation, we can reach n-1 other rotations
Use DP: dp[i][j] = number of ways to reach rotation j in exactly i operations
Apply matrix exponentiation for optimization when k is large

Visualization

Tap to expand

Step-by-Step Walkthrough

State Space

Each rotation of s is a state in our graph

Transitions

From each state, n-1 transitions are possible

DP Table

Build table of ways to reach each state in i operations

Final Answer

dp[k][target_index] gives our result

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1000

int numWays(char* s, char* t, int k) {
    int n = strlen(s);
    
    // Generate all rotations
    char rotations[MAX_N][MAX_N];
    strcpy(rotations[0], s);
    
    for (int i = 1; i < n; i++) {
        strcpy(rotations[i], rotations[i-1] + 1);
        strncat(rotations[i], rotations[i-1], 1);
    }
    
    // Find target index
    int targetIdx = -1;
    for (int i = 0; i < n; i++) {
        if (strcmp(rotations[i], t) == 0) {
            targetIdx = i;
            break;
        }
    }
    
    if (targetIdx == -1) return 0;
    
    // DP: dp[i][j] = ways to reach rotation j in exactly i operations
    long long dp[1001][MAX_N];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1;
    
    for (int i = 1; i <= k; i++) {
        for (int j = 0; j < n; j++) {
            for (int suffixLen = 1; suffixLen < n; suffixLen++) {
                int nextRot = (j + suffixLen) % n;
                dp[i][nextRot] = (dp[i][nextRot] + dp[i-1][j]) % MOD;
            }
        }
    }
    
    return dp[k][targetIdx];
}

int main() {
    char s[] = "abc";
    char t[] = "bca";
    int k = 2;
    printf("%d\n", numWays(s, t, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * k)

n states, each transition takes O(n), repeated k times

⚠ Quadratic Growth

Space Complexity

O(n * k)

DP table storing ways to reach each of n states in each of k steps

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
1 ≤ k ≤ 1000
n == s.length == t.length
s and t consist of only lowercase English letters

52.0K Views

Medium Frequency

~35 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with State Compression — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler