Find the Maximum Achievable Number - Practice Coding Problems

Find the Maximum Achievable Number - Problem

Math Easy

You're given two integers: num and t. Your goal is to find the maximum achievable number x that can become equal to num after applying a special operation at most t times.

The operation is unique: you can increase or decrease both x and num by 1 simultaneously. This means in a single operation, you can:

Increase both x and num by 1, OR
Decrease both x and num by 1

The key insight is that since both numbers change together, you're effectively controlling the gap between them. Return the maximum possible starting value of x.

Example: If num = 4 and t = 1, you could start with x = 6. Then decrease both by 1: x becomes 5, num becomes 3. They're still 2 apart, but we've used our operation.

Input & Output

example_1.py — Basic Case

$ Input: num = 4, t = 1

› Output: 6

💡 Note: Start with x = 6. After 1 operation of decreasing both by 1: x becomes 5, num becomes 3. We can't make them equal, but if we start with x = 6 and increase both by 1: x becomes 7, num becomes 5. Still not equal. Actually, we need x = 4 + 2*1 = 6. Starting with x = 6, we decrease both by 1 twice? No, we only have 1 operation. The maximum achievable x is num + 2*t = 4 + 2*1 = 6.

example_2.py — Multiple Operations

$ Input: num = 3, t = 2

› Output: 7

💡 Note: With 2 operations available, we can start with x = 7. The gap between x and num is 4, which equals 2*t. We can close this gap by decreasing both numbers twice, making x = 5 and num = 1, or by using operations strategically to make them equal.

example_3.py — No Operations

$ Input: num = 10, t = 0

› Output: 10

💡 Note: With no operations allowed, x must already equal num, so the maximum achievable x is 10.

Constraints

1 ≤ t ≤ 50
-10⁹ ≤ num ≤ 10⁹
Both num and t are integers

Visualization

Tap to expand

Understanding the Visualization

Maximum Starting Position

Start x as far right as possible while still reachable

Close the Gap

Each operation can close the gap by 2 (move toward each other)

Perfect Meeting

After t operations, they meet at the same position

Key Takeaway

🎯 Key Insight: The maximum achievable x is num + 2*t because each operation can close the gap by at most 2, so we need at most 2*t initial gap.

Asked in

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

This problem has an elegant mathematical solution: the maximum achievable x is simply num + 2*t. Since both numbers change by the same amount in each operation, the gap between them changes by 2 per operation. To maximize x, we want the largest possible starting gap, which is 2*t.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(2^t)	O(t)	Try different starting values of x and simulate all possible operation sequences

Brute Force Simulation — Algorithm Steps

Start with a reasonable range of x values to test
For each x, generate all possible sequences of t operations
Apply each sequence and check if final x equals final num
Return the maximum x that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with x and num

Begin with initial values

Branch on operations

Try both increase and decrease

Recursively explore

Continue until operations are exhausted

Check equality

See if final values match

Code -

solution.c — C

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

bool dfs(int x, int num, int operationsLeft) {
    if (operationsLeft == 0) {
        return x == num;
    }
    
    // Try increasing both
    if (dfs(x + 1, num + 1, operationsLeft - 1)) {
        return true;
    }
    
    // Try decreasing both
    if (dfs(x - 1, num - 1, operationsLeft - 1)) {
        return true;
    }
    
    return false;
}

bool canAchieve(int x, int num, int t) {
    return dfs(x, num, t);
}

int theMaximumAchievableX(int num, int t) {
    int maxX = INT_MIN;
    
    // Test a reasonable range around num
    for (int startX = num - t - 10; startX <= num + t + 10; startX++) {
        if (canAchieve(startX, num, t)) {
            if (startX > maxX) {
                maxX = startX;
            }
        }
    }
    
    return maxX;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^t)

For each starting x, we try 2^t possible sequences of operations

✓ Linear Growth

Space Complexity

O(t)

Space for recursion stack or storing operation sequences

✓ Linear Space

8.9K Views

Medium Frequency

~5 min Avg. Time

245 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler