Equalize Strings by Adding or Removing Characters at Ends

Equalize Strings by Adding or Removing Characters at Ends - Problem

Imagine you have a magical word transformer that can only work at the beginning and end of strings! Given two strings initial and target, your mission is to transform the initial string into the target string using the minimum number of operations.

In each operation, you can:

Add one character at the beginning or end of initial
Remove one character from the beginning or end of initial

Goal: Find the minimum number of operations needed to make initial equal to target.

Example: If initial = "abc" and target = "def", you could remove all 3 characters from initial and add 3 new ones, requiring 6 operations total.

Input & Output

example_1.py — Basic Transformation

$ Input: initial = "abc", target = "def"

› Output: 6

💡 Note: No common substring exists between "abc" and "def". We need to remove all 3 characters from initial (3 operations) and add all 3 characters of target (3 operations), totaling 6 operations.

example_2.py — Partial Overlap

$ Input: initial = "programming", target = "algorithm"

› Output: 14

💡 Note: The longest common substring is "gra" (length 3). We remove 11-3=8 characters from initial and add 9-3=6 characters to reach target. Total: 8+6=14 operations.

example_3.py — Identical Strings

$ Input: initial = "hello", target = "hello"

› Output: 0

💡 Note: The strings are already identical, so no operations are needed. The entire string is the common substring.

Visualization

Tap to expand

Understanding the Visualization

Identify Common Pattern

Find the longest pattern that exists in both ribbons

Plan Cuts

Decide which parts to cut from the ends of the first ribbon

Plan Additions

Decide what new pieces to attach to the ends

Calculate Total Work

Sum up all the cutting and attaching operations needed

Key Takeaway

🎯 Key Insight: The minimum operations equal the total length of both strings minus twice the length of their longest common substring, because we preserve the common part and replace everything else.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

O(n) substrings of initial × O(m) to check each in target string

✓ Linear Growth

Space Complexity

O(m)

Space for storing target string and hash lookups

✓ Linear Space

Constraints

0 ≤ initial.length, target.length ≤ 1000
initial and target consist of only lowercase English letters
Time limit: 2 seconds per test case
Memory limit: 256 MB

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a sliding window approach to find the longest common substring between the initial and target strings. Since we can only modify characters at the ends, the key insight is that any valid transformation must preserve some contiguous substring. The answer is len(initial) + len(target) - 2 × max_common_length, representing the characters we need to remove from initial plus the characters we need to add to reach target.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Substrings)	O(n³)	O(1)	Try every possible substring of initial and see which gives minimum operations
Sliding Window (Optimal)	O(n × m)	O(m)	Use sliding window to find the longest common substring efficiently

Brute Force (Try All Substrings) — Algorithm Steps

Generate all possible substrings of initial string
For each substring, calculate operations needed to transform to target
Operations = removals from initial + additions to make target
Return the minimum operations across all substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings of initial string

Check Validity

For each substring, check if it can appear in target

Calculate Cost

Count removals from initial + additions to reach target

Find Minimum

Track the minimum operations across all valid transformations

Code -

solution.c — C

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

bool canTransform(char* substring, char* target) {
    int subLen = strlen(substring);
    int targetLen = strlen(target);
    
    if (subLen > targetLen) return false;
    
    for (int i = 0; i <= targetLen - subLen; i++) {
        if (strncmp(target + i, substring, subLen) == 0) {
            return true;
        }
    }
    return false;
}

int minOperations(char* initial, char* target) {
    int n = strlen(initial);
    int minOps = strlen(initial) + strlen(target);
    char substring[1001];
    
    for (int i = 0; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            strncpy(substring, initial + i, j - i);
            substring[j - i] = '\0';
            
            if (canTransform(substring, target)) {
                int removals = i + (n - j);
                int additions = strlen(target) - strlen(substring);
                if (removals + additions < minOps) {
                    minOps = removals + additions;
                }
            }
        }
    }
    
    return minOps;
}

int main() {
    char initial[1001], target[1001];
    fgets(initial, sizeof(initial), stdin);
    fgets(target, sizeof(target), stdin);
    
    // Remove newlines and quotes
    initial[strcspn(initial, "\n")] = '\0';
    target[strcspn(target, "\n")] = '\0';
    
    if (initial[0] == '"') {
        memmove(initial, initial + 1, strlen(initial));
        initial[strlen(initial) - 1] = '\0';
        memmove(target, target + 1, strlen(target));
        target[strlen(target) - 1] = '\0';
    }
    
    printf("%d\n", minOperations(initial, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring against target

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

0 ≤ initial.length, target.length ≤ 1000
initial and target consist of only lowercase English letters
Time limit: 2 seconds per test case
Memory limit: 256 MB

39.0K Views

Medium Frequency

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

Brute Force (Try All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler