FirstUniqueCharIndex

In this medium-level challenge, you'll find the first non-repeating character in a string and return its index. If no unique character exists, you return -1, inspired by LeetCode problem 387.

Detailed Explanation

We need a helper type to check if a character appears in a string, then iterate through each character to find the first one that does not appear in the rest of the string (and has not been seen before).

type Contains<
  S extends string,
  C extends string
> = S extends `${infer _}${C}${infer _Rest}` ? true : false
 
type FirstUniqueCharIndex<
  T extends string,
  Index extends any[] = [],
  Seen extends string = never
> = T extends `${infer First}${infer Rest}`
  ? First extends Seen
    ? FirstUniqueCharIndex<Rest, [...Index, 1], Seen>
    : Contains<Rest, First> extends true
      ? FirstUniqueCharIndex<Rest, [...Index, 1], Seen | First>
      : Index['length']
  : -1

How it works:

• Contains<S, C> checks whether character C appears anywhere in string S using template literal inference
• We iterate through T one character at a time, maintaining an Index counter and a Seen union of characters already known to be duplicated
• If First is already in Seen, it has been encountered before and is a duplicate, so we skip it
• If First is not in Seen but appears in Rest, it is a duplicate -- we add it to Seen and continue
• If First is not in Seen and does not appear in Rest, it is the first unique character, so we return Index['length']
• If we exhaust the entire string without finding a unique character, we return -1

This challenge helps you understand string character iteration with duplicate detection and how to apply this concept in real-world scenarios.