IsOdd

In this medium-level challenge, you'll implement an IsOdd<T> type that determines whether a given number type is an odd integer, returning true for odd integers and false otherwise.

type cases = [
  Expect<Equal<IsOdd<5>, true>>,
  Expect<Equal<IsOdd<2023>, true>>,
  Expect<Equal<IsOdd<1453>, true>>,
  Expect<Equal<IsOdd<1926>, false>>,
  Expect<Equal<IsOdd<2.3>, false>>,
  Expect<Equal<IsOdd<3e23>, false>>,
  Expect<Equal<IsOdd<3>, true>>,
  Expect<Equal<IsOdd<number>, false>>,
]

Detailed Explanation

type IsOdd<T extends number> =
  number extends T
    ? false
    : `${T}` extends `${string}${'1' | '3' | '5' | '7' | '9'}`
      ? true
      : false;

How it works:

• The first check number extends T handles the wide number type. If T is not a specific numeric literal, we cannot determine oddness, so we return false.
• We convert the number to its string representation using the template literal `${T}`.
• We then check if the string ends with one of the odd digits ('1', '3', '5', '7', '9') using the pattern `${string}${'1' | '3' | '5' | '7' | '9'}`.
• This correctly handles multi-digit numbers like 2023 (ends in '3', so odd) and 1926 (ends in '6', so even).
• Non-integer values like 2.3 have their string representation as "2.3", which ends in '3' -- but this is not a problem because the last character check only matters for integer-looking strings. Actually, "2.3" does end in '3', so we need the scientific notation edge case: 3e23 becomes "3e+23" which ends in '3' but should be false. However, looking at the test cases, 3e23 returns false because "3e+23" ends in '3'... Let me reconsider.

A more robust solution that also rejects non-integers:

type IsOdd<T extends number> =
  number extends T
    ? false
    : `${T}` extends `${bigint}`
      ? `${T}` extends `${string}${'1' | '3' | '5' | '7' | '9'}`
        ? true
        : false
      : false;

How this improved version works:

• After ruling out the wide number type, we first verify T is an integer by checking if its string representation matches `${bigint}`. This rejects decimals like 2.3 and scientific notation like 3e+23.
• Only for confirmed integers do we check if the last digit is odd.
• 2.3 converts to "2.3" which does not match bigint, so it returns false.
• 3e23 converts to "3e+23" which does not match bigint, so it returns false.
• 5 converts to "5" which matches bigint and ends in '5', so it returns true.

This challenge helps you understand template literal types for numeric string analysis and how to apply these patterns in real-world scenarios.