K-th Smallest Prime Fraction - Practice Coding Problems

K-th Smallest Prime Fraction - Problem

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

K-th Smallest Prime Fraction

You're given a sorted array containing 1 and prime numbers, where all integers are unique. Your task is to find the k-th smallest fraction formed by dividing any element by a larger element in the array.

For every pair of indices i and j where 0 <= i < j < arr.length, we can form the fraction arr[i] / arr[j]. Among all such fractions, return the k-th smallest one as an array [numerator, denominator].

Example: For array [1, 2, 3, 5], possible fractions are: 1/2, 1/3, 1/5, 2/3, 2/5, 3/5. If k=3, we return [2, 5] since 2/5 is the 3rd smallest fraction.

Input & Output

example_1.py — Basic Case

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

› Output: [2, 5]

💡 Note: All fractions in ascending order: 1/5, 1/3, 2/5, 1/2, 3/5, 2/3. The 3rd fraction is 2/5.

example_2.py — First Fraction

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

› Output: [1, 7]

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

example_3.py — Larger Array

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

› Output: [2, 7]

💡 Note: With 5 numbers, we have 10 possible fractions. The 5th smallest is 2/7.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Set Search Range

Initialize binary search bounds from 0 to 1 (all possible fraction values)

Count Efficiently

For each mid value, use two pointers to count fractions ≤ mid in O(n) time

Track Best Candidate

While counting, remember the largest fraction that's still ≤ mid

Narrow Search

Adjust search range based on whether we found too few or too many fractions

Find Exact Match

When count equals k, return the tracked best candidate fraction

Key Takeaway

🎯 Key Insight: Instead of generating all O(n²) fractions, we binary search on the fraction value and use two pointers to count fractions ≤ target in O(n) time, achieving optimal O(n log(max_val)) complexity.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 20 Apple 15

The optimal approach uses binary search on the answer with two-pointer counting. Since we need the k-th smallest fraction, we binary search on fraction values [0,1] and for each candidate value, efficiently count how many fractions are ≤ that value using two pointers on the sorted array. This achieves O(n log(max_val)) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Fractions)	O(n² log n)	O(n²)	Generate all possible fractions, sort them, and return the k-th smallest
Binary Search on Answer	O(n log(max_val))	O(1)	Binary search on fraction values, count fractions ≤ target using two pointers

Brute Force (Generate All Fractions) — Algorithm Steps

Generate all fractions arr[i]/arr[j] where i < j
Store each fraction with its numerator and denominator indices
Sort all fractions by their decimal values
Return the numerator and denominator of the k-th fraction

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Fractions

Create all possible fractions arr[i]/arr[j] where i < j

Sort Fractions

Sort all fractions by their decimal values

Select k-th

Return the k-th element from sorted list

Code -

solution.c — C

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

typedef struct {
    double value;
    int num;
    int den;
} Fraction;

int compare(const void *a, const void *b) {
    Fraction *fa = (Fraction *)a;
    Fraction *fb = (Fraction *)b;
    if (fa->value < fb->value) return -1;
    if (fa->value > fb->value) return 1;
    return 0;
}

int* kthSmallestPrimeFraction(int* arr, int arrSize, int k, int* returnSize) {
    Fraction *fractions = malloc(arrSize * arrSize * sizeof(Fraction));
    int count = 0;
    
    // Generate all possible fractions
    for (int i = 0; i < arrSize; i++) {
        for (int j = i + 1; j < arrSize; j++) {
            fractions[count].value = (double)arr[i] / arr[j];
            fractions[count].num = arr[i];
            fractions[count].den = arr[j];
            count++;
        }
    }
    
    // Sort by fraction value
    qsort(fractions, count, sizeof(Fraction), compare);
    
    // Return the k-th smallest
    int *result = malloc(2 * sizeof(int));
    result[0] = fractions[k-1].num;
    result[1] = fractions[k-1].den;
    *returnSize = 2;
    
    free(fractions);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n²) to generate all fractions, O(n² log n) to sort them

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store all O(n²) possible fractions

⚠ Quadratic Space

38.5K Views

Medium-High Frequency

~25 min Avg. Time

1.2K 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 (Generate All Fractions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler