Extra Characters in a String - Practice Coding Problems

Extra Characters in a String - Problem

You're given a string s and a dictionary of valid words. Your goal is to break down the string into dictionary words with the minimum number of leftover characters.

Think of it like a word puzzle: you want to use as many characters as possible to form valid dictionary words, leaving behind the fewest "extra" characters that can't be used.

Example: If s = "leetscode" and dictionary = ["leet", "code", "leetcode"], you could break it as:

"leet" + "code" → uses 8 characters, 0 extra ✅
"leetcode" → uses 8 characters, 0 extra ✅
Skip breaking → uses 0 characters, 9 extra ❌

Return the minimum number of extra characters when you break the string optimally.

Input & Output

example_1.py — Basic Word Matching

$ Input: s = "leetscode", dictionary = ["leet","code","leetcode"]

› Output: 0

💡 Note: We can break "leetscode" as "leet" + "code" using both dictionary words, leaving 0 extra characters. Alternatively, we could use "leetcode" + skip "s" + skip "code" but that would give us 1 extra character.

example_2.py — Some Extra Characters

$ Input: s = "sayhelloworld", dictionary = ["hello","world"]

› Output: 3

💡 Note: We can break it as: skip "s", skip "a", skip "y", "hello", "world". This leaves us with 3 extra characters (s, a, y) that couldn't be matched with any dictionary words.

example_3.py — No Dictionary Matches

$ Input: s = "xyz", dictionary = ["abc","def"]

› Output: 3

💡 Note: None of the characters in "xyz" can form any dictionary words, so all 3 characters are extra.

Constraints

1 ≤ s.length ≤ 50
1 ≤ dictionary.length ≤ 50
1 ≤ dictionary[i].length ≤ 50
s and dictionary[i] consist of only lowercase English letters
dictionary contains distinct words

Visualization

Tap to expand

Understanding the Visualization

Scan Position

Start from each position in the string

Try Dictionary Words

Check if any dictionary word can fit starting at current position

Make Decision

Either skip character (add to extras) or use a valid dictionary word

Optimize Recursively

Use memoization to remember best results for each position

Key Takeaway

🎯 Key Insight: At each position, we make an optimal choice between skipping (1 extra) or using dictionary words, building up the solution using previously computed results through dynamic programming.

Asked in

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

This problem is solved optimally using Dynamic Programming with Memoization. The key insight is that at each position, we can either skip the character (count as extra) or try using any dictionary word that starts at that position. We use a hash set for O(1) dictionary lookups and memoization to avoid recomputing the same subproblems, achieving O(n² + n×m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(2^n)	O(n)	Try all possible ways to break the string recursively
Dynamic Programming (Optimal)	O(n² + n*m)	O(n + W)	Use memoization to avoid recalculating subproblems

Recursive Brute Force — Algorithm Steps

Start from the beginning of the string
At each position, try skipping the character (count as 1 extra)
Also try each dictionary word that can start at this position
Recursively solve for the remaining substring
Return the minimum extra characters across all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin processing from the first character

Branch decisions

At each position, try skipping or using dictionary words

Recursive calls

Explore each branch completely before backtracking

Take minimum

Return the minimum extra characters across all branches

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_WORDS 1000

int solve(char* s, char dictionary[][MAX_LEN], int dictSize, int index, int sLen) {
    if (index >= sLen) {
        return 0;
    }
    
    // Option 1: Skip current character (count as extra)
    int result = 1 + solve(s, dictionary, dictSize, index + 1, sLen);
    
    // Option 2: Try each word from dictionary
    for (int i = 0; i < dictSize; i++) {
        int wordLen = strlen(dictionary[i]);
        if (index + wordLen <= sLen && 
            strncmp(s + index, dictionary[i], wordLen) == 0) {
            int candidate = solve(s, dictionary, dictSize, index + wordLen, sLen);
            if (candidate < result) {
                result = candidate;
            }
        }
    }
    
    return result;
}

int minExtraChar(char* s, char dictionary[][MAX_LEN], int dictSize) {
    return solve(s, dictionary, dictSize, 0, strlen(s));
}

int main() {
    char s[MAX_LEN];
    char dictionary[MAX_WORDS][MAX_LEN];
    int dictSize = 0;
    
    // Simple input parsing
    scanf("\"%s\"", s);
    
    char temp[MAX_LEN * 10];
    scanf("%s", temp);
    
    // Parse dictionary (simplified)
    char* token = strtok(temp, "[],\"");
    while (token != NULL && dictSize < MAX_WORDS) {
        strcpy(dictionary[dictSize], token);
        dictSize++;
        token = strtok(NULL, "[],\"");
    }
    
    printf("%d\n", minExtraChar(s, dictionary, dictSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

At each position, we make up to 2 choices, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack can go as deep as the string length

⚡ Linearithmic Space

68.4K Views

Medium-High Frequency

~25 min Avg. Time

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

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler