Number Tricks: Digits, Carries, Bases and Modular Arithmetic

Peel digits with divmod. divmod(n, 10) gives the last digit and the rest in one step. Repeating it until the number is 0 visits every digit from the right: the digit sum of 9875 is 29. Reverse the order of work (read digits, then rebuild) to reverse a number.

def digit_sum(n):
    total = 0
    while n:
        n, d = divmod(n, 10)
        total += d
    return total

digit_sum(9875)   # 29

Carry like on paper. To add two numbers given as digit strings (too long for any integer type), start at the right ends, add the two digits plus the carry, keep sum % 10 and carry sum // 10. Keep going while either number has digits left or a carry remains: 999 + 1 ends with a carry that makes a fourth digit (1000).

def add_digits(a, b):
    out, carry = [], 0
    i, j = len(a) - 1, len(b) - 1
    while i >= 0 or j >= 0 or carry:
        s = carry
        if i >= 0:
            s += int(a[i]); i -= 1
        if j >= 0:
            s += int(b[j]); j -= 1
        out.append(str(s % 10))
        carry = s // 10
    return ''.join(reversed(out))

add_digits('999', '1')    # '1000'
add_digits('456', '77')   # '533'

Other bases are the same loop. Repeatedly divide by the base and collect remainders; the digits come out last-first, so reverse them. 255 is 11111111 in base 2 and FF in base 16; 100 is 202 in base 7 (2 x 49 + 0 x 7 + 2). Going the other way, multiply the running value by the base and add each digit.

Division and remainder with negatives. Python floors: -7 // 2 is -4 and -7 % 2 is 1, while int(-7 / 2) truncates toward zero and gives -3. Many languages truncate instead, so a solution that is right in one language can be off by one in another. Prefer integer arithmetic over floats whenever the answer must be exact.

Keep numbers small with a modulus. (a + b) % m and (a * b) % m can be taken at every step, which is how you compute huge powers: pow_mod squares the base and halves the exponent, so 2^10 mod 1000 takes four rounds instead of a million-digit number. Python also has pow(base, exp, mod) built in.

def pow_mod(base, exp, mod):
    result = 1
    base %= mod
    while exp:
        if exp & 1:
            result = result * base % mod
        base = base * base % mod
        exp >>= 1
    return result

pow_mod(3, 200, 13)   # 9

Euclid's gcd and the sieve. gcd(a, b): replace (a, b) with (b, a % b) until b is 0 (gcd(48, 18) is 6). To list all primes up to n, cross out the multiples of each prime starting at p * p: the primes up to 30 are 2, 3, 5, 7, 11, 13, 17, 19, 23, 29. Python caps integer-to-text conversion at 4,300 digits by default, so for huge numbers keep digit lists and do the carries yourself.