Get Equal Substrings Within Budget - Practice Coding Problems

Get Equal Substrings Within Budget - Problem

Imagine you're a text editor developer working on a smart autocorrect feature. You have two strings: s (the current text) and t (the target text), both of the same length. You want to transform s into t, but each character change has a cost.

The cost of changing the i-th character of s to the i-th character of t is |s[i] - t[i]| (the absolute difference between their ASCII values). For example, changing 'a' to 'c' costs |97 - 99| = 2.

Given a budget of maxCost, find the maximum length of a contiguous substring that you can completely transform from s to match the corresponding substring in t.

Think of it as finding the longest segment of text you can autocorrect within your computational budget!

Input & Output

example_1.py — Basic Case

$ Input: s = "abcd", t = "bcdf", maxCost = 3

› Output: 3

💡 Note: We can change "abc" to "bcd" with costs |a-b| + |b-c| + |c-d| = 1 + 1 + 1 = 3, which equals maxCost. Length = 3.

example_2.py — Larger Budget

$ Input: s = "abcd", t = "cdef", maxCost = 3

› Output: 1

💡 Note: Each character change costs 2, so with maxCost=3, we can change at most 1 character. Any single character can be changed within budget.

example_3.py — Zero Budget

$ Input: s = "abcd", t = "acde", maxCost = 0

› Output: 1

💡 Note: With maxCost=0, we can only include characters that don't need changing. The first character 'a' matches, so length = 1.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Start Editing

Begin with an empty selection and gradually expand to include more characters

Check Budget

As you include each character, add its correction cost to your total

Manage Resources

When your budget is exceeded, remove characters from the beginning of your selection

Find Optimum

Keep track of the largest selection you could afford throughout the process

Key Takeaway

🎯 Key Insight: The sliding window technique is perfect for finding the optimal contiguous subarray with a sum constraint, achieving linear time complexity by avoiding redundant calculations.

Asked in

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

This problem is optimally solved using the sliding window technique in O(n) time. The key insight is that we need the longest contiguous substring where the sum of character transformation costs is ≤ maxCost. By maintaining a window with two pointers and expanding/shrinking based on the current cost, we can efficiently find the maximum length without checking all possible subarrays.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n log n)	O(1)	Binary search on the length, check if each length is achievable within budget
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible substring and calculate its total cost
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to find maximum length substring within budget

Binary Search on Answer — Algorithm Steps

Binary search on length from 0 to n
For each candidate length, use sliding window to check feasibility
If length is achievable within maxCost, try larger lengths
If not achievable, try smaller lengths
Return the maximum achievable length

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search bounds

left = 0, right = string length

Check middle length

Use sliding window to check if mid length is achievable

Adjust bounds

If achievable, search for larger lengths; otherwise, search smaller

Code -

solution.c — C

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

int abs_diff(char a, char b) {
    return abs(a - b);
}

int canAchieveLength(char* s, char* t, int maxCost, int targetLength) {
    if (targetLength == 0) return 1;
    
    int currentCost = 0;
    int n = strlen(s);
    
    // Calculate cost for first window
    for (int i = 0; i < targetLength; i++) {
        currentCost += abs_diff(s[i], t[i]);
    }
    
    if (currentCost <= maxCost) return 1;
    
    // Slide the window
    for (int i = targetLength; i < n; i++) {
        currentCost -= abs_diff(s[i - targetLength], t[i - targetLength]);
        currentCost += abs_diff(s[i], t[i]);
        
        if (currentCost <= maxCost) return 1;
    }
    
    return 0;
}

int equalSubstring(char* s, char* t, int maxCost) {
    int left = 0, right = strlen(s);
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieveLength(s, t, maxCost, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char s[1000], t[1000];
    int maxCost;
    scanf("%s %s %d", s, t, &maxCost);
    printf("%d\n", equalSubstring(s, t, maxCost));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(log n) binary search iterations × O(n) sliding window check for each length

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search bounds and sliding window pointers

✓ Linear Space

52.0K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler