Imagine this...
You walk into a shop and buy 30 chocolates. 🍫
Your friend looks at the chocolates and asks:
“Can we divide these chocolates equally among people without breaking any chocolate?”
Interesting question, right?
So now we start thinking...
- Can 1 person take all 30 chocolates?
- Can 2 people share equally?
- What about 3?
- 4?
- 5?
- 6?
Suddenly... mathematics enters the story.
And that is where the beautiful idea of Divisors begins.
Step 1: Understanding Divisors Using Chocolates
We have:
30 chocolates
Now let’s check who can divide them equally.
If a number divides 30 completely with no remainder, then it is called a divisor (or factor) of 30.
These are the divisors of 30:
1 2 3 5 6 10 15 30
Because:
- 30 ÷ 1 = 30
- 30 ÷ 2 = 15
- 30 ÷ 3 = 10
- 30 ÷ 5 = 6
No remainder anywhere.
The Secret Weapon: % Modulus Operator
In Python:
30 % 2
means:
“What remainder is left when 30 is divided by 2?”
If the answer is:
0
then division happened perfectly.
That means:
2 is a divisor of 30
Step 2: Checking Divisors Manually
At first, beginners usually think like this:
if 30%1 == 0:
print(1)
if 30%2 == 0:
print(2)
if 30%3 == 0:
print(3)
if 30%4 == 0:
print(4)
if 30%5 == 0:
print(5)
if 30%6 == 0:
print(6)
if 30%7 == 0:
print(7)
if 30%8 == 0:
print(8)
Let’s Understand This Deeply
Take this line:
if 30%2 == 0:
print(2)
Here’s what happens internally:
Step-by-step Thinking
- Divide 30 by 2
- Check the remainder
- If remainder is 0
- Then print 2
Because 30 divides perfectly by 2.
Flowchart
Start
|
v
Check 30 % 2
|
Is remainder 0?
/ \
Yes No
/ \
Print 2 Ignore
\
v
End
But Wait... This Feels Repetitive
Imagine checking till 1000 manually.
Impossible!
So programmers start asking smarter questions:
“Can the computer repeat the work for us?”
And that leads us to loops.
Step 3: Reducing Repetition
Instead of writing many if statements:
div = 1
if 30%div == 0:
print(div)
div+=1
if 30%div == 0:
print(div)
div+=1
if 30%div == 0:
print(div)
div+=1
Now we introduced a variable:
div
which means:
“Current divisor we are checking.”
What is Happening Here?
Initially:
div = 1
Then:
30 % div
checks whether current divisor divides 30 perfectly.
After checking:
div += 1
moves to the next divisor.
This is already smarter than writing everything manually.
But still repetitive.
Step 4: The Power of While Loop
Now comes the real programming mindset.
no = 30
div = 1
while div <= no:
if no % div == 0:
print(div)
div += 1
Let’s Build the Logic Slowly
We are saying:
“Start divisor from 1 and keep checking till 30.”
Detailed Breakdown
Line 1
no = 30
The number whose divisors we want.
Line 2
div = 1
We begin checking from divisor 1.
Line 3
while div <= no:
Meaning:
“Keep running until divisor becomes greater than 30.”
Inside the Loop
if no % div == 0:
Check whether divisor divides the number perfectly.
If True
print(div)
Print the divisor.
Move Forward
div += 1
Go to next divisor.
Flowchart
Start
|
v
no = 30
div = 1
|
v
Is div <= no ?
/ \
Yes No
| |
v v
Check no % div End
|
Is remainder 0?
/ \
Yes No
| |
Print div |
\ /
v v
div += 1
|
v
Repeat Loop
Output
1
2
3
5
6
10
15
30
Beautiful.
The computer found all divisors automatically.
Step 5: Can We Make It Faster?
Suppose:
no = 10000
Do we really need to check till 10000?
Actually no.
Because:
A number cannot have divisors greater than half of itself (except the number itself).
So we optimize.
Optimized Version
no = 10000
div = 2
while div <= no//2:
if no % div == 0:
print(div)
div += 1
Why Start From 2?
Because:
- 1 is always a divisor
- number itself is always a divisor
We are searching for divisors in between.
Why no//2?
Because no number larger than half can divide the number evenly.
For example:
Can 20 divide 30?
No.
So checking after 15 is useless.
This saves time.
This is called:
Optimization
A very important programming skill.
Flowchart
Start
|
v
no = 10000
div = 2
|
v
Is div <= no//2 ?
/ \
Yes No
| |
v v
Check no % div End
|
Is remainder 0?
/ \
Yes No
| |
Print div |
\ /
v v
div += 1
|
v
Repeat
Step 6: Counting Divisors Instead of Printing
Now a new idea comes.
Instead of printing divisors...
What if we count them?
Code
no = 30
div = 2
count = 0
while div <= no//2:
if no % div == 0:
count += 1
div += 1
print("Count of Divisors", count)
Deep Understanding
Variable count
This stores:
“How many divisors we found.”
Initially:
count = 0
Whenever divisor is found:
count += 1
means:
count = count + 1
Let’s Trace It
For 30:
Divisors between 2 and 15 are:
2 3 5 6 10 15
Total:
6
So output becomes:
Count of Divisors 6
Flowchart
Start
|
v
count = 0
|
v
Check divisors
|
Divisor found?
/ \
Yes No
|
count += 1
|
v
Continue Loop
|
v
Print count
Step 7: The Birth of Prime Numbers
Now comes the magical idea.
A prime number is:
A number that has NO divisors except 1 and itself.
Examples:
2 3 5 7 11 13 17
Let’s Test 31
no = 31
div = 2
count = 0
while div <= no//2:
if no % div == 0:
count += 1
div += 1
if count == 0:
print(no, 'is a prime number')
The Core Idea
We search for divisors between:
2 to no//2
If we find none...
Then the number is prime.
Why Does This Work?
For 31:
- 31 % 2 → not 0
- 31 % 3 → not 0
- 31 % 4 → not 0
...
No divisor found.
So:
count == 0
Which means:
31 is a prime number
Flowchart
Start
|
v
count = 0
|
v
Check divisors
|
Any divisor found?
/ \
Yes No
| |
count += 1 |
\ /
v v
Loop Ends
|
v
Is count == 0 ?
/ \
Yes No
| |
Print Prime Not Prime
Special Fact
The One and Only Even Prime Number is 2
Why?
Because every other even number is divisible by 2.
But 2 itself has only:
1 and 2
as divisors.
So it is prime.
Final Big Idea
Everything started with chocolates.
Then we learned:
Chocolate Sharing
↓
Divisors
↓
Finding Divisors
↓
Counting Divisors
↓
Prime Numbers
This is how programming should be learned.
Not by memorizing code.
But by:
- Asking questions
- Building logic slowly
- Thinking like a problem solver
Final Thought
Whenever you see a prime number problem now...
Don’t think:
“Oh no, math!”
Instead think:
“Can this number share chocolates equally with anyone?”
And suddenly...
Prime numbers become simple.
