Kth Smallest Number in Multiplication Table

Kth Smallest Number in Multiplication Table - Problem

Imagine you're looking at a multiplication table that every student learns in elementary school, but this time it's arranged as a matrix! 📊

Given three integers m, n, and k, you need to find the k-th smallest element in an m × n multiplication table where mat[i][j] = i * j (using 1-based indexing).

For example, a 3×3 multiplication table looks like:

[1, 2, 3]
[2, 4, 6]
[3, 6, 9]

Your task is to find the k-th smallest number when all elements are considered in sorted order: 1, 2, 2, 3, 3, 4, 6, 6, 9

The challenge: Can you do this without actually generating the entire table? 🤔

Input & Output

example_1.py — Small Table

$ Input: m = 3, n = 3, k = 5

› Output: 3

💡 Note: The 3×3 multiplication table is [[1,2,3],[2,4,6],[3,6,9]]. When flattened and sorted: [1,2,2,3,3,4,6,6,9]. The 5th smallest element is 3.

example_2.py — Rectangular Table

$ Input: m = 2, n = 3, k = 6

› Output: 6

💡 Note: The 2×3 multiplication table is [[1,2,3],[2,4,6]]. When flattened and sorted: [1,2,2,3,4,6]. The 6th (last) smallest element is 6.

example_3.py — Large K

$ Input: m = 4, n = 4, k = 10

› Output: 6

💡 Note: In a 4×4 table, sorted values are [1,2,2,3,3,3,4,4,4,6,6,6,8,8,9,12,16]. The 10th smallest is 6.

Constraints

1 ≤ m, n ≤ 3 × 10⁴
1 ≤ k ≤ m × n
Memory constraint: Cannot store all m×n values for large inputs

Visualization

Tap to expand

Understanding the Visualization

Set Search Range

Initialize binary search between 1 and m×n (smallest and largest possible values)

Make a Guess

Pick the middle value and count how many table elements are ≤ this guess

Smart Counting

For each row i, count min(guess/i, n) elements that are ≤ guess

Adjust Range

If count ≥ k, answer could be this or smaller. If count < k, answer is larger

Converge

Repeat until we find the exact k-th smallest value

Key Takeaway

🎯 Key Insight: Instead of generating O(mn) values, we binary search on the answer and count elements ≤ our guess in O(m) time, achieving optimal O(m log(mn)) complexity!

Asked in

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

The optimal solution uses binary search on the answer with a smart counting function. Instead of generating all m×n values, we binary search on the range [1, m×n] and for each candidate answer, count how many elements are ≤ that value using the formula: count = Σ min(x/i, n) for i from 1 to m. Time complexity: O(m log(mn)), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Values (Brute Force)	O(mn log(mn))	O(mn)	Generate entire multiplication table, sort, and return k-th element
Binary Search on Answer (Optimal)	O(m log(mn))	O(1)	Binary search on possible values and count elements ≤ mid without generating the table

Generate All Values (Brute Force) — Algorithm Steps

Create an array to store all m×n multiplication results
Generate all values: for each i from 1 to m, for each j from 1 to n, add i×j to array
Sort the array in ascending order
Return the element at index k-1 (converting from 1-indexed to 0-indexed)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Table

Create all i×j values for the multiplication table

Sort Values

Sort all generated values in ascending order

Pick Kth

Select the k-th element from sorted array

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int findKthNumber(int m, int n, int k) {
    // Generate all multiplication table values
    int* values = (int*)malloc(m * n * sizeof(int));
    int idx = 0;
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            values[idx++] = i * j;
        }
    }
    
    // Sort all values
    qsort(values, m * n, sizeof(int), compare);
    
    // Return k-th smallest (1-indexed)
    int result = values[k - 1];
    free(values);
    return result;
}

int main() {
    int m, n, k;
    scanf("%d %d %d", &m, &n, &k);
    printf("%d\n", findKthNumber(m, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn log(mn))

O(mn) to generate all values + O(mn log(mn)) for sorting

⚡ Linearithmic

Space Complexity

O(mn)

Need to store all mn values in memory

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Generate All Values (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler