Can Convert String in K Moves - Practice Coding Problems

Can Convert String in K Moves - Problem

Can Convert String in K Moves

You're given two strings s and t of equal length, and your mission is to transform s into t using at most k moves. This is like a puzzle where you need to strategically shift characters in the alphabet!

The Rules:
• In move i (where i goes from 1 to k), you can pick any unused index j from string s
• Shift the character at position j exactly i positions forward in the alphabet
• Alphabet wraps around: 'z' + 1 = 'a'
• Each index can only be used once
• You can also choose to do nothing in a move

Goal: Return true if transformation is possible, false otherwise.

Example: To change 'a' to 'c', you need 2 shifts. You could use this in move 2, or wait for a later move that gives exactly 2 shifts (like move 28, since (28-2) % 26 = 0).

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: We need to change 'i'→'o' (shift 6) and 'n'→'p' (shift 2). Move 6 gives shift 6, move 2 gives shift 2. Both moves ≤ 9, so it's possible.

example_2.py — Insufficient Moves

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

› Output: false

💡 Note: All three positions need shift 1. Only move 1 provides shift 1 within k=2 moves. We need 3 such moves but only have 1.

example_3.py — Wrap Around

$ Input: s = "aab", t = "bbc", k = 27

› Output: true

💡 Note: Position 0: 'a'→'b' needs shift 1 (use move 1). Position 2: 'b'→'c' needs shift 1 (use move 27, since 27%26=1). Two positions need same shift, and we have moves 1 and 27.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Calculate Shifts

For each position, find how many steps forward we need to go from s[i] to t[i]

Group by Remainder

Group positions by their shift amount modulo 26 (since alphabet wraps)

Count Available Moves

For shift amount r, moves r, r+26, r+52, ... all work

Verify Sufficiency

Check if we have enough moves of each type within the k limit

Key Takeaway

🎯 Key Insight: The circular nature of alphabets means moves repeat every 26 steps. Count requirements by remainder class, then verify sufficient moves exist in each class.

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 Apple 3

The optimal solution uses a counting approach with modular arithmetic. Key insight: multiple moves can provide the same shift (e.g., moves 1, 27, 53 all give shift 1). We count required shifts for each remainder class, then verify we have enough moves available in each class. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Counting Approach (Optimal)	O(n + k)	O(1)	Count required shifts and available shifts, then match them efficiently
Brute Force (Try All Assignments)	O(k! × n)	O(k)	Try every possible assignment of moves to string positions

Counting Approach (Optimal) — Algorithm Steps

Calculate required shift for each position that differs between s and t
Count frequency of each shift amount (1-26) needed
For each shift amount, calculate how many moves ≤ k can provide it
Check if available moves ≥ required moves for each shift amount

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Required Shifts

Group positions by required shift amount

Count Available Moves

For each shift type, count how many moves provide it

Match Requirements

Check if supply meets demand for each shift

Code -

solution.c — C

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

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

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

O(n) to process string differences, O(k) to count available moves (but k can be optimized to O(26) since we only care about remainders)

✓ Linear Growth

Space Complexity

O(1)

Only need arrays of size 26 to count shifts, which is constant space

✓ Linear Space

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Counting Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler