Find Positive Integer Solution for a Given Equation

Find Positive Integer Solution for a Given Equation - Problem

You are given a mysterious black box function f(x, y) that takes two positive integers and returns a positive integer. Your mission is to reverse engineer this function by finding all pairs of positive integers (x, y) where f(x, y) == z for a given target value z.

Here's what you know about the function:
• The exact formula is hidden from you
• The function is monotonically increasing in both dimensions:
- f(x, y) < f(x + 1, y) (increasing as x increases)
- f(x, y) < f(x, y + 1) (increasing as y increases)

Goal: Return all positive integer pairs [x, y] where f(x, y) == z. The pairs can be returned in any order.

Example: If f(x, y) = x + y and z = 3, then the answer would be [[1,2], [2,1]] because f(1,2) = 3 and f(2,1) = 3.

Input & Output

example_1.py — Basic Function

$ Input: function_id = 1, z = 5 # Hidden function: f(x, y) = x + y

› Output: [[1,4], [2,3], [3,2], [4,1]]

💡 Note: The function f(x, y) = x + y, so we need to find all positive integer pairs where x + y = 5. The valid pairs are (1,4), (2,3), (3,2), and (4,1).

example_2.py — Multiplicative Function

$ Input: function_id = 2, z = 5 # Hidden function: f(x, y) = x * y

› Output: [[1,5], [5,1]]

💡 Note: The function f(x, y) = x * y, so we need to find all positive integer pairs where x * y = 5. Since 5 is prime, only (1,5) and (5,1) work.

example_3.py — No Solutions

$ Input: function_id = 1, z = 1 # Hidden function: f(x, y) = x + y

› Output: []

💡 Note: The function f(x, y) = x + y, but since x and y must be positive integers (≥ 1), the minimum value of x + y is 2. Therefore, there are no solutions for z = 1.

Visualization

Tap to expand

Understanding the Visualization

Start Smart

Begin at the top-right corner (small x, large y) where we have the best information

Compare & Decide

If f(x,y) > target: move left (smaller y). If f(x,y) < target: move down (larger x)

Eliminate Regions

Each move eliminates an entire row or column from consideration

Collect Solutions

When f(x,y) = target, record the solution and continue searching

Key Takeaway

🎯 Key Insight: By starting from a strategic corner and using the monotonic property, each comparison eliminates an entire row or column, reducing time complexity from O(n²) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(X × Y)

Where X and Y are the upper bounds for x and y coordinates. In worst case, this could be O(z²) if the function grows slowly

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting the output array

✓ Linear Space

Constraints

1 ≤ function_id ≤ 9
1 ≤ z ≤ 100
f(x, y) is monotonically increasing
1 ≤ x, y ≤ 1000
The function will return an integer in the range [1, 10⁹]

Asked in

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

The optimal approach uses two pointers technique starting from a strategic corner of the search grid. By leveraging the monotonically increasing property of the function, we can eliminate entire rows or columns with each comparison, achieving O(X + Y) time complexity instead of the brute force O(X × Y). This makes it significantly more efficient for large search spaces.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(X × Y)	O(1)	Try every possible (x, y) pair within reasonable bounds
Binary Search for Each Row	O(X × log Y)	O(1)	For each x value, binary search to find y values where f(x,y) = z
Two Pointers (Smart Grid Traversal)	O(X + Y)	O(1)	Start from corners and move intelligently using monotonic property

Brute Force (Nested Loops) — Algorithm Steps

Determine reasonable upper bounds for x and y by testing f(i, 1) and f(1, i)
Use nested loops to iterate through all possible (x, y) pairs
For each pair, call f(x, y) and check if it equals z
If equal, add [x, y] to the result list
Return all found pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Bounds

Determine reasonable upper bounds for x and y

Nested Loops

Use nested loops to check every (x,y) pair

Function Call

Call f(x,y) for each coordinate

Compare

Check if f(x,y) equals target z

Collect Results

Add matching pairs to result list

Code -

solution.c — C

int** findSolution(int (*customfunction)(int, int), int z, int* returnSize, int** returnColumnSizes) {
    int** result = (int**)malloc(1000 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    // Find reasonable upper bounds
    int maxX = 1000;
    int maxY = 1000;
    
    // Refine bounds by testing
    while (maxX > 1 && customfunction(maxX, 1) > z) {
        maxX /= 2;
    }
    while (maxY > 1 && customfunction(1, maxY) > z) {
        maxY /= 2;
    }
    
    maxX = (maxX * 2 < 1000) ? maxX * 2 : 1000;
    maxY = (maxY * 2 < 1000) ? maxY * 2 : 1000;
    
    // Brute force search
    for (int x = 1; x <= maxX; x++) {
        for (int y = 1; y <= maxY; y++) {
            int val = customfunction(x, y);
            if (val == z) {
                result[*returnSize] = (int*)malloc(2 * sizeof(int));
                result[*returnSize][0] = x;
                result[*returnSize][1] = y;
                (*returnColumnSizes)[*returnSize] = 2;
                (*returnSize)++;
            } else if (val > z) {
                break; // No need to check larger y values for this x
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(X × Y)

Where X and Y are the upper bounds for x and y coordinates. In worst case, this could be O(z²) if the function grows slowly

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting the output array

✓ Linear Space

Constraints

1 ≤ function_id ≤ 9
1 ≤ z ≤ 100
f(x, y) is monotonically increasing
1 ≤ x, y ≤ 1000
The function will return an integer in the range [1, 10⁹]

52.3K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler