Code Review (Easy): Ordering the Tests

Story

Lena was tasked with creating a system to assign unique access keys for the team's internal testing environment. Eva asked her to build a small utility that could generate a specific sequence of digits from a sorted list of all possible arrangements. This way, if Mark needed to recreate a specific test case, he could just request the exact order by its position in the list. For example, if they were working with four digits and needed the ninth possible arrangement, the tool would provide the sequence "2314".

Your Task

Read the story and code, then decide if the code is ready for production or needs improvement.

Hints

What would block an approval? Give me a hint.

Check out Next Topic: Organizing the Workspace

export function getPermutation(n: number, k: number): string {
  // check if n is less than or equal to zero and handle that case
  if (n <= 0) return ""; 
  // create an array to hold factorial values up to n
  const factorial: number[] = new Array(n + 1);
  // set the factorial of zero to one
  factorial[0] = 1;
  // loop to fill factorial values from 1 to n
  for (let i = 1; i <= n; i++) {
    // set factorial[i] to factorial[i - 1] multiplied by i
    factorial[i] = factorial[i - 1] * i;
  }
  // verify that k is within the valid range of 1 to n!
  if (k < 1 || k > factorial[n]) throw new Error("k out of range");
  // prepare an array of number strings from 1 to n
  const numbers: string[] = [];
  // fill the numbers array with string representations of 1..n
  for (let i = 1; i <= n; i++) {
    // push the current number as a string into the numbers array
    numbers.push(i.toString());
  }
  // convert k to a zero-based index for calculation
  let kAdj = k - 1;
  // initialize the result as an empty string
  let result = "";
  // iterate from n down to 1 to construct the permutation
  for (let i = n; i >= 1; i--) {
    // get the factorial for (i - 1)
    const f = factorial[i - 1];
    // compute the index by dividing kAdj by f and flooring the result
    const idx = Math.floor(kAdj / f);
    // remove the element at idx from numbers and append it to the result
    result += numbers.splice(idx, 1)[0];
    // update kAdj to the remainder after removing the block accounted for
    kAdj %= f;
  }
  // return the constructed permutation string
  return result;
}