MinusOne

In this medium-level challenge, you'll implement MinusOne<T>, a type that takes a positive number literal type and returns the number decreased by one, handling values up to very large numbers.

type Zero = MinusOne<1> // 0
type FiftyFour = MinusOne<55> // 54

Detailed Explanation

type ParseInt<T extends string> =
  T extends `${infer N extends number}` ? N : never;
 
type ReverseString<S extends string> =
  S extends `${infer First}${infer Rest}`
    ? `${ReverseString<Rest>}${First}`
    : '';
 
type SubOneMap = {
  '0': '9';
  '1': '0';
  '2': '1';
  '3': '2';
  '4': '3';
  '5': '4';
  '6': '5';
  '7': '6';
  '8': '7';
  '9': '8';
};
 
type RemoveLeadingZeros<S extends string> =
  S extends `0${infer Rest}`
    ? Rest extends ''
      ? '0'
      : RemoveLeadingZeros<Rest>
    : S;
 
type SubOneReversed<S extends string> =
  S extends `${infer D extends keyof SubOneMap}${infer Rest}`
    ? D extends '0'
      ? `9${SubOneReversed<Rest>}`
      : `${SubOneMap[D]}${Rest}`
    : '';
 
type MinusOne<T extends number> =
  ParseInt<RemoveLeadingZeros<ReverseString<SubOneReversed<ReverseString<`${T}`>>>>>;

How it works:

• Since TypeScript's type system cannot directly perform arithmetic on number literal types, this solution operates on the string representation of the number digit by digit
• ReverseString reverses the digits so we can process from the least significant digit (ones place) first
• SubOneReversed works on the reversed string: if the current digit is '0', it becomes '9' and the borrow carries to the next digit (recursion continues); otherwise, it decrements the digit using SubOneMap and keeps the remaining digits unchanged
• RemoveLeadingZeros strips any leading zeros that result from subtraction (e.g., 100 - 1 = 099 becomes 99), while preserving a single '0' for the result of 1 - 1
• ParseInt converts the final string back into a number literal type using template literal inference with infer N extends number
• This string-based approach avoids tuple length limitations and can handle very large numbers like 9_007_199_254_740_992

This challenge helps you understand type-level arithmetic via string manipulation, and how to apply these concepts in real-world scenarios.