Can Convert String in K Moves

Can Convert String in K Moves - Problem

Given two strings s and t, your goal is to convert s into t in k moves or less.

During the i-th move (1 <= i <= k) you can:

Choose any index j (1-indexed) from s, such that 1 <= j <= s.length and j has not been chosen in any previous move, and shift the character at that index i times.
Do nothing.

Shifting a character means replacing it by the next letter in the alphabet (wrapping around so that 'z' becomes 'a'). Shifting a character by i means applying the shift operations i times.

Remember that any index j can be picked at most once.

Return true if it's possible to convert s into t in no more than k moves, otherwise return false.

Input & Output

Example 1 — Basic Conversion

$ Input: s = "input", t = "ouput", k = 9

› Output: true

💡 Note: We need to convert 'i'→'o' (shift 6), 'n'→'u' (shift 7), 'p'→'p' (shift 0, no change), 'u'→'u' (shift 0, no change), 't'→'t' (shift 0, no change). We need shifts of 6 and 7, which can be achieved with moves 6 and 7 respectively, both ≤ 9.

Example 2 — Impossible Case

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

› Output: false

💡 Note: We need 'a'→'b' (shift 1), 'b'→'c' (shift 1), 'c'→'d' (shift 1). All three positions need shift amount 1, but we only have moves 1 and 2. Move 1 creates shift 1, move 2 creates shift 2. We need 3 positions with shift 1 but only have 1 move that creates shift 1.

Example 3 — Wrap Around

$ Input: s = "ab", t = "bb", k = 1

› Output: true

💡 Note: We need 'a'→'b' (shift 1), 'b'→'b' (no change). One position needs shift 1, and we have move 1 available which creates shift 1.

Constraints

1 ≤ s.length, t.length ≤ 10⁵
0 ≤ k ≤ 10⁹
s and t consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is that we can only use each move number once, and move i creates a shift of i % 26. We need to count how many positions require each shift amount, then check if we have enough moves to satisfy all requirements. The optimal greedy approach assigns moves efficiently in O(n) time and O(1) space.

Common Approaches

✓ Count Required Shifts

⏱️ Time: O(n + k) Space: O(26)

Calculate the shift amount needed for each position, group positions by shift amount, then verify if we have enough move numbers available for each group.

Greedy Assignment

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

Group positions by required shift amount, then greedily assign the smallest available move numbers that can produce each shift. This ensures we use moves efficiently.

Try All Combinations

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

For each position that needs shifting, try assigning each available move number (1 to k) and recursively check if remaining positions can be satisfied with remaining moves.

Count Required Shifts — Algorithm Steps

Calculate shift needed for each differing position
Count frequency of each shift amount
Check if enough move numbers exist for each shift count

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Shifts

Count how many positions need each shift amount

Count Moves

Count how many moves can produce each shift amount

Compare

Check if supply meets demand for each shift amount

Code -

solution.c — C

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

bool solution(char* s, char* t, int k) {
    int len = strlen(s);
    if (len != strlen(t)) return false;
    
    int shiftCounts[27] = {0}; // 1-26 for shifts
    
    for (int i = 0; i < len; i++) {
        if (s[i] != t[i]) {
            int shift = (t[i] - s[i] + 26) % 26;
            if (shift == 0) continue;
            shiftCounts[shift]++;
        }
    }
    
    int availableMoves[27] = {0};
    for (int move = 1; move <= k; move++) {
        int shiftCreated = move % 26;
        if (shiftCreated == 0) shiftCreated = 26;
        availableMoves[shiftCreated]++;
    }
    
    for (int i = 1; i <= 26; i++) {
        if (shiftCounts[i] > availableMoves[i]) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char s[1001], t[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    fgets(t, sizeof(t), stdin);
    t[strcspn(t, "\n")] = 0;
    scanf("%d", &k);
    
    bool result = solution(s, t, k);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

One pass through string to count shifts, one pass through move counts

✓ Linear Growth

Space Complexity

O(26)

Hash map stores at most 26 different shift amounts (a-z)

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Count Required Shifts — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler