# Solving Leetcode Interviews in Seconds with AI: K-th Smallest Prime Fraction


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "786" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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 kth smallest fraction considered. Return your answer as an array of integers of size 2, where answer[0] == arr[i] and answer[1] == arr[j].   Example 1:  Input: arr = [1,2,3,5], k = 3 Output: [2,5] Explanation: The fractions to be considered in sorted order are: 1/5, 1/3, 2/5, 1/2, 3/5, and 2/3. The third fraction is 2/5.  Example 2:  Input: arr = [1,7], k = 1 Output: [1,7]    Constraints:  2 <= arr.length <= 1000 1 <= arr[i] <= 3 * 104 arr[0] == 1 arr[i] is a prime number for i > 0. All the numbers of arr are unique and sorted in strictly increasing order. 1 <= k <= arr.length * (arr.length - 1) / 2    Follow up: Can you solve the problem with better than O(n2) complexity?

	# Explanation
	Here's a solution to find the kth smallest fraction from the given array, focusing on efficiency:

*   **Binary Search:** The core idea is to perform a binary search on the possible range of fraction values (from 0 to 1).
*   **Fraction Counting:** For each mid-value in the binary search, count how many fractions `arr[i] / arr[j]` are less than or equal to the `mid`.
*   **Adjustment:** Adjust the binary search range based on whether the count is less than, equal to, or greater than `k`.

*   **Runtime Complexity:** O(n log n log(max_val)), where n is the length of the array and max_val is the largest element in arr.  The outer log n factor comes from the binary search on fraction values. The inner log n comes from `bisect_left`.
    **Storage Complexity:** O(1)

	
	# Code
	```python
	from bisect import bisect_left

def kthSmallestPrimeFraction(arr, k):
    """
    Finds the kth smallest fraction formed by pairs from a sorted array of primes.

    Args:
        arr: A sorted array of integers (1 and prime numbers).
        k: The kth smallest fraction to find.

    Returns:
        A list of two integers representing the numerator and denominator of the kth smallest fraction.
    """
    n = len(arr)
    low = 0.0
    high = 1.0

    while low < high:
        mid = (low + high) / 2.0
        count = 0
        max_frac = 0.0
        p, q = 0, 1  # Store the numerator and denominator of the largest fraction <= mid

        j = 1
        for i in range(n - 1):
            while j < n and arr[i] > mid * arr[j]:
                j += 1
            count += n - j

            if j < n and (arr[i] / arr[j]) > max_frac:
                max_frac = (arr[i] / arr[j])
                p, q = arr[i], arr[j]

        if count == k:
            return [p, q]
        elif count < k:
            low = mid
        else:
            high = mid

    return []
	```