Equalize Strings by Adding or Removing Characters at Ends

Equalize Strings by Adding or Removing Characters at Ends - Problem

Given two strings initial and target, your task is to modify initial by performing a series of operations to make it equal to target.

In one operation, you can add or remove one character only at the beginning or the end of the string initial.

Return the minimum number of operations required to transform initial into target.

Input & Output

Example 1 — Basic Transformation

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

› Output: 1

💡 Note: Remove 'b' from the middle by removing it from either end after rearranging. Actually, we can keep 'a' and 'c', so we need to remove 'b' (1 operation).

Example 2 — Complete Replacement

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

› Output: 6

💡 Note: No common characters, so remove all 3 characters from initial (3 ops) and add all 3 characters for target (3 ops) = 6 operations total.

Example 3 — Partial Overlap

$ Input: initial = "abcde", target = "cdefg"

› Output: 4

💡 Note: Keep common substring 'cde' (length 3). Remove 'ab' (2 ops) + add 'fg' (2 ops) = 4 operations.

Constraints

0 ≤ initial.length, target.length ≤ 1000
initial and target consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22

The key insight is to find the maximum characters we can keep unchanged and minimize the operations. The optimal approach uses Longest Common Subsequence (LCS) to find the maximum overlap. Time: O(n×m), Space: O(n×m).

Common Approaches

✓ Find Maximum Overlap

⏱️ Time: O(n×m²) Space: O(1)

This approach finds the maximum length substring of target that can be obtained by removing characters from both ends of initial. The remaining characters need to be changed.

Longest Common Subsequence Approach

⏱️ Time: O(n×m) Space: O(n×m)

Find the longest common subsequence between initial and target strings, then calculate the minimum operations needed as the sum of both string lengths minus twice the LCS length.

Try All Operation Sequences

⏱️ Time: O(4^(n+m)) Space: O(4^(n+m))

This approach tries all possible combinations of adding and removing characters from both ends of the initial string until it matches the target string.

Find Maximum Overlap — Algorithm Steps

For each substring of target
Check if it can be formed by removing characters from ends of initial
Track the maximum length achievable
Calculate operations as total length minus 2×max_overlap

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Substrings

Try all substrings of initial

Find in Target

See which ones appear in target

Calculate Operations

Operations = total - 2×max_overlap

Code -

solution.c — C

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

int solution(char* initial, char* target) {
    int n = strlen(initial), m = strlen(target);
    int maxKeep = 0;
    
    for (int i = 0; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            int subLen = j - i;
            if (subLen > maxKeep) {
                char temp[1001];
                strncpy(temp, initial + i, subLen);
                temp[subLen] = '\0';
                
                if (strstr(target, temp) != NULL) {
                    maxKeep = subLen;
                }
            }
        }
    }
    
    return n + m - 2 * maxKeep;
}

int main() {
    char initial[1001], target[1001];
    fgets(initial, sizeof(initial), stdin);
    fgets(target, sizeof(target), stdin);
    
    initial[strcspn(initial, "\n")] = 0;
    target[strcspn(target, "\n")] = 0;
    
    printf("%d\n", solution(initial, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m²)

For each position in initial (n), we check all substrings of target (m²)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

⚡ Linearithmic Space

23.4K 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

Find Maximum Overlap — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler