K-th Smallest Prime Fraction

K-th Smallest Prime Fraction - Problem

Array Two Pointers Binary Search Sorting Heap (Priority Queue) Medium

You are given a sorted integer array arr containing 1 and prime numbers, where all the integers of arr are unique. You are also given an integer k.

For every i and j where 0 <= i < j < arr.length, we consider the fraction arr[i] / arr[j].

Return the k-th smallest fraction considered. Return your answer as an array of integers of size 2, where answer[0] == arr[i] and answer[1] == arr[j].

Input & Output

Example 1 — Basic Case

$ Input: arr = [1,2,3,5], k = 3

› Output: [2,5]

💡 Note: All fractions: 1/2, 1/3, 1/5, 2/3, 2/5, 3/5. Sorted: 1/5, 1/3, 2/5, 1/2, 3/5, 2/3. The 3rd smallest is 2/5.

Example 2 — Different K Value

$ Input: arr = [1,7], k = 1

› Output: [1,7]

💡 Note: Only one fraction possible: 1/7, so the 1st smallest is 1/7.

Example 3 — Larger Array

$ Input: arr = [1,2,3,5,7], k = 4

› Output: [1,3]

💡 Note: All fractions in ascending order: 1/7, 1/5, 2/7, 1/3, 1/2, 2/5, 3/7, 3/5, 2/3, 5/7. The 4th smallest fraction is 1/3.

Constraints

2 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 3 × 10⁴
arr[0] == 1
arr[i] is a prime number for i > 0
All the numbers of arr are unique and sorted in ascending order
1 ≤ k ≤ arr.length × (arr.length - 1) / 2

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that we need to find the k-th smallest fraction efficiently from all possible pairs. The binary search on answer space approach is optimal with O(n log W) time complexity, where we binary search on fraction values and count how many fractions are smaller than each candidate value.

Common Approaches

✓ Binary Search on Answer Space

⏱️ Time: O(n log W) Space: O(1)

Use binary search on the range [0, 1] to find the exact value such that there are exactly k fractions smaller than or equal to it.

Generate All Fractions and Sort

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

Create all fractions arr[i]/arr[j] where i < j, sort by value, and pick the k-th one. Simple but inefficient for large inputs.

Priority Queue (Min Heap)

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

Start with fractions having the smallest possible denominators, use a min heap to always get the next smallest fraction, and expand candidates as needed.

Binary Search on Answer Space — Algorithm Steps

Binary search on fraction values between 0 and 1
For each mid value, count fractions <= mid using two pointers
Adjust search range based on count vs k

Visualization

Tap to expand

Step-by-Step Walkthrough

Range

Binary search between 0.0 and 1.0

Count

For each mid value, count fractions ≤ mid

Adjust

Narrow range based on count vs k

Code -

solution.c — C

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

void countFractions(int *arr, int n, double maxVal, int *result) {
    int count = 0;
    int bestNum = 0, bestDen = 0;
    int j = 1;
    
    for (int i = 0; i < n - 1; i++) {
        // Find the largest j such that arr[i]/arr[j] <= maxVal
        while (j < n && arr[i] > maxVal * arr[j]) {
            j++;
        }
        
        if (j < n) {
            count += n - j;
            // Track the largest fraction <= maxVal
            if (bestNum * arr[j] < bestDen * arr[i]) {
                bestNum = arr[i];
                bestDen = arr[j];
            }
        }
    }
    
    result[0] = count;
    result[1] = bestNum;
    result[2] = bestDen;
}

void solution(int *arr, int n, int k, int *result) {
    double left = 0.0, right = 1.0;
    
    while (right - left > 1e-9) {
        double mid = (left + right) / 2;
        int tempResult[3];
        countFractions(arr, n, mid, tempResult);
        int count = tempResult[0];
        
        if (count < k) {
            left = mid;
        } else {
            right = mid;
        }
    }
    
    // Find the actual k-th fraction
    int finalResult[3];
    countFractions(arr, n, right, finalResult);
    result[0] = finalResult[1];
    result[1] = finalResult[2];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int arr[100];
    int n = 0;
    char *token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result[2];
    solution(arr, n, k, result);
    printf("[%d,%d]\n", result[0], result[1]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log W)

Binary search iterations O(log W) where W is precision range, each iteration counts in O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra variables for binary search and counting

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~35 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler