Kth Smallest Instructions - Practice Coding Problems

Kth Smallest Instructions - Problem

Imagine Bob is on a treasure hunt on a grid! Bob starts at the top-left corner (0, 0) and wants to reach his treasure at position (row, column). However, Bob can only move in two directions:

'H' - Move horizontally (right)
'V' - Move vertically (down)

For example, to reach (2, 3), Bob needs exactly 3 H's and 2 V's. Valid instruction sequences include "HHHVV", "HVHVH", "VHHVH", and many more!

Here's the twist: Bob has a lucky number k, and he wants the k-th lexicographically smallest instruction sequence. Since 'H' comes before 'V' alphabetically, "HHHVV" would come before "HVHVH".

Goal: Given the destination coordinates and Bob's lucky number k, return the k-th lexicographically smallest instruction sequence that will get Bob to his treasure!

Input & Output

example_1.py — Basic Case

$ Input: destination = [2, 3], k = 1

› Output: "HHHVV"

💡 Note: To reach (2,3), we need 3 H's and 2 V's. The lexicographically smallest sequence puts all H's first, giving us "HHHVV".

example_2.py — Middle Sequence

$ Input: destination = [2, 3], k = 2

› Output: "HHVHV"

💡 Note: The second lexicographically smallest sequence. After "HHHVV", we get "HHVHV" by moving one V earlier while keeping the lexicographic order.

example_3.py — Last Sequence

$ Input: destination = [2, 3], k = 3

› Output: "HHVVH"

💡 Note: The third lexicographically smallest sequence follows the pattern of incrementally moving V's to earlier positions.

Constraints

1 ≤ destination[0], destination[1] ≤ 15
1 ≤ k ≤ C(destination[0] + destination[1], destination[0])
k is guaranteed to be valid (within the range of possible sequences)

Visualization

Tap to expand

Understanding the Visualization

Setup Navigation

Calculate total moves needed: 3 right (H) and 2 down (V) for destination (2,3)

Decision Point Analysis

At each intersection, calculate how many routes start by going right vs down

Smart Routing Choice

Use combinatorics to determine optimal direction without exploring all paths

Update Route Parameters

Adjust remaining moves and target route number based on chosen direction

Key Takeaway

🎯 Key Insight: By using combinatorics to count possibilities at each decision point, we can jump directly to the k-th solution without generating all permutations - like having a mathematical GPS that calculates the optimal route instantly!

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses combinatorics to make binary decisions at each position. Instead of generating all permutations, we calculate how many sequences start with 'H' at each step using Pascal's triangle. This gives us O(m+n) time complexity and avoids the exponential cost of generating all possibilities.

Common Approaches

Approach	Time	Space	Notes
✓ Combinatorics with Binary Decisions (Optimal)	O(m + n)	O(min(m, n))	Use combinatorics to make binary decisions at each position without generating all permutations
Generate All Permutations	O((m+n)! / (m!×n!))	O((m+n)! / (m!×n!))	Generate all possible instruction sequences, sort them, and return the k-th one

Combinatorics with Binary Decisions (Optimal) — Algorithm Steps

Initialize counters for remaining H's and V's needed
For each position, calculate combinations: C(remaining_positions-1, remaining_H-1)
If k <= combinations starting with 'H', choose 'H' and decrement H count
Otherwise, choose 'V', subtract those combinations from k, and decrement V count
Repeat until all positions are filled

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total Moves

For destination (2,3): need 3 H's and 2 V's, total 5 moves

Make Binary Decision

At each position, calculate how many sequences start with 'H'

Use Combinations

Use C(remaining_positions-1, remaining_H-1) to count possibilities

Update Counters

Choose H or V based on k, then update remaining counts and k

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

char* kthSmallestPath(int* destination, int k) {
    int row = destination[0], col = destination[1];
    int total = row + col;
    
    // Precompute Pascal's triangle
    int** C = malloc((total + 1) * sizeof(int*));
    for (int i = 0; i <= total; i++) {
        C[i] = calloc(col + 1, sizeof(int));
    }
    
    for (int i = 0; i <= total; i++) {
        for (int j = 0; j <= min(i, col); j++) {
            if (j == 0 || j == i) {
                C[i][j] = 1;
            } else {
                C[i][j] = C[i-1][j-1] + C[i-1][j];
            }
        }
    }
    
    char* result = malloc((total + 1) * sizeof(char));
    int remainingH = col;
    int remainingV = row;
    
    for (int i = 0; i < total; i++) {
        if (remainingH == 0) {
            result[i] = 'V';
            remainingV--;
        } else if (remainingV == 0) {
            result[i] = 'H';
            remainingH--;
        } else {
            int remainingPositions = remainingH + remainingV - 1;
            int sequencesWithH = (remainingH > 0 && remainingPositions >= 0 && remainingH - 1 <= remainingPositions)
                ? C[remainingPositions][remainingH - 1]
                : 0;
                
            if (k <= sequencesWithH) {
                result[i] = 'H';
                remainingH--;
            } else {
                result[i] = 'V';
                k -= sequencesWithH;
                remainingV--;
            }
        }
    }
    
    result[total] = '\0';
    
    // Free memory
    for (int i = 0; i <= total; i++) {
        free(C[i]);
    }
    free(C);
    
    return result;
}

int main() {
    int destination[] = {2, 3};
    int k = 1;
    printf("%s\n", kthSmallestPath(destination, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

We make exactly m+n decisions, each taking O(1) time with precomputed combinations

✓ Linear Growth

Space Complexity

O(min(m, n))

Space for Pascal's triangle to compute combinations efficiently

⚡ Linearithmic Space

21.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Combinatorics with Binary Decisions (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler