Longest Common Prefix

In this medium-level challenge, you'll implement LongestCommonPrefix, a type that finds the longest common prefix string shared among all strings in a given tuple, returning an empty string if no common prefix exists.

type Common = LongestCommonPrefix<["flower", "flow", "flight"]>
//   ?^ "fl"
 
type Uncommon = LongestCommonPrefix<["dog", "racecar", "race"]>
//   ?^ ""

Detailed Explanation

type LongestCommonPrefix<
  T extends string[],
  Prefix extends string = ''
> = T extends [infer First extends string, ...infer Rest extends string[]]
  ? First extends `${Prefix}${infer C}${string}`
    ? AllStartWith<Rest, `${Prefix}${C}`> extends true
      ? LongestCommonPrefix<T, `${Prefix}${C}`>
      : Prefix
    : Prefix
  : Prefix;
 
type AllStartWith<T extends string[], P extends string> =
  T extends [infer First extends string, ...infer Rest extends string[]]
    ? First extends `${P}${string}`
      ? AllStartWith<Rest, P>
      : false
    : true;

How it works:

• LongestCommonPrefix takes the first string from the tuple and attempts to extend the current Prefix by one character at a time using template literal inference (${Prefix}${infer C}${string})
• The helper type AllStartWith checks whether every remaining string in the tuple starts with the candidate prefix, returning true only if all strings match
• If all strings share the extended prefix, the type recurses with the new longer prefix; otherwise it returns the current prefix as the result
• The base cases handle empty tuples (returning the accumulated prefix) and strings that have been fully consumed (also returning the current prefix)
• Empty strings in the tuple naturally cause the recursion to stop early, since an empty string cannot match ${Prefix}${infer C}${string} when the prefix is non-empty

This challenge helps you understand recursive template literal type manipulation and tuple iteration, and how to apply these concepts in real-world scenarios.