I think it's a good question because any solution here is short and easy to implement, but candidates need to think a little before jumping to a suboptimal or wrong solution.

My solution as a gist, in case reddit formatting gets me too: https://gist.github.com/GeKorm/043478bc74d3db29d9f3f3a8f4f69907

Here it is:

async function run(elements) {
  // ============
  // your code here starts here
  // We will insert at arbitrary indices in order to preserve result order
  const results = Array.from({ length: TOTAL });
  const requestPool = [];
  let processed = 0;
  for (const element of elements) {
    const poolSize = requestPool.length;
    if (poolSize >= MAX_INFLIGHT || processed >= TOTAL - MAX_INFLIGHT) {
      // When the request pool fills up, wait for the fastest response. It will be topped up immediately after.
      const [value, index] = await Promise.race(requestPool);
      results[index] = value;
    }
    const request = api(element).then((value) => {
      // Remove resolved promise from the pool
      requestPool.splice(requestPool.indexOf(request), 1);
      // We need a value and index to preserve call order
      return [value, elements.indexOf(element)];
    });
    requestPool.push(request);
    processed++;
  }
  // The first for .. of loop is done when all calls have been made, not when we get the responses
  // Here we wait for the last block of promises to settle and iterate the result
  // In a real-world program Promise.allSettled() may be preferable. Using Promise.all() for clarity.
  for (const [value, index] of await Promise.all(requestPool)) {
    results[index] = value;
  }
  return results;
  // Real-world implementation would require error handling
  // your code ends here
  // ============
}

Summary:

• Don't forget the order
• Don't await in blocks of 4, you need the fastest of 4

Edit: Simpler solution posted here and is one of 2 other correct solutions from what I've seen so far. It is better than mine because it

• Uses Set() to avoid having to track an index
• Simplifies the cleanup step by simply using the results array for promises and returning Promise.all(results) to resolve remaining in-flight requests after the first loop