Minimum Operations to Make a Special Number

Minimum Operations to Make a Special Number - Problem

You're given a string num representing a non-negative integer. Your task is to make this number special by deleting as few digits as possible.

A number is considered special if it's divisible by 25. This means the number must end in one of these patterns: 00, 25, 50, or 75.

Operations allowed:

Delete any digit from the string
If all digits are deleted, the number becomes 0 (which is divisible by 25)

Goal: Return the minimum number of deletions needed to make the number divisible by 25.

Example: For num = "2245047", you can delete "2245047" → "2250" (delete '4' and '7') to get a number ending in '50', which requires 2 operations.

Input & Output

example_1.py — Basic Pattern Matching

$ Input: num = "2245047"

› Output: 2

💡 Note: We can delete digits to form "2250" (ending in 50, divisible by 25). Delete positions with '4' and '7', requiring 2 operations.

example_2.py — Multiple Valid Patterns

$ Input: num = "2908305"

› Output: 3

💡 Note: Multiple patterns possible: keep "00" (4 deletions), keep "25" (5 deletions), keep "50" (5 deletions), or make "0" (6 deletions). Best is keeping "00" with 4 deletions... wait, let me recalculate: we can make "2250" by deleting '9','8','3' (3 deletions).

example_3.py — Edge Case: Single Zero

$ Input: num = "0"

› Output: 0

💡 Note: The number is already 0, which is divisible by 25. No operations needed.

Constraints

1 ≤ num.length ≤ 10⁵
num consists of only digits
num does not contain any leading zeros except for the number 0 itself

Visualization

Tap to expand

Understanding the Visualization

Identify Target

Numbers divisible by 25 must end in: 00, 25, 50, or 75

Work Backwards

Scan from right to find each pattern with minimum deletions

Special Case

Consider making the number 0 by keeping just one zero

Choose Minimum

Return the pattern requiring the fewest deletions

Key Takeaway

🎯 Key Insight: Since divisibility by 25 requires specific ending patterns, we can work backwards greedily to find the optimal pattern with minimum deletions in linear time.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses greedy pattern matching by working backwards from the end to find valid ending patterns (00, 25, 50, 75). We scan from right to left to find these patterns with minimum deletions, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Pattern Matching (Optimal)	O(n)	O(1)	Work backwards to find valid ending patterns (00, 25, 50, 75) with minimum deletions
Brute Force (Try All Subsequences)	O(2^n)	O(n)	Generate all possible subsequences and check which ones are divisible by 25

Greedy Pattern Matching (Optimal) — Algorithm Steps

Work backwards to find the rightmost occurrence of each valid ending pattern
For patterns 25, 50, 75: find the second digit first, then find the first digit
For pattern 00: find the rightmost 0, then find another 0 to its left
Handle special case: count zeros for making the entire number 0
Return the minimum deletions among all valid patterns

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Second Digit

Scan from right to find the rightmost occurrence of pattern's second digit

Find First Digit

Scan backwards from second digit to find first digit of pattern

Calculate Deletions

Count how many digits need to be deleted

Try All Patterns

Repeat for patterns 00, 25, 50, 75 and special case 0

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int minimumOperations(char* num) {
    int n = strlen(num);
    if (n == 1) {
        return (strcmp(num, "0") == 0) ? 0 : 1;
    }
    
    int minOps = INT_MAX;
    char patterns[][3] = {"00", "25", "50", "75"};
    
    for (int p = 0; p < 4; p++) {
        char first = patterns[p][0];
        char second = patterns[p][1];
        
        // Find rightmost occurrence of second digit
        int secondPos = -1;
        for (int i = n - 1; i >= 0; i--) {
            if (num[i] == second) {
                secondPos = i;
                break;
            }
        }
        
        if (secondPos == -1) continue;
        
        // Find rightmost occurrence of first digit
        int firstPos = -1;
        for (int i = secondPos - 1; i >= 0; i--) {
            if (num[i] == first) {
                firstPos = i;
                break;
            }
        }
        
        if (firstPos != -1) {
            int deletions = n - 2;
            minOps = min(minOps, deletions);
        }
    }
    
    // Special case: make number 0
    int zeroCount = 0;
    for (int i = 0; i < n; i++) {
        if (num[i] == '0') zeroCount++;
    }
    if (zeroCount > 0) {
        minOps = min(minOps, n - 1);
    }
    
    return (minOps == INT_MAX) ? n : minOps;
}

int main() {
    char num[32];
    scanf("%s", num);
    if (num[0] == '"') {
        int len = strlen(num);
        memmove(num, num+1, len-2);
        num[len-2] = '\0';
    }
    printf("%d\n", minimumOperations(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string for each pattern, total 4 passes maximum

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track positions and counts

✓ Linear Space

23.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Greedy Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler