Definition
n = k²
Some integer k squares to n.
Check Perfect Square in C
Overview
What You’ll Learn
A perfect square equals k * k for some whole number k. Examples: 1, 4, 9, 16, 25. This tutorial covers the loop and sqrt approaches, a live checker, worked C examples, edge cases, and complexity.
i*i Loop
Beginner
Try candidates while i*i <= n.
sqrt
Robust
Integer root, then root*root == n.
0 and 1
Both square
0*0 and 1*1 both count.
Live Preview
Try 16 / 15
See k and the verdict instantly.
Not Perfect Number
Different idea
Squares vs divisor sums.
Introduction
A perfect square is a non-negative integer that equals some integer squared. So 16 is perfect because 4 * 4 = 16, while 15 is not because no whole k works.
Interviews usually accept either a clear i * i loop or a sqrt check. Prefer integer roots over floating sqrt so large values stay exact.
Why it matters?
It is a classic math interview warm-up that teaches exact integer reasoning without float traps.
Key Highlights
n = k²
Some integer k squares to n.
Two Methods
Loop or sqrt.
0 and 1
Both are perfect squares.
Avoid Float
Verify float sqrt by squaring.
In short: find whether some integer k satisfies k * k == n.
Foundation
📝 Problem & Approach
Given an integer n, decide whether it is a perfect square of a non-negative integer.
c
/* 16 -> 4 * 4 = 16 perfect
15 -> not a square
0 -> 0 * 0 = 0 perfect
1 -> 1 * 1 = 1 perfect */Inputs & Outputs
| Item | Type | Description |
|---|---|---|
n / number | int | Value to test (non-negative for yes). |
| Return | int (0/1) | 1 when some k has k*k == n. |
| Optional k | int | The integer root when the answer is yes. |
Minimal workflow
Pseudocode
function is_perfect_square_loop(n):
if n < 0:
return false
i = 0
while i * i <= n:
if i * i == n:
return true
i = i + 1
return falseMethod comparison
| Method | Idea | Notes |
|---|---|---|
| i*i loop | Try candidates until square exceeds n | Clearest for beginners |
| sqrt | root = (int)sqrt(n); root*root == n | Fast and exact for integers |
| float sqrt | round(sqrt(n))**2 == n | Risky for large n — avoid |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Reject negatives | if (n < 0) return 0; |
| Loop check | while i * i <= n: |
| Exact hit | if (i * i == n) return 1; |
| sqrt + verify | root = sqrt(n) |
| Verify root | return root * root == n |
| Build squares | k * k for k = 0, 1, 2, … |
Compare
📋 Loop vs sqrt vs Float
Same question — different reliability.
i*i loop
while i*i <= nInterview-friendly and exact
sqrt
root*root == nPreferred production check
float sqrt
avoid for intsRounding can lie on big n
vs perfect number
k*k vs s(n)=nDifferent “perfect” meaning
Context
When This Problem Shows Up
Reach for a square check whenever you need exact integer roots.
Interview warm-ups
Simple math with an exactness twist.
Grid / geometry puzzles
Can n form a square layout?
Filtering sequences
Keep only square values in a range.
Teaching sqrt
Show why integer roots beat floats.
Not for float domains
This tutorial targets integer n.
Key benefit: one crisp yes/no question that forces you to think in exact integers, not approximate roots.
Interactive
🔮 Live Preview
Checks with integer logic, then reports the root and verdict.
Hands-On
Examples Gallery
Three complete C programs — loop check for 16, list squares from 1 to 50 with sqrt, and generate squares by squaring. Click View Output to reveal sample console results.
📚 Getting Started
A beginner-friendly loop that never needs floating roots.
Example 1 — Integer Loop Check
Simple and beginner-friendly perfect square check (no math.h).
c
#include <stdio.h>
int isPerfectSquare(int number) {
int i;
for (i = 1; i * i <= number; i++) {
if (i * i == number) {
return 1;
}
}
return 0;
}
int main(void) {
int testNumber = 16;
if (isPerfectSquare(testNumber)) {
printf("%d is a perfect square.\n", testNumber);
} else {
printf("%d is not a perfect square.\n", testNumber);
}
return 0;
}How It Works
Candidates advance from 1 while i * i has not passed 16. When i reaches 4, the product matches and the function returns 1. (Handle 0 separately if you need it — this loop starts at 1.)
⚡ Library Square Root
Use sqrt from <math.h>, then verify by squaring.
Example 2 — Range Scan Using sqrt
Use sqrt and print all perfect squares from 1 to 50. Link with -lm on GCC/Clang.
c
#include <stdio.h>
#include <math.h>
int isPerfectSquare(int num) {
int root = (int)sqrt((double)num);
return root * root == num;
}
int main(void) {
printf("Perfect Squares in the Range 1 to 50:\n");
for (int i = 1; i <= 50; ++i) {
if (isPerfectSquare(i)) {
printf("%d ", i);
}
}
printf("\n");
return 0;
}How It Works
sqrt returns a floating root; casting to int truncates toward zero. Squaring that root recovers num exactly when num is a perfect square.
Example 3 — Generate Squares by Squaring
Build squares directly instead of filtering every integer.
c
#include <stdio.h>
int main(void) {
printf("First squares from k = 0 to 7:\n");
for (int k = 0; k <= 7; ++k) {
int square = k * k;
printf("%d * %d = %d\n", k, k, square);
}
return 0;
}How It Works
When you only need the square sequence, squaring consecutive integers is cheaper than testing every n in a range.
🧠 How the Algorithm Decides
1
Reject negatives
No non-negative integer squares to a negative.
Guard
2
Find a candidate root
Loop i while i*i <= n, or call sqrt(n) and cast.
Search
3
Compare square to n
Exact match means perfect square.
Rule
=
Return the verdict
1 with root k, or 0.
Trace
🔎 Worked Walkthrough — 16
Trace the loop method for n = 16.
| i | i * i | i*i <= 16? | Match? |
|---|---|---|---|
0 | 0 | Yes | No |
1 | 1 | Yes | No |
2 | 4 | Yes | No |
3 | 9 | Yes | No |
4 | 16 | Yes | Yes — return 1 |
4 * 4 equals 16 — perfect square.
Use Cases
Where perfect-square checks show up beyond the interview prompt.
1. Interview Classics
Exact integer math checks.
Example: is_square(16).
2. Range Filtering
List squares inside a band.
Example: 1..50 list.
3. Sequence Generation
Build squares with k*k.
Example: Example 3.
4. Grid Layouts
Can n tiles form a square?
Example: 25 -> 5×5.
5. Teaching sqrt
Show exact integer roots.
Example: avoid float sqrt.
6. Next: Averages
Continue the interview chain.
Example: related CTA.
Pro Tip: say “I’ll check whether root*root equals n using an integer root” before coding.
Advantages
Why these approaches work well for beginners and interviews.
1. Easy to Trace
Dry-run 16 on paper and watch i grow.
2. Exact Integers
Always square the truncated root again.
3. Two Clear Styles
Loop for clarity; sqrt for a short check.
4. Generates Cleanly
k*k builds the sequence without scanning.
Pro Tip: lead with the loop in interviews, then mention sqrt as the robust alternative.
Usage Tips
Small habits that keep square checks interview-ready.
1. Guard Negatives
Return 0 immediately for n < 0.
2. Prefer verify-after-sqrt
Cast
sqrttoint, then checkroot * root == n.3. Verify root*root
Never trust a root without squaring back.
4. Generate When Possible
Use k*k if you need the sequence itself.
5. Separate From Perfect Number
Name the definition so interviewers know you know.
Pro Tip: sanity-check 0, 1, 16, and 15 — if those four behave, your logic is solid.
Common Pitfalls
Mistakes that commonly break perfect-square programs.
1. Trusting float sqrt
Large ints can round incorrectly.
→ Use sqrt or an integer loop.
2. Skipping root verification
Taking floor(sqrt) without squaring back.
→ Always compare root * root to n.
3. Confusing With Perfect Number
Different “perfect” concept entirely.
→ This page is about k * k.
4. Forgetting 0
Starting i at 1 and rejecting zero.
→ 0 = 0 * 0 is a square.
5. Accepting Negatives
Returning 1 for -16 in real-integer checks.
→ Reject n < 0 in this tutorial.
Edge Cases
Handle these before claiming the check is complete.
n = 0
Zero is square
0 = 0 * 0.
n = 1
One is square
1 = 1 * 1.
Negative
Not a real integer square
Return 0 for negatives in this tutorial.
Large n
Avoid float precision
Prefer sqrt over float sqrt.
15
Classic no
Between 9 and 16 — not square.
16
Classic yes
4 * 4 = 16.
Theory
⚖️ Facts Worth Knowing
Handy follow-ups interviewers sometimes ask.
- Odd gaps. Differences between consecutive squares are odd: 3, 5, 7, 9…
- Grid picture. n tiles form a square if and only if n is a perfect square.
- sqrt identity. Perfect ⇔ truncated root squared equals n (for safe ranges).
- Name clash. Perfect square ≠ perfect number.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Prove 16
- Trace the loop
- Confirm 4 * 4
2. Reject 15
- Show no matching i
- sqrt(15) truncates to 3, 9 != 15
3. List 1..50
- Reproduce Example 2
- Expect seven values
4. Generate k*k
- Print first eight squares
- Match Example 3
Important
Notes
- Definition: n is square if n = k * k.
- Methods: integer loop or
sqrt. - Remember: 0 and 1 are perfect squares.
- Prefer the integer loop, or verify
(int)sqrt(n)by squaring. The loop takes O(sqrt(n)) checks. Return 0 immediately for negatives.
Quick Takeaway: n is a perfect square when some integer k satisfies k * k == n.
Analysis
⏱️ Time and Space Complexity
| Approach | Time (single n) | Extra space |
|---|---|---|
| Loop until i*i > n | O(sqrt(n)) | O(1) |
| sqrt-based check | O(1) practical | O(1) |
| Range 1..U scan | O(U) checks | O(1) |
For interview demos, either method is fine; mention float pitfalls when asked about reliability.
🎉 Conclusion
A perfect square equals some integer squared. Use an i * i loop or sqrt, reject negatives, and remember that 0 and 1 count.
Practice the three examples above, then continue to finding the average of N numbers.
n = k² means perfect square; verify with integers, not float sqrt.
Pro Tips
💡 Best Practices
✅ Do
- Reject negatives early
- Verify root * root == n
- Prefer sqrt for exactness
- Treat 0 and 1 as squares
- Generate with k*k when listing
❌ Don’t
- Trust float sqrt alone
- Skip squaring the root back
- Confuse with perfect numbers
- Forget zero as a square
- Accept negatives as yes
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about perfect squares
Decide exact squares the interview-friendly way.
5
Core concepts 01
Rule
n = k * k
Definition 02
Loop
while i*i
Method 03
sqrt
root*root
Robust 04
Edges
0, 1 yes
Guards 05
Cost
O(√n)
Analysis❓ Frequently Asked Questions
A whole number is a perfect square if it equals k * k for some whole number k.
Yes. 1 = 1 * 1.
The loop is easy to understand, needs no math library, and avoids floating-point concerns.
It means we only test candidate roots whose square has not passed n.
Yes. Truncate the root to int and check root * root == n. With GCC/Clang you often need -lm when linking.
No. Perfect square is about k * k; perfect number is about divisor sums.
Yes. 0 = 0 * 0. Treat it as a special case if your loop starts at i = 1.
Large integers can round incorrectly; always verify by squaring the truncated root, or prefer the integer loop.
About O(sqrt(n)) candidate checks for a single n.
Did you Know? 🔊
A perfect square is also a quadratic residue in everyday arithmetic: the count of objects you can arrange in a square grid with the same number of rows and columns. The gaps between consecutive squares 1, 4, 9, 16… grow by the odd numbers 3, 5, 7, 9…
Continue to Average of N Numbers
Learn how to find the average of N numbers in C.
About the author
9 people found this page helpful