Lexicographically Smallest String After Applying Operations

Lexicographically Smallest String After Applying Operations - Problem

String Transformation Challenge: You're given a string s of even length consisting only of digits (0-9), along with two integers a and b. Your goal is to find the lexicographically smallest string possible by applying these two operations any number of times:

Add Operation: Add a to all digits at odd indices (1, 3, 5, ...). Digits wrap around after 9 (e.g., 8+3=1, 9+2=1)
Rotate Operation: Rotate the string b positions to the right

Example: If s = "5525", a = 9, b = 2:

Add 9 to odd indices: "5525" → "5424" (5+9=4, 2+9=1)
Rotate right by 2: "5424" → "2454"

Return the lexicographically smallest string achievable through any sequence of these operations.

Input & Output

example_1.py — Basic transformation

$ Input: s = "5525", a = 9, b = 2

› Output: "2050"

💡 Note: Starting with "5525", we can apply operations: add 9 to odd indices → "5424", rotate by 2 → "2454", continue exploring until we find "2050" as the lexicographically smallest.

example_2.py — Multiple rotations

$ Input: s = "74", a = 5, b = 1

› Output: "24"

💡 Note: From "74": add 5 to odd indices → "79", rotate by 1 → "97", add 5 → "92", rotate → "29", add 5 → "24". The smallest achievable string is "24".

example_3.py — No improvement possible

$ Input: s = "0011", a = 4, b = 2

› Output: "0011"

💡 Note: Starting with "0011", after exploring all possible operations, no string lexicographically smaller than "0011" can be achieved.

Visualization

Tap to expand

Understanding the Visualization

Start Position

Begin with the initial string configuration

Generate States

Apply both operations to create new possible states

Track Visited

Mark states as visited to avoid infinite cycles

Find Minimum

Keep track of the lexicographically smallest string encountered

Key Takeaway

🎯 Key Insight: Since the string length is finite and digits are bounded (0-9), there are only finitely many reachable states. BFS guarantees we find the lexicographically smallest string by exploring all possibilities systematically.

Time & Space Complexity

Time Complexity

⏱️

O(n * 10^n)

In worst case, we might visit all possible digit combinations (10^n) and for each state we do O(n) work

✓ Linear Growth

Space Complexity

O(10^n)

We store all visited states in a set, which could be up to 10^n different strings

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 100
s.length is even
s consists of digits from 0 to 9 only
1 ≤ a ≤ 9
1 ≤ b ≤ s.length - 1

Asked in

G Google 15 a Amazon 12 f Facebook 8 ⊞ Microsoft 5

The optimal approach uses BFS (Breadth-First Search) to explore all reachable string states by applying the two operations: adding a to odd-indexed digits and rotating by b positions. Since there are only finitely many possible strings, BFS guarantees finding the lexicographically smallest result with O(n × 10^n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ BFS State Exploration	O(n * 10^n)	O(10^n)	Use BFS to explore all possible string states until finding the lexicographically smallest

BFS State Exploration — Algorithm Steps

Start BFS with the original string
For each string, generate new states by applying both operations
Use a set to track visited states to avoid cycles
Keep track of the lexicographically smallest string seen
Continue until all reachable states are explored

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original string in queue

Apply Operations

Generate new states by adding to odd indices and rotating

Track Minimum

Keep track of lexicographically smallest string seen

Continue BFS

Process all reachable states until queue is empty

Code -

solution.c — C

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

#define MAX_STATES 100000
#define MAX_LEN 100

char* findLexSmallestString(char* s, int a, int b) {
    char states[MAX_STATES][MAX_LEN];
    int visited[MAX_STATES];
    int front = 0, rear = 0;
    int stateCount = 0;
    
    strcpy(states[rear++], s);
    visited[0] = 1;
    stateCount = 1;
    
    char* result = malloc(strlen(s) + 1);
    strcpy(result, s);
    
    while (front < rear) {
        char* current = states[front++];
        
        if (strcmp(current, result) < 0) {
            strcpy(result, current);
        }
        
        // Operation 1: Add a to all odd indices
        char addResult[MAX_LEN];
        strcpy(addResult, current);
        for (int i = 1; i < strlen(current); i += 2) {
            addResult[i] = '0' + ((current[i] - '0') + a) % 10;
        }
        
        // Check if addResult is new
        int found = 0;
        for (int i = 0; i < stateCount; i++) {
            if (strcmp(states[i], addResult) == 0) {
                found = 1;
                break;
            }
        }
        if (!found && stateCount < MAX_STATES) {
            strcpy(states[rear++], addResult);
            stateCount++;
        }
        
        // Operation 2: Rotate right by b positions
        char rotateResult[MAX_LEN];
        int n = strlen(current);
        int shift = b % n;
        strcpy(rotateResult, current + n - shift);
        strncat(rotateResult, current, n - shift);
        rotateResult[n] = '\0';
        
        // Check if rotateResult is new
        found = 0;
        for (int i = 0; i < stateCount; i++) {
            if (strcmp(states[i], rotateResult) == 0) {
                found = 1;
                break;
            }
        }
        if (!found && stateCount < MAX_STATES) {
            strcpy(states[rear++], rotateResult);
            stateCount++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 10^n)

In worst case, we might visit all possible digit combinations (10^n) and for each state we do O(n) work

✓ Linear Growth

Space Complexity

O(10^n)

We store all visited states in a set, which could be up to 10^n different strings

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 100
s.length is even
s consists of digits from 0 to 9 only
1 ≤ a ≤ 9
1 ≤ b ≤ s.length - 1

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

BFS State Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler