Number Theory: Perfect Numbers, Abundant, and Digit Problems

def digit_sum(n):
    return sum(int(d) for d in str(n))

def reverse_number(n):
    sign = -1 if n < 0 else 1
    return sign * int(str(abs(n))[::-1])

def is_palindrome_number(n):
    if n < 0 or (n % 10 == 0 and n != 0):
        return False
    rev = 0
    while n > rev:
        rev = rev * 10 + n % 10
        n //= 10
    return n == rev or n == rev // 10  # odd-length: n == rev//10

def proper_divisor_sum(n):
    total = 1  # 1 is always a proper divisor
    i = 2
    while i * i <= n:
        if n % i == 0:
            total += i
            if i != n // i:
                total += n // i
        i += 1
    return total

def classify(n):
    s = proper_divisor_sum(n)
    if s == n: return "perfect"
    elif s > n: return "abundant"
    else: return "deficient"

# Amicable pairs: a and b where sum_div(a)=b and sum_div(b)=a
def find_amicable_pairs(limit):
    pairs = []
    for a in range(2, limit):
        b = proper_divisor_sum(a)
        if b > a and proper_divisor_sum(b) == a:
            pairs.append((a, b))
    return pairs

def is_armstrong(n):
    digits = str(n)
    power = len(digits)
    return n == sum(int(d)**power for d in digits)

def is_happy(n):
    seen = set()
    while n != 1 and n not in seen:
        seen.add(n)
        n = sum(int(d)**2 for d in str(n))
    return n == 1

#include <bits/stdc++.h>
using namespace std;

bool isPalindrome(long long n) {
    if (n < 0) return false;
    long long orig = n, rev = 0;
    while (n > 0) { rev = rev * 10 + n % 10; n /= 10; }
    return orig == rev;
}

int digitSum(int n) {
    int s = 0;
    while (n > 0) { s += n % 10; n /= 10; }
    return s;
}

// LeetCode 202: Happy Number
bool isHappy(int n) {
    auto next = [](int n) {
        int s = 0;
        while (n) { int d = n%10; s += d*d; n/=10; }
        return s;
    };
    int slow = n, fast = next(n);
    while (fast != 1 && slow != fast) {
        slow = next(slow);
        fast = next(next(fast));
    }
    return fast == 1;
}

public class NumberTheory {
    public static boolean isPalindrome(int x) {
        if (x < 0 || (x % 10 == 0 && x != 0)) return false;
        int rev = 0;
        while (x > rev) {
            rev = rev * 10 + x % 10;
            x /= 10;
        }
        return x == rev || x == rev / 10;
    }

    public static boolean isHappy(int n) {
        Set<Integer> seen = new HashSet<>();
        while (n != 1 && !seen.contains(n)) {
            seen.add(n);
            int sum = 0;
            while (n > 0) { int d = n % 10; sum += d * d; n /= 10; }
            n = sum;
        }
        return n == 1;
    }
}