Write a Python Program to check whether a given number is a palindrome.

**Palindrome number in Python** is a number that remains the same when its digits are reversed. It reads the same forwards and backwards. To check if a number is a palindrome, we compare it with its reverse. If they are equal, the number is a palindrome.

**Example:** Numbers like 121, 454, and 888 are all palindrome numbers as they read the same forwards and backwards.

There are several ways to check whether a number is a palindrome or not in Python. Let’s explore various approaches to implement this function:

**Palindrome Number Program in Python**

- Palindrome Program in Python using While Loop
- Palindrome Program in Python using Built-in Function
- Palindrome Program in Python using Recursion
- Palindrome Program in Python using Slicing

**String Palindrome Program in Python**

In this method, we check for Palindrome number using while loop.

Here is source code of the Python Program to check whether a given number is a palindrome. The program output is also shown below.

n=int(input("Enter number:")) temp=n rev=0 while(n>0): dig=n%10 rev=rev*10+dig n=n//10 if(temp==rev): print("The number is a palindrome!") else: print("The number isn't a palindrome!")

1. The program works by first creating a variable called **reversed_number** and initializing it to 0.

2. Then, it uses a while loop to iterate over the digits of the number, starting from the least significant digit.

3. For each digit, the program adds it to the **reversed_number** variable and divides the number by 10 to get the next digit.

4. The while loop terminates when the value of the number is 0. This is because the least significant digit of a number is always 0, so once we reach the least significant digit, we know that we have reversed the entire number.

5. After the while loop terminates, the program compares the **reversed_number** variable to the original number.

6. If they are the same, then the number is a palindrome and the program returns True. Otherwise, the program returns False.

**Time Complexity: O(log n)**

The time complexity of the program is O(log n) as it depends on the number of digits in the input.

**Space Complexity: O(1)**

The space complexity of this program is O(1) because it uses a constant amount of extra space to store the variables ‘temp’, ‘rev’, and ‘dig’.

**Testcase 1:** In this case, we enter the number “121” as input to check whether it is a palindrome number or not.

Enter number:121 The number is a palindrome!

**Testcase 2:** In this case, we enter the number “567” as input to check whether the entered number is palindrome number or not.

Enter number:567 The number isn't a palindrome!

In this method, we use the built-in reversed() function. The reversed() function takes an iterable (e.g., a string, a list, or a tuple) and returns a reversed iterator.

Here is source code of the Python Program to check whether a given number is a palindrome or not using Built-in Function.

# Palindrome Program in Python using Built-in Function def is_palindrome(n): return str(n) == ''.join(reversed(str(n))) # Get the number from the user n = int(input("Enter number: ")) # Check if the number is a palindrome if is_palindrome(n): print("The number is a palindrome!") else: print("The number is not a palindrome.")

1. The user is prompted to enter a number.

2. The number is converted to a string.

3. The **reversed() function** is used to reverse the string.

4. The reversed string is compared to the original string.

5. If the reversed string is equal to the original string, then the number is a palindrome and the program prints “The number is a palindrome!”.

6. Otherwise, the number is not a palindrome and the program prints “The number is not a palindrome.”.

**Time complexity: O(n)**

The time complexity of the program is O(n), where n is the number of digits in the number. This is because the str() function takes O(n) time to convert the number to a string, the reversed() function takes O(n) time to reverse the string, and the ”.join() function takes O(n) time to concatenate the strings.

**Space complexity: O(1)**

The space complexity of the program is O(1), because it only uses a constant amount of extra space to store the variables n, str(n), and ”.join(reversed(str(n))).

In this case, we enter the number “12321” as input to check whether it is a palindrome number or not.

Enter number:12321 The number is a palindrome!

In this method, we use the built-in reversed() function. The reversed() function takes an iterable (e.g., a string, a list, or a tuple) and returns a reversed iterator.

Here is source code of the Python Program to check whether a given number is a palindrome or not using Recursion.

def is_palindrome(n, temp, rev=0): if n == 0: if temp == rev: return "The number is a palindrome!" else: return "The number isn't a palindrome!" else: dig = n % 10 rev = rev * 10 + dig n = n // 10 return is_palindrome(n, temp, rev) n = int(input("Enter number:")) result = is_palindrome(n, n) print(result)

1. The program begins by defining a function **is_palindrome** that checks whether a given number is a palindrome using recursion.

2. The function takes three parameters: n (the number being checked), temp (the original number), and rev (the reversed number). It also has a base case to handle when n becomes 0.

3. In the base case, it checks whether the reversed number (rev) is equal to the original number (temp) and returns the appropriate message.

4. If the base case is not met, the function proceeds with the recursion. It extracts the last digit (dig) of the number, updates the reversed number (rev), and removes the last digit from n. The function is then recursively called with the updated values.

5. The program prompts the user to enter a number and stores it in the variable n.

6. The **is_palindrome** function is called with the user’s input, and the result is stored in the variable result.

7. The program prints the result, indicating whether the input number is a palindrome or not.

**Time Complexity: O(log10(n))**

The program has a time complexity of O(log10(n)) because it processes each digit of the input number once, and the number of digits is approximately log10(n).

**Space Complexity: O(log10(n))**

The space complexity is also O(log10(n)) since the recursion depth and stack memory usage depend on the number of digits in the input.

**Testcase 1:** In this case, we enter the number “545” as input to check whether it is a palindrome number or not.

Enter number:545 The number is a palindrome!

**Testcase 2:** In this case, we enter the number “678” as input to check whether the entered number is palindrome number or not.

Enter number:678 The number isn't a palindrome!

In this method, the program uses slicing to reverse the number’s digits and then compares it with the original number to check for palindromic properties.

Here is source code of the Python Program to check whether a given number is a palindrome or not using Slicing.

def is_palindrome(n): # Convert the number to a string num_str = str(n) # Use slicing to reverse the string reversed_str = num_str[::-1] # Compare the original string with the reversed string return num_str == reversed_str n = int(input("Enter a number:")) if is_palindrome(n): print("The number is a palindrome!") else: print("The number is not a palindrome.")

1. The program begins by defining a function, **is_palindrome(n)**, which takes an integer n as its input.

2. Inside the function, it converts the integer n to a string using **str(n)**.

3. Using string slicing with **[::-1]**, it reverses the string, creating a new string called **reversed_str**.

4. The program then compares the original string **num_str** with the reversed string **reversed_str** to determine if the number is a palindrome.

5. If the strings are equal, it returns True, indicating that the number is a palindrome. Otherwise, it returns False.

**Time Complexity: O(N)**

The time complexity of this program is O(N), where N is the number of digits in the input number n. String slicing and string comparisons both have linear time complexity.

**Space Complexity: O(N)**

The space complexity is also linear and depends on the input’s size, used mainly for storing the reversed string reversed_str.

In this case, we enter the number “1368631” as input to check whether it is a palindrome number or not.

Enter number:1368631 The number is a palindrome!

To practice programs on every topic in Python, please visit “Programming Examples in Python”.

**Related Posts:**

- Check Information Technology Books
- Check Python Books
- Apply for Programming Internship
- Practice Programming MCQs
- Apply for Python Internship