Definition
Same both ways
Digits match left-to-right and right-to-left.
Check Palindrome Number in C
Overview
What You’ll Learn
A palindrome number reads the same forwards and backwards — like 121 or 7. This tutorial covers reversing digits with % 10 and / 10, listing palindromes in a range, a string alternative, a live checker, worked C examples, edge cases, and complexity.
Reverse
% 10 / 10
Build the digit reverse, then compare.
Save Original
Before the loop
Keep a copy before you destroy n.
Range List
100..200
Reuse the helper for each candidate.
Live Preview
Try 121 / 123
Check any nonnegative integer live.
O(d) Cost
d = digits
One pass over the digits of n.
Introduction
A palindrome number looks the same when its digits are reversed. The classic interview approach builds that reverse with a loop, then compares it to the original.
Single-digit values always pass. Numbers ending in 0 (except 0 itself) fail because leading zeros disappear in the reversed integer. This page focuses on nonnegative integers for beginner clarity.
Why it matters?
It is a classic while-loop drill that combines remainder, integer division, and careful state saving.
Key Highlights
Reverse Loop
rev = rev*10 + n%10.
Compare
original == reversed.
Trailing Zeros
120 reverses to 21.
Single Digit
Always a palindrome.
In short: save the original, reverse digits in a loop, return whether they match.
Foundation
📝 Problem & Approach
Given a nonnegative integer, decide whether its decimal digits form a palindrome, and optionally list all palindromes in a range.
c
/* 121 -> reverse 121 -> palindrome
123 -> reverse 321 -> not
7 -> reverse 7 -> palindrome
120 -> reverse 21 -> not */Inputs & Outputs
| Item | Type | Description |
|---|---|---|
number / n | int | Nonnegative integer to test. |
| Return | int | 1 when original equals digit reverse; else 0. |
| Range print | text | Palindrome values from start through end. |
Minimal workflow
Pseudocode
function isPalindrome(n):
original = n
reversed = 0
while n != 0:
reversed = reversed * 10 + (n mod 10)
n = floor(n / 10)
return original == reversedMethod comparison
| Method | Idea | Notes |
|---|---|---|
| Arithmetic reverse | Loop with % and / | Interview default |
| Char buffer | sprintf + two-index compare | Short; mention after arithmetic |
| Two pointers on digits | Compare ends | Useful for digit arrays |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Last digit | digit = n % 10 |
| Append to reverse | rev = rev * 10 + digit |
| Drop last digit | n /= 10 |
| Compare | return original == rev |
| String check | sprintf + two-index compare |
| Inclusive range | for (i = 100; i <= 200; ++i) |
Compare
📋 Arithmetic vs String vs Pointers
Same yes/no answer — different interview signals.
Arithmetic
rev*10 + n%10This page — classic interview style
String
sprintf + endsShort C; show loops first
Two pointers
left / rightNatural for digit lists
Interview tip
save originalCopy n before the reverse loop
Context
When This Problem Shows Up
Reach for a digit-reverse palindrome check whenever symmetry of digits matters.
Interview classics
While loops, remainder, and comparison.
Digit drills
Practice % 10 and / 10 together.
Filtering ranges
List all palindromes in an interval.
Bridge to string pals
Same idea as word palindromes.
Not signed by default
Define negative behavior separately.
Key benefit: one reusable helper that teaches digit peeling, state saving, and symmetry checks.
Interactive
🔮 Live Preview
Enter a nonnegative integer and check whether it is a palindrome.
Hands-On
Examples Gallery
Three complete C programs — arithmetic check for 121, palindromes from 100 to 200, and a string-based alternative. Click View Output to reveal sample console results.
📚 Getting Started
Arithmetic reversal and a single sample value.
Example 1 — Check One Number
Use arithmetic reversal and compare with the original.
c
#include <stdio.h>
int isPalindrome(int number) {
int originalNumber = number;
int reversedNumber = 0;
int remainder;
while (number != 0) {
remainder = number % 10;
reversedNumber = reversedNumber * 10 + remainder;
number /= 10;
}
return originalNumber == reversedNumber;
}
int main(void) {
int number = 121;
if (isPalindrome(number)) {
printf("%d is a palindrome number.\n", number);
} else {
printf("%d is not a palindrome number.\n", number);
}
return 0;
}How It Works
The loop peels digits from the right and builds reversedNumber. For 121 the reverse is also 121, so the helper returns 1 (true).
⚡ Listing Palindromes
Reuse the same helper inside an inclusive range loop.
Example 2 — Palindromes from 100 to 200
Scan each candidate and print those that pass the check.
c
#include <stdio.h>
int isPalindrome(int num) {
int originalNum = num;
int reversedNum = 0;
int remainder;
while (num != 0) {
remainder = num % 10;
reversedNum = reversedNum * 10 + remainder;
num /= 10;
}
return originalNum == reversedNum;
}
int main(void) {
int i;
printf("Palindrome numbers in the range 100 to 200:\n");
for (i = 100; i <= 200; ++i) {
if (isPalindrome(i)) {
printf("%d ", i);
}
}
printf("\n");
return 0;
}How It Works
The for loop uses i <= 200 so 200 is included. Three-digit palindromes in this band look like 1a1.
Example 3 — String Alternative
Write digits with sprintf, then compare ends with two indices — short, but show arithmetic first in interviews.
c
#include <stdio.h>
#include <string.h>
int isPalindromeStr(int number) {
char s[32];
int i, j;
sprintf(s, "%d", number);
i = 0;
j = (int)strlen(s) - 1;
while (i < j) {
if (s[i] != s[j]) {
return 0;
}
i++;
j--;
}
return 1;
}
int main(void) {
int tests[] = {121, 123, 7, 120};
int i, n;
for (i = 0; i < 4; ++i) {
n = tests[i];
if (isPalindromeStr(n)) {
printf("%d is palindrome.\n", n);
} else {
printf("%d is not a palindrome.\n", n);
}
}
return 0;
}How It Works
Two indices walk from both ends of the sprintf buffer until they meet. Leading zeros never appear in that buffer, so 120 still fails — matching the arithmetic rule.
🧠 How Digit Reversal Works
1
Save original
Copy n before the loop mutates it.
Setup
2
Peel last digit
digit = n % 10, then n /= 10.
Loop
3
Build reverse
rev = rev * 10 + digit each step.
Build
=
Compare
Palindrome if original == rev.
Trace
🔎 Worked Walkthrough — 121
Trace the reverse loop for n = 121.
| Step | n | digit | rev |
|---|---|---|---|
| Start | 121 | — | 0 |
| 1 | 12 | 1 | 1 |
| 2 | 1 | 2 | 12 |
| 3 | 0 | 1 | 121 |
original 121 equals rev 121 — palindrome.
Use Cases
Where palindrome-number checks show up beyond the interview prompt.
1. Interview Classics
While loops and digit math.
Example: write isPalindrome.
2. Range Filters
List pals in an interval.
Example: 100..200.
3. Digit Drills
Practice % 10 and / 10.
Example: reverse any n.
4. Edge-Case Talk
Trailing zeros and single digits.
Example: 120 vs 7.
5. String Twin
Same idea as word palindromes.
Example: radar / level.
6. Next: Pascal
Continue the interview track.
Example: related CTA.
Pro Tip: say “save original, reverse with % and /, compare” before typing code.
Advantages
Why the arithmetic reverse approach works well in interviews.
1. Easy to Trace
Dry-run 121 on paper and watch rev grow.
2. No String Required
Shows comfort with integer arithmetic.
3. Reusable Helper
Same function powers single checks and ranges.
4. C-Friendly
No overflow worries with C ints.
Pro Tip: lead with arithmetic reverse; offer the sprintf buffer check as a concise alternative.
Usage Tips
Small habits that keep palindrome checks interview-ready.
1. Save Original First
Copy n before the reverse loop.
2. Mention Trailing Zeros
Call out 120 → 21 as a classic trap.
3. Define Negatives
State whether negatives are allowed.
4. Inclusive Ranges
Use end + 1 with C range.
5. Offer String Later
Show arithmetic first, then sprintf + ends.
Pro Tip: dry-run 121 and 120 aloud — if both match the table, your reverse logic is solid.
Common Pitfalls
Mistakes that commonly break palindrome-number programs.
1. Forgetting to Save Original
Comparing after n is already zeroed out.
→ Copy original before the loop.
2. Trailing Zero Blind Spot
Thinking 120 should match 021.
→ Integer reverse drops leading zeros.
3. Off-by-One Range
Stopping the loop before
endinclusive.→ Use
i <= end(inclusive) in theforloop.4. Silent Negatives
Undefined behavior for -121.
→ Reject or define a signed policy.
5. Only Showing Strings
Skipping the arithmetic method in interviews.
→ Lead with the reverse loop.
Edge Cases
Handle these before claiming the check is complete.
Zeros
Trailing zeros
120 reverses to 21, so it is not a palindrome.
Single
n < 10
Always a palindrome for nonnegative numbers.
Zero
n = 0
Zero is a palindrome.
Neg
Negative input
This page rejects negatives in live preview for clarity.
Even len
Even digit counts
Works the same — e.g. 1221.
Large
Many digits
Still O(d); C ints grow as needed.
Theory
⚖️ Facts Worth Knowing
Handy follow-ups interviewers sometimes ask.
- Single digits. Every n in 0..9 is a palindrome.
- Form 1a1. Three-digit pals look like first digit equals last.
- Words too. The same symmetry idea applies to strings like radar.
- No C overflow. Reversed values can grow freely unlike fixed-width ints.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Trace 121
- Reproduce the walkthrough table
- Confirm original == rev
2. Reject 120
- Show reverse becomes 21
- Explain leading zeros
3. List 100..200
- Reproduce Example 2
- Expect ten three-digit pals
4. String twin
- Implement Example 3
- Match arithmetic answers
Important
Notes
- Core trick: reverse digits and compare with original.
- Range scan: reuse the same helper for each candidate.
- Watch-outs: trailing zeros and negative input rules.
- C integers do not overflow like fixed-width ints. A string comparison also works, but arithmetic reverse is the classic interview approach.
Quick Takeaway: save original, reverse with % and //, return original == rev.
Analysis
⏱️ Time and Space Complexity
| Operation | Time | Extra space |
|---|---|---|
isPalindrome(n) | O(d) | O(1) |
Range [a, b] | O((b-a+1) * d) | O(1) |
| sprintf buffer check | O(d) | O(d) for the string |
Here d is the number of decimal digits in the value being tested.
🎉 Conclusion
Checking a palindrome number means reversing its digits and comparing with the original. Save a copy first, peel digits with % 10 and / 10, and watch for trailing zeros.
Practice the three examples above, then continue to generating Pascal’s triangle.
original == reverse(digits) — that is the whole check.
Pro Tips
💡 Best Practices
✅ Do
- Save original before reversing
- Use % 10 and / 10
- Call out trailing zeros
- Reuse the helper in ranges
- State nonnegative scope
❌ Don’t
- Compare after destroying n
- Treat 120 as a palindrome
- Forget inclusive
i <= end - Leave negatives undefined
- Skip arithmetic in interviews
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about palindrome numbers
Check digit symmetry the interview-friendly way.
5
Core concepts 01
Reverse
% and / loop
Pattern 02
Compare
original == rev
Rule 03
Zeros
120 ≠ 21
Edge 04
Digits
0..9 always yes
Base 05
Cost
O(d) / O(1)
Analysis❓ Frequently Asked Questions
A palindrome number reads the same from left to right and right to left, like 121 or 9009.
Reversing digits gives a value you can directly compare with the original using ==.
Yes. Any single-digit number is palindrome.
Yes. Zero reads the same in both directions.
These snippets assume nonnegative integers. Negatives need extra care because % with signs follows C rules.
Checking one number is O(d) where d is digit count. Range scan multiplies this by number of tested values.
Its digit reverse is 021, which as an integer is 21 — not equal to 120.
Yes—sprintf into a buffer and compare ends with two indices. Interviews often want the arithmetic reverse first.
Yes on fixed-width ints. For very large digit strings prefer a char buffer or a wider type; these examples stay in typical small ranges.
Did you Know? 🔊
The word palindrome also describes words like “radar” or “level”. For integers, we compare digits only, so single-digit values like 7 always pass.
Continue to Pascal’s Triangle
Learn how to generate Pascal’s triangle rows with nested loops in C.
About the author
8 people found this page helpful