Find Positive Integer Solution for a Given Equation

Find Positive Integer Solution for a Given Equation - Problem

Given a callable function f(x, y) with a hidden formula and a value z, reverse engineer the formula and return all positive integer pairs x and y where f(x,y) == z.

You may return the pairs in any order. While the exact formula is hidden, the function is monotonically increasing, i.e.:

f(x, y) < f(x + 1, y)
f(x, y) < f(x, y + 1)

The function interface is defined like this:

interface CustomFunction {
    public:
    // Returns some positive integer f(x, y) for two positive integers x and y based on a formula.
    int f(int x, int y);
};

We will judge your solution as follows: The judge has a list of 9 hidden implementations of CustomFunction, along with a way to generate an answer key of all valid pairs for a specific z. The judge will receive two inputs: a function_id (to determine which implementation to test your code with), and the target z. The judge will call your findSolution and compare your results with the answer key.

Input & Output

Example 1 — Simple Addition Function

$ Input: function_id = 1, z = 5

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

💡 Note: Assuming f(x,y) = x + y, we need pairs where x + y = 5. Valid positive integer pairs are (1,4), (2,3), (3,2), (4,1).

Example 2 — Product Function

$ Input: function_id = 2, z = 6

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

💡 Note: Assuming f(x,y) = x * y, we need pairs where x * y = 6. Valid positive integer pairs are (1,6), (2,3), (3,2), (6,1).

Example 3 — Large Target

$ Input: function_id = 1, z = 100

› Output: [[1,99],[2,98],...[99,1]]

💡 Note: For f(x,y) = x + y with target 100, there are 99 valid pairs from (1,99) to (99,1).

Constraints

The function f is defined for you
1 ≤ z ≤ 100
It's guaranteed that the solutions of f(x, y) == z will be on the range 1 ≤ x, y ≤ 1000
It's also guaranteed that f(x, y) will fit in 32-bit signed integer if 1 ≤ x, y ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is leveraging the monotonically increasing property of the function to eliminate large search spaces efficiently. The two-pointer approach is optimal, starting from a corner and navigating based on comparison results. Time: O(x + y), Space: O(k).

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Binary Search on Y

⏱️ Time: O(x log y) Space: O(k)

Fix x and use binary search on y to find values where f(x,y) = z. Since f is monotonically increasing in y, we can binary search efficiently.

Brute Force

⏱️ Time: O(n²) Space: O(k)

Try every combination of x and y values from 1 to some upper limit. Since we don't know the exact bounds, we estimate based on the target value z.

Two Pointers

⏱️ Time: O(x + y) Space: O(k)

Start from top-right corner (x=1, y=max) or bottom-left. Use the monotonic property: if f(x,y) > z, decrease y; if f(x,y) < z, increase x. This eliminates entire rows/columns efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(char* word, int m, int* returnSize) {
    int n = strlen(word);
    int* div = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    int remainder = 0;
    
    for (int i = 0; i < n; i++) {
        int digit = word[i] - '0';
        remainder = (remainder * 10 + digit) % m;
        if (remainder == 0) {
            div[i] = 1;
        } else {
            div[i] = 0;
        }
    }
    
    return div;
}

int main() {
    char word[100001];
    int m;
    
    if (fgets(word, sizeof(word), stdin) != NULL) {
        word[strcspn(word, "\n")] = 0;
    }
    scanf("%d", &m);
    
    int returnSize;
    int* result = solution(word, m, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

892 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