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 std::sqrt approaches, a live checker, worked C++ examples, edge cases, and complexity.
i*i Loop
Beginner
Try candidates while i*i <= n.
std::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 std::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 std::sqrt.
0 and 1
Both are perfect squares.
Avoid Float
verify after std::sqrt.
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 -> no integer k not perfect
// 0 -> 0 * 0 = 0 perfect
// 1 -> 1 * 1 = 1 perfectInputs & Outputs
| Item | Type | Description |
|---|---|---|
n / number | int | Value to test (non-negative for yes). |
| Return | bool | true 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 |
| std::sqrt | root = static_cast<int>(std::sqrt(n)); root*root == n | Fast and exact for integers |
| float sqrt | std::lround(std::sqrt(n))² == n | Risky for large n — avoid |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Reject negatives | if (n < 0) return false; |
| Loop check | while (i * i <= n) |
| Exact hit | if (i * i == n) return true; |
| sqrt check | int root = static_cast<int>(std::sqrt(n)); |
| Verify root | return root * root == n; |
| Build squares | k * k for k = 0, 1, 2, … |
Compare
📋 Loop vs std::sqrt vs Float
Same question — different reliability.
i*i loop
while i*i <= nInterview-friendly and exact
std::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 std::sqrt
Show why integer roots beat floats.
Not for float domains
This tutorial targets integer n.
Key benefit: one crisp bool 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 std::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.
c++
#include <iostream>
bool isPerfectSquare(int number) {
if (number < 0) {
return false;
}
int i = 0;
while ((long long) i * i <= number) {
if (i * i == number) {
return true;
}
i++;
}
return false;
}
int main() {
int testNumber = 16;
if (isPerfectSquare(testNumber)) {
std::cout << testNumber << " is a perfect square.\n";
} else {
std::cout << testNumber << " is not a perfect square.\n";
}
return 0;
}How It Works
Candidates advance from 0 while i * i has not passed 16. When i reaches 4, the product matches and the function returns true.
⚡ Integer Square Root
Use the standard library for a crisp, exact check.
Example 2 — Range Scan Using std::sqrt
Use std::sqrt and print all perfect squares from 1 to 50.
c++
#include <iostream>
#include <cmath>
bool isPerfectSquare(int num) {
if (num < 0) {
return false;
}
int root = static_cast<int>(std::sqrt(num));
return root * root == num;
}
int main() {
std::cout << "Perfect Squares in the Range 1 to 50:\n";
for (int i = 1; i <= 50; i++) {
if (isPerfectSquare(i)) {
std::cout << i << " ";
}
}
std::cout << "\n";
return 0;
}How It Works
Casting std::sqrt(num) to int gives a candidate root. 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 <iostream>
int main() {
std::cout << "First squares from k = 0 to 7:\n";
for (int k = 0; k <= 7; k++) {
int square = k * k;
std::cout << k << " * " << k << " = " << square << "\n";
}
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 cast std::sqrt(n).
Search
3
Compare square to n
Exact match means perfect square.
Rule
=
Return the verdict
true with root k, or false.
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 true |
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 std::sqrt
Show exact integer roots.
Example: avoid float sqrt.
6. Next: Average of N Numbers
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
No float rounding surprises with std::sqrt.
3. Two Clear Styles
Loop for clarity; std::sqrt for speed.
4. Generates Cleanly
k*k builds the sequence without scanning.
Pro Tip: lead with the loop in interviews, then mention std::sqrt as the robust alternative.
Usage Tips
Small habits that keep square checks interview-ready.
1. Guard Negatives
Return false immediately for n < 0.
2. Prefer std::sqrt + verify
Exact integer root for production code.
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 std::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 true 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 false for negatives in this tutorial.
Large n
Avoid float precision
Prefer std::sqrt from <cmath>.
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 ⇔ root² == n for n >= 0.
- 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
- static_cast<int>(std::sqrt(15))=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
std::sqrt. - Remember: 0 and 1 are perfect squares.
- Prefer
std::sqrtfrom<cmath>. The loop approach takes O(sqrt(n)) checks. Return false 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) |
| std::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 std::sqrt, reject negatives, and remember that 0 and 1 count.
Practice the three examples above, then continue to checking powers of 2.
n = k² means perfect square; verify with integers, not float sqrt.
Pro Tips
💡 Best Practices
✅ Do
- Reject negatives early
- Verify root * root == n
- Prefer std::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
std::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 and avoids floating-point concerns.
It means we only test candidate roots whose square has not passed n.
Yes. Cast the result to int (or long), then verify root * root equals n. That avoids relying on float equality alone.
No. Perfect square is about k * k; perfect number is about divisor sums.
Yes. 0 = 0 * 0.
Floating-point sqrt can be slightly off for large values; squaring the integer root confirms the answer.
About O(sqrt(n)) candidate checks for a single n.
Did you Know? 🔊
A perfect square can be arranged into a square grid with equal rows and columns. The gaps between consecutive squares (1, 4, 9, 16...) are 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