Maximum 69 Number - Practice Coding Problems

Maximum 69 Number - Problem

Math Greedy Easy

Imagine you have a special number made up of only 6s and 9s - like a digital display where some segments might be flipped! Your mission is to make this number as large as possible by flipping at most one digit.

🔄 The Rule: You can change exactly one digit:

6 → 9 (increases the number)
9 → 6 (decreases the number)

Goal: Return the maximum possible number you can achieve.

Example: Given 9669, you can change the first 6 to 9 to get 9969 - but is this optimal? 🤔

Input & Output

example_1.py — Basic Case

$ Input: num = 9669

› Output: 9969

💡 Note: We can change the first 6 to 9 to get 9969, which is the maximum possible.

example_2.py — All 9s

$ Input: num = 9996

› Output: 9969

💡 Note: No 6s to change to 9, so we change the rightmost 9 to 6 to minimize the decrease.

example_3.py — Single Digit

$ Input: num = 9

› Output: 6

💡 Note: Only one digit available, and since it's 9, we change it to 6.

Constraints

1 ≤ num ≤ 10⁴
num consists only of digits 6 and 9
You can change at most one digit

Visualization

Tap to expand

Understanding the Visualization

Scan from Left

Start from the most significant digit - changes here have the biggest impact

Find First 6

The first 6 we encounter can be flipped to 9 for maximum gain

Flip and Return

Change that 6 to 9 and we're done - this gives us the maximum possible value

All 9s Case

If no 6s exist, flip the rightmost 9 to 6 to minimize the loss

Key Takeaway

🎯 Key Insight: The greedy approach works because changing the leftmost digit has the maximum impact on the final number value. Always prioritize the most significant positions!

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 5

The optimal solution uses a greedy approach: find the leftmost 6 and change it to 9 for maximum impact. If no 6 exists, change the rightmost 9 to 6 to minimize the decrease. This achieves O(n) time complexity with a single pass through the digits.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Single Pass (Optimal)	O(n)	O(n)	Find the first 6 from left and change it to 9, or change last 9 to 6
Try All Possible Changes	O(n²)	O(n)	Convert to string, try changing each digit, and find maximum

Greedy Single Pass (Optimal) — Algorithm Steps

Convert number to string for digit access
Scan from left to right to find the first '6'
If found, change it to '9' and return the result
If no '6' found, change the last '9' to '6'
Convert back to integer and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Left to Right

Look for the first '6' from the most significant digit

Found First 6

Change it to '9' for maximum impact on the final value

No 6 Found

If all digits are '9', change the rightmost '9' to '6'

Return Result

Convert the modified string back to integer

Code -

solution.c — C

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

int maximumSwap(int num) {
    char digits[20];
    sprintf(digits, "%d", num);
    int n = strlen(digits);
    
    // Find the first '6' from left
    for (int i = 0; i < n; i++) {
        if (digits[i] == '6') {
            digits[i] = '9';
            return atoi(digits);
        }
    }
    
    // If no '6' found, change the last '9' to '6'
    digits[n-1] = '6';
    return atoi(digits);
}

int main() {
    int num;
    scanf("%d", &num);
    printf("%d\n", maximumSwap(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the digits to find first 6 or process all digits

✓ Linear Growth

Space Complexity

O(n)

Space needed to store string representation of the number

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~8 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 Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler