Fixed-Length Combination Sum

Given integers k and target, return every combination of exactly k distinct integers from 1 through 9 whose sum is target.
Each value may be selected at most once.
Values within a combination must be increasing.
Return the combinations in lexicographic order.

Function
fixedLengthCombinationSum(k: int, target: int) → int[][]

Examples
Example 1
k = 3
target = 7
return = [[1,2,4]]
The only three distinct values from 1 through 9 that sum to 7 are 1, 2, and 4.
Example 2
k = 3
target = 9
return = [[1,2,6],[1,3,5],[2,3,4]]
These are all increasing three-value combinations with sum 9.
Example 3
k = 4
target = 1
return = []
The smallest sum of four distinct positive values is greater than 1.

Constraints
1 <= k <= 9.
1 <= target <= 60.

The trick is backtracking with a start index. Pick values in increasing order, so each combination is built once and comes out sorted. Iterate from the start value up to 9, add the number, recurse with start+1, then remove it. Lexicographic order comes free if you loop ascending. Prune hard: stop when the current sum exceeds target, stop when the path already has k values, and skip when there aren't enough numbers left to fill k slots. Common pitfalls are reusing a value by recursing with the same index, forgetting to copy the path before appending it to results, and returning nothing for impossible cases like k=4, target=1 instead of an empty list. With only 9 values, the search is at most 512 subsets, so performance isn't the risk. Correctness is. If you freeze on the recursion, StealthCoder is the hedge during the live OA.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.