**π‘ Problem Formulation:** This article addresses the challenge of determining whether a given number is a perfect square in Python without utilizing the `sqrt()`

function. For instance, given the input 16, the output would affirm that 16 is a perfect square because 4 * 4 equals 16.

## Method 1: Iterative Approach

This method involves iterating over a range of numbers and squaring each one until it is equal to or greater than the input number. If a squared number is equal to the input, the input is a perfect square. This is a straightforward approach that is easy to understand and implement.

Here’s an example:

def is_perfect_square(num): if num num: return False return False print(is_perfect_square(16))

Output: `True`

This method compares each squared number with the input until it finds a match or exceeds it. It’s simple but can be slow for large numbers since it checks every number up to the input.

## Method 2: Binary Search Technique

The binary search technique divides the range of possible square roots and efficiently narrows down the search space. This method is more efficient than the iterative approach, especially for large numbers.

Here’s an example:

def is_perfect_square(num): if num < 1: return False low, high = 0, num while low <= high: mid = (low + high) // 2 if mid * mid == num: return True elif mid * mid < num: low = mid + 1 else: high = mid - 1 return False print(is_perfect_square(16))

Output: `True`

This snippet uses the binary search algorithm to find the perfect square. It is much faster than the iterative approach for large numbers because it reduces the search range in each step by half.

## Method 3: Exponentiation Check

By taking advantage of the property that a perfect square when raised to the power of 0.5 should yield an integer, this method can check for perfect squares. However, instead of using the `sqrt()`

function, we use exponentiation.

Here’s an example:

def is_perfect_square(num): if num < 1: return False guess = num // 2 guess_squared = guess ** 2 while guess_squared != num: guess = (guess + num // guess) // 2 guess_squared = guess ** 2 if guess_squared == num: return True if guess == num // guess: return False return True print(is_perfect_square(16))

Output: `True`

This snippet raises a guess to the power of two and compares the result to the input number. It optimizes the guess using the average of the guess and the quotient of the input and the guess. It can be slightly intricate but is efficient for larger numbers.

## Method 4: Mathematical Trick with Odd Numbers

This method involves the observation that all perfect squares are the sum of successive odd numbers. For example, 1+3=4, 1+3+5=9, and so on. Thus, by subtracting successive odd numbers, we can determine if a number is a perfect square.

Here’s an example:

def is_perfect_square(num): if num 0: num -= odd odd += 2 return num == 0 print(is_perfect_square(16))

Output: `True`

This code subtracts successive odd numbers from the input number and checks if it reaches zero. It’s a clever yet non-intuitive method. It’s fairly efficient, but still slower than binary search on very large numbers.

## Bonus One-Liner Method 5: Using Set Comprehension

A clever one-liner in Python uses set comprehension to check within the range if any number squared equals the input. This method is concise but not as efficient as the binary search.

Here’s an example:

is_perfect_square = lambda num: num in {x*x for x in range(num+1)} print(is_perfect_square(16))

Output: `True`

This one-liner creates a set of squares of all numbers up to the input and checks if the input is in this set. While concise, it suffers in efficiency due to the overhead of creating a whole set of squared numbers.

## Summary/Discussion

**Method 1:**Iterative Approach. Simple. Not efficient for large numbers.**Method 2:**Binary Search Technique. Efficient for large numbers. More complex to understand.**Method 3:**Exponentiation Check. No`sqrt()`

used. Needs careful implementation to ensure efficiency.**Method 4:**Mathematical Trick with Odd Numbers. Elegant mathematical insight. Can be slower than binary search for bigger numbers.**Method 5:**Set Comprehension One-Liner. Extremely concise. Not suitable for very large numbers due to memory and performance constraints.