1class Solution {
2    /**
3     * Checks whether the sum of x * (x - 1) for every digit x of n is at least 50.
4     *
5     * @param n the input integer whose digits will be evaluated
6     * @return true if the accumulated sum reaches 50 or more, false otherwise
7     */
8    public boolean checkGoodInteger(int n) {
9        // Accumulator for the sum of x * (x - 1) over all digits.
10        int sum = 0;
11
12        // Process the number digit by digit, from least significant to most significant.
13        for (; n > 0; n /= 10) {
14            // Extract the current last digit.
15            int digit = n % 10;
16
17            // Add the contribution of this digit to the running sum.
18            sum += digit * (digit - 1);
19        }
20
21        // The integer is "good" only when the total reaches the threshold of 50.
22        return sum >= 50;
23    }
24}
25```
26
27**A note on correctness:** The current implementation only handles positive `n` (the loop condition `n > 0` skips `n == 0` and negative values). If you also need to support `n == 0` or negative numbers, consider taking the absolute value first and adjusting the loop condition. Here's an alternative perspective that covers those cases:
28
29```java
30class Solution {
31    public boolean checkGoodInteger(int n) {
32        // Work with the absolute value so negative inputs are handled consistently.
33        long value = Math.abs((long) n); // long avoids Integer.MIN_VALUE overflow
34
35        int sum = 0;
36
37        // Use a do-while so that n == 0 is still processed once.
38        do {
39            int digit = (int) (value % 10);
40            sum += digit * (digit - 1);
41            value /= 10;
42        } while (value > 0);
43
44        return sum >= 50;
45    }
46}
47

1class Solution {
2public:
3    bool checkGoodInteger(int n) {
4        // Accumulator for the weighted sum of all digits
5        int sum = 0;
6
7        // Iterate over each digit by repeatedly dividing by 10
8        for (; n > 0; n /= 10) {
9            // Extract the least significant digit
10            int digit = n % 10;
11
12            // Add the contribution of this digit: digit * (digit - 1)
13            sum += digit * (digit - 1);
14        }
15
16        // The integer is "good" if the accumulated sum reaches the threshold
17        return sum >= 50;
18    }
19};
20

1/**
2 * Determines whether the given integer is "good".
3 * A number is considered good when the sum of the value `digit * (digit - 1)`
4 * over all of its decimal digits is greater than or equal to 50.
5 *
6 * @param n - The non-negative integer to evaluate.
7 * @returns `true` if the computed sum is at least 50, otherwise `false`.
8 */
9function checkGoodInteger(n: number): boolean {
10    // Accumulator for the sum of digit * (digit - 1) across all digits.
11    let sum: number = 0;
12
13    // Process each decimal digit from least significant to most significant.
14    for (; n; n = Math.floor(n / 10)) {
15        // Extract the current least significant digit.
16        const digit: number = n % 10;
17
18        // Add this digit's contribution: digit * (digit - 1).
19        // Note: this yields 0 for digits 0 and 1, and increases for larger digits.
20        sum += digit * (digit - 1);
21    }
22
23    // The integer is "good" when the total reaches the threshold of 50.
24    return sum >= 50;
25}
26