Working with numbers: digits, divisors and primes

Has a bank card number been typed correctly? The algorithm that checks it takes the number apart digit by digit, adds the digits up and looks at a remainder. Every DİM informatics paper has 3–4 tasks on the topic «loops and working with numbers», and in three of the four 2025–2026 papers one of the written programs came from this topic too. The good news: almost all of these tasks are built from a few ready templates — the digit loop, the divisor loop and Euclid's algorithm. This lesson continues «Loops: for, while, step, break, continue and nested loops».

Taking digits apart: n % 10 and n // 10

In the decimal system the last digit of a number is the remainder of dividing it by 10, and integer division by 10 drops that digit: 5682 % 10 = 2, 5682 // 10 = 568. Repeat these two operations in a loop and you get the digits one by one from right to left; when the number becomes 0, the digits have run out.

1. 1
   Keep a copy

   The loop will change n until it becomes 0. If you need the original number later, first write m = n.

2. 2
   Starting values

   sum s = 0, product p = 1, count c = 0, reverse r = 0.

3. 3
   Loop condition

   while n > 0: — as long as digits are left.

4. 4
   Take the digit and use it

   d = n % 10, then s = s + d, p = p * d, c = c + 1, r = r * 10 + d, or a condition such as if d % 2 == 0:.

5. 5
   Drop the digit

   n = n // 10. Forget this line and the loop never ends.

n = 5682
s = 0
p = 1
c = 0
r = 0
while n > 0:
    d = n % 10
    s = s + d
    p = p * d
    c = c + 1
    r = r * 10 + d
    n = n // 10
print(s, p, c, r)

21 480 4 2865

x = 3704
k = 0
m = x
while x > 0:
    if x % 10 % 2 == 0:
        k = k + 1
    x = x // 10
print(m * 10 + k)

37042

Reverse numbers, palindromes and «all digits odd»

To build the reverse, at every step multiply the result so far by 10 and add the new digit: the earlier digits move one place to the left. A number equal to its reverse is a palindrome: 121, 4554, 7.

«Are all the digits odd?» can be answered in two ways: count the odd digits and compare with the total number of digits, or use a flag variable: first t = 1 («all odd so far»), and t = 0 as soon as an even digit appears. In the program below the outer loop walks through the numbers and the inner loop through their digits.

for n in [357, 48, 1991, 7, 5031]:
    m = n
    t = 1
    while m > 0:
        if m % 10 % 2 == 0:
            t = 0
        m = m // 10
    if t == 1:
        print(n)

357
1991
7

Divisors, primes and perfect squares

n = 60
c = 0
s = 0
t = 0
for i in range(1, n + 1):
    if n % i == 0:
        print(i, end=' ')
        c = c + 1
        s = s + i
        if i % 2 == 1:
            t = t + i
print()
print(c, s, t)

1 2 3 4 5 6 10 12 15 20 30 60 
12 168 24

Nested loops: checking every number of an interval

When a task asks about every number of an interval [a, b] rather than about one number, put the divisor (or digit) loop inside another loop: the outer loop walks through the numbers, the inner one through the divisors. The counter (c = 0) must be reset for every new number, so it is written inside the outer loop.

a = 20
b = 40
k = 0
for n in range(a, b + 1):
    c = 0
    for i in range(1, n + 1):
        if n % i == 0:
            c = c + 1
    if c == 2:
        print(n, end=' ')
        k = k + 1
print()
print('count =', k)

23 29 31 37 
count = 4

GCD, LCM and sums

The greatest common divisor (GCD) of two numbers can be found without checking every divisor, with Euclid's algorithm. It rests on one fact: the remainder of a divided by b is also divisible by gcd(a, b). So the pair (a, b) can be replaced with (b, a % b), and the numbers shrink fast.

a = 84
b = 36
p = a * b
while b != 0:
    r = a % b
    a = b
    b = r
print(a, p // a)

12 252

Sums and products of sequences follow the same scheme: an accumulator (s = 0) or a multiplier (p = 1) and one term per step of the loop. Fractions use /, so the result is a float.

n = 4
s = 0
p = 1
for i in range(1, n + 1):
    s = s + 1 / i
    p = p * i
print(round(s, 4), p)

2.0833 24

n = 90517
s = 0
r = 0
# digit loop here

print(s, r)

22 71509

for n in range(1, 101):
    c = 0
    # count the divisors of n here

    if c == 3:
        print(n)

4
9
25
49