Strange Printer - Practice Coding Problems

Strange Printer - Problem

Imagine you have a peculiar printer that operates under very specific constraints. This printer can only print sequences of identical characters at a time, and it has a unique ability to overwrite existing characters by printing new ones on top.

Here's how it works:

🖨️ The printer can only print the same character repeatedly in one operation
📍 Each print operation can start and end at any positions you choose
✏️ New characters will cover and replace any existing characters in that range

Given a target string s, your challenge is to determine the minimum number of print operations needed to produce this exact string. This is a fascinating problem that combines string manipulation with dynamic programming optimization!

For example, to print "aba":

Operation 1: Print "aaa" → result: "aaa"
Operation 2: Print "b" at position 1 → result: "aba"
Total: 2 operations

Input & Output

example_1.py — Basic Case

$ Input: s = "aaabbb"

› Output: 2

💡 Note: Print "aaa" first, then print "bbb" to get "aaabbb". Total: 2 operations.

example_2.py — Interleaved Characters

$ Input: s = "aba"

› Output: 2

💡 Note: Print "aaa" first to get "aaa", then print "b" at position 1 to get "aba". Total: 2 operations.

example_3.py — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: Print "a" once. Total: 1 operation.

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters only
The string is non-empty for most test cases

Visualization

Tap to expand

Understanding the Visualization

Choose Base Color

For each section, pick the first character as base color

Paint Full Range

Paint this color across the entire range you're working on

Find Corrections

Identify positions that need different colors

Optimize Splits

When same colors appear later, merge operations by splitting optimally

Combine Results

Sum up the minimum operations for all subproblems

Key Takeaway

🎯 Key Insight: When the same character appears at different positions in a range, we can paint them together in one operation, then recursively solve the segments in between. Memoization ensures each subproblem is solved only once.

Asked in

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

The optimal solution uses dynamic programming with memoization to avoid recomputing overlapping subproblems. The key insight is that when characters at different positions are the same, we can merge print operations by printing the character across a larger range and then recursively fixing the differences. This reduces the time complexity from exponential O(3ⁿ) to polynomial O(n³).

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(3^n)	O(n)	Try all possible ways to partition and print the string recursively
Dynamic Programming with Memoization (Optimal)	O(n³)	O(n²)	Use memoized recursion to avoid recomputing overlapping subproblems

Recursive Brute Force — Algorithm Steps

For each substring, try printing the first character across the entire substring
Then recursively solve for the remaining parts that need different characters
Try every possible split point and take the minimum operations needed
Base case: empty string needs 0 operations, single character needs 1 operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Call

Start with solve(0, n-1) for entire string

Branch Creation

For each position, create branches for different split points

Recursive Calls

Recursively solve left and right subproblems

Minimum Selection

Take minimum operations across all possible splits

Code -

solution.c — C

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

int solve(char* s, int start, int end) {
    if (start > end) return 0;
    if (start == end) return 1;
    
    // Print s[start] from start to end, then fix differences
    int result = 1 + solve(s, start + 1, end);
    
    // Try to find characters same as s[start] and split there
    for (int i = start + 1; i <= end; i++) {
        if (s[i] == s[start]) {
            int current = solve(s, start, i - 1) + solve(s, i, end);
            if (current < result) {
                result = current;
            }
        }
    }
    
    return result;
}

int strangePrinter(char* s) {
    int len = strlen(s);
    if (len == 0) return 0;
    return solve(s, 0, len - 1);
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0';  // Remove newline
    printf("%d\n", strangePrinter(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

Each position can be: start of new segment, continuation, or split point, leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels deep

⚡ Linearithmic Space

52.3K Views

Medium Frequency

~25 min Avg. Time

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