1class Solution {
2    // Precomputed factorials for digits 0 through 9
3    private static final int[] FACTORIAL = new int[10];
4
5    // Static initializer block to populate the factorial table
6    static {
7        FACTORIAL[0] = 1; // 0! = 1
8        for (int i = 1; i < 10; i++) {
9            FACTORIAL[i] = FACTORIAL[i - 1] * i; // i! = (i-1)! * i
10        }
11    }
12
13    /**
14     * Determines whether the sum of the factorials of n's digits,
15     * when written out, is a permutation of the digits of n itself.
16     *
17     * @param n the input number to check
18     * @return true if the digit-factorial sum is a permutation of n, false otherwise
19     */
20    public boolean isDigitorialPermutation(int n) {
21        int factorialSum = 0; // Accumulates the sum of factorials of each digit
22        int remaining = n;    // Working copy of n used for digit extraction
23
24        // Extract each digit and add its factorial to the running sum
25        while (remaining > 0) {
26            factorialSum += FACTORIAL[remaining % 10]; // Add factorial of the last digit
27            remaining /= 10;                           // Drop the last digit
28        }
29
30        // Convert both the factorial sum and the original number to character arrays
31        char[] sumDigits = String.valueOf(factorialSum).toCharArray();
32        char[] numberDigits = String.valueOf(n).toCharArray();
33
34        // Sort both arrays so that a permutation comparison becomes a direct equality check
35        Arrays.sort(sumDigits);
36        Arrays.sort(numberDigits);
37
38        // The two are permutations of each other if their sorted digit arrays match
39        return Arrays.equals(sumDigits, numberDigits);
40    }
41}
42

1class Solution {
2public:
3    bool isDigitorialPermutation(int n) {
4        // Precompute factorials for digits 0-9 (lazy initialization)
5        static int factorial[10];
6        static bool isInitialized = false;
7
8        if (!isInitialized) {
9            factorial[0] = 1;
10            for (int i = 1; i < 10; ++i) {
11                factorial[i] = factorial[i - 1] * i;
12            }
13            isInitialized = true;
14        }
15
16        // Compute the sum of factorials of each digit of n
17        int digitFactorialSum = 0;
18        int remaining = n;
19
20        while (remaining > 0) {
21            digitFactorialSum += factorial[remaining % 10]; // add factorial of the last digit
22            remaining /= 10;                                 // drop the last digit
23        }
24
25        // Convert both numbers to strings for digit comparison
26        string sumDigits = to_string(digitFactorialSum);
27        string originalDigits = to_string(n);
28
29        // Sort the digits so a permutation check becomes an equality check
30        sort(sumDigits.begin(), sumDigits.end());
31        sort(originalDigits.begin(), originalDigits.end());
32
33        // n is a "digitorial permutation" if both share the exact same multiset of digits
34        return sumDigits == originalDigits;
35    }
36};
37

1// Precompute factorials for digits 0 through 9.
2const factorials: number[] = new Array(10);
3factorials[0] = 1;
4for (let i = 1; i < 10; i++) {
5    factorials[i] = factorials[i - 1] * i;
6}
7
8/**
9 * Determines whether the sum of the factorials of the digits of `n`
10 * is a permutation of the digits of `n` itself.
11 *
12 * @param n - The non-negative integer to check.
13 * @returns `true` if the digit-factorial sum is a permutation of `n`'s digits.
14 */
15function isDigitorialPermutation(n: number): boolean {
16    // Accumulate the sum of factorials of each digit.
17    let digitFactorialSum = 0;
18    // Working copy of `n` used to extract digits.
19    let remaining = n;
20
21    // Process each digit from least significant to most significant.
22    while (remaining > 0) {
23        const digit = remaining % 10;
24        digitFactorialSum += factorials[digit];
25        remaining = Math.floor(remaining / 10);
26    }
27
28    // Sort the digits of the factorial sum to form a canonical signature.
29    const sumSignature = digitFactorialSum.toString().split('').sort().join('');
30    // Sort the digits of the original number to form its canonical signature.
31    const originalSignature = n.toString().split('').sort().join('');
32
33    // The number qualifies when both signatures match (i.e. same multiset of digits).
34    return sumSignature === originalSignature;
35}
36