Introduction

The smallest number evenly divisible by every integer from 1 to 20 is the least common multiple, or LCM, of that range. The cleanest way to find it is to keep the highest power of every prime needed by any number in the set.

Solve it with prime factors

To build the LCM, list the prime powers that matter most:

• '2^4 from 16'
• '3^2 from 9'
• '5 from 5'
• '7 from 7'
• '11 from 11'
• '13 from 13'
• '17 from 17'
• '19 from 19'

Now multiply them:

2^4 * 3^2 * 5 * 7 * 11 * 13 * 17 * 19
= 16 * 9 * 5 * 7 * 11 * 13 * 17 * 19
= 232792560

That number contains enough factors to be divisible by every number from 1 through 20.

Why this works

An LCM must include every prime factor needed by every number in the set. For example:

• '8 requires 2^3'
• '16 requires 2^4'

If the final number only had 2^3, it would be divisible by 8 but not by 16. So you keep the highest required power, not every duplicate from every number.

The same logic applies to 3^2 because 9 and 18 need two factors of 3.

Verify it with code

A short Python program can confirm the answer:

1number = 232792560
2
3for divisor in range(1, 21):
4    print(divisor, number % divisor == 0)

Every line should print True.

You can also compute the answer programmatically using the LCM relation:

• 'lcm(a, b) = abs(a * b) // gcd(a, b)'

1from math import gcd
2from functools import reduce
3
4
5def lcm(a, b):
6    return abs(a * b) // gcd(a, b)
7
8
9result = reduce(lcm, range(1, 21))
10print(result)

This prints:

232792560

That approach is often better in software because it generalizes easily to any range.

A useful way to think about the problem

This is not really a "guess the magic number" puzzle. It is an LCM problem disguised as a divisibility question. Once you recognize that, the structure becomes simple:

1. find the primes involved,
2. keep the largest needed power of each,
3. multiply those powers.

This method works not only for 1 through 20, but for any list of positive integers. It also explains why the answer is much smaller than the raw product of all numbers in the range: the LCM keeps only the factors that are actually necessary.

A nice side effect of the prime-factor method is that it gives you both the number and the proof of minimality. Once every required prime power is present exactly once, removing any one factor would immediately break divisibility for at least one number in the range.

Common Pitfalls

The biggest mistake is multiplying all the numbers from 1 to 20 together. That produces a number divisible by everything in the range, but it is far from the smallest one.

Another common issue is forgetting that repeated prime powers matter. If you include 2 only once, the final number will fail divisibility tests for numbers such as 4, 8, and 16.

Be careful when verifying with code too. Testing only a few divisors such as 2, 5, and 10 is not enough. The answer must divide evenly by all numbers in the full range.

Finally, if you compute LCM iteratively in code, use gcd to control growth. Repeated raw multiplication becomes unnecessarily large very quickly.

Summary

• The problem is asking for the LCM of the integers from 1 to 20.
• Keep the highest required power of each prime.
• The final answer is 232792560.
• Prime factorization explains why the answer is minimal.
• In code, iterative gcd and lcm functions are the cleanest general solution.