Largest palindromic number in an array
Given an array of non-negative integers arr[]. The task is to find the largest number in the array which is palindrome. If no such number exits then print -1.
Examples:
Input: arr[] = {1, 232, 54545, 999991};
Output: 54545
Input: arr[] = {1, 2, 3, 4, 5, 50};
Output: 5
Method 1:
- Sort the array in ascending order.
- Start traversing the array from the end.
- The first number which is a palindrome is the required answer.
- If no palindromic number is found then print -1
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isPalindrome( int n)
{
int divisor = 1;
while (n / divisor >= 10)
divisor *= 10;
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing)
return false ;
n = (n % divisor) / 10;
divisor = divisor / 100;
}
return true ;
}
int largestPalindrome( int A[], int n)
{
sort(A, A + n);
for ( int i = n - 1; i >= 0; --i) {
if (isPalindrome(A[i]))
return A[i];
}
return -1;
}
int main()
{
int A[] = { 1, 232, 54545, 999991 };
int n = sizeof (A) / sizeof (A[0]);
cout << largestPalindrome(A, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static boolean isPalindrome( int n)
{
int divisor = 1 ;
while (n / divisor >= 10 )
divisor *= 10 ;
while (n != 0 ) {
int leading = n / divisor;
int trailing = n % 10 ;
if (leading != trailing)
return false ;
n = (n % divisor) / 10 ;
divisor = divisor / 100 ;
}
return true ;
}
static int largestPalindrome( int []A, int n)
{
Arrays.sort(A);
for ( int i = n - 1 ; i >= 0 ; --i) {
if (isPalindrome(A[i]))
return A[i];
}
return - 1 ;
}
public static void main(String []args)
{
int []A = { 1 , 232 , 54545 , 999991 };
int n = A.length;
System.out.println(largestPalindrome(A, n));
}
}
|
Python3
def isPalindrome(n) :
divisor = 1
while (n / divisor > = 10 ) :
divisor * = 10
while (n ! = 0 ) :
leading = n / / divisor
trailing = n % 10
if (leading ! = trailing) :
return False
n = (n % divisor) / / 10
divisor = divisor / / 100
return True
def largestPalindrome(A, n) :
A.sort()
for i in range (n - 1 , - 1 , - 1 ) :
if (isPalindrome(A[i])) :
return A[i]
return - 1
if __name__ = = "__main__" :
A = [ 1 , 232 , 54545 , 999991 ]
n = len (A)
print (largestPalindrome(A, n))
|
C#
using System;
class GFG
{
static bool isPalindrome( int n)
{
int divisor = 1;
while (n / divisor >= 10)
divisor *= 10;
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing)
return false ;
n = (n % divisor) / 10;
divisor = divisor / 100;
}
return true ;
}
static int largestPalindrome( int []A, int n)
{
Array.Sort(A);
for ( int i = n - 1; i >= 0; --i) {
if (isPalindrome(A[i]))
return A[i];
}
return -1;
}
public static void Main()
{
int []A = { 1, 232, 54545, 999991 };
int n = A.Length;
Console.WriteLine(largestPalindrome(A, n));
}
}
|
Javascript
<script>
function sort(a, n) {
var i, j, min, temp;
for (i = 0; i < n - 1; i++) {
min = i;
for (j = i + 1; j < n; j++)
if (a[j] < a[min])
min = j;
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
function isPalindrome(n)
{
var divisor = 1;
while (parseInt(n / divisor) >= 10)
divisor *= 10;
while (n != 0) {
var leading = parseInt(n / divisor);
var trailing = n % 10;
if (leading != trailing)
return false ;
n = parseInt((n % divisor) / 10);
divisor = parseInt(divisor / 100);
}
return true ;
}
function largestPalindrome( A, n)
{
sort(A,A.length);
for ( var i = n - 1; i >= 0; --i) {
if (isPalindrome(A[i]))
return A[i];
}
return -1;
}
var A = [ 1, 232, 54545, 999991 ];
var n = A.length;
document.write(largestPalindrome(A, n));
</script>
|
PHP
<?php
function isPalindrome( $n )
{
$divisor = 1;
while ((int)( $n / $divisor ) >= 10)
$divisor *= 10;
while ( $n != 0)
{
$leading = (int)( $n / $divisor );
$trailing = $n % 10;
if ( $leading != $trailing )
return false;
$n = (int)(( $n % $divisor ) / 10);
$divisor = (int)( $divisor / 100);
}
return true;
}
function largestPalindrome( $A , $n )
{
sort( $A );
for ( $i = $n - 1; $i >= 0; -- $i )
{
if (isPalindrome( $A [ $i ]))
return $A [ $i ];
}
return -1;
}
$A = array (1, 232, 54545, 999991);
$n = sizeof( $A );
echo largestPalindrome( $A , $n );
?>
|
Time complexity : O(nlogn)
Auxiliary space : O(1)
Method 2:
- Set a variable currentMax = -1 and start traversing the array.
- If current element arr[i] > currentMax and arr[i] is a palindrome.
- Then set currentMax = arr[i].
- Print currentMax in the end.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isPalindrome( int n)
{
int divisor = 1;
while (n / divisor >= 10)
divisor *= 10;
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing)
return false ;
n = (n % divisor) / 10;
divisor = divisor / 100;
}
return true ;
}
int largestPalindrome( int A[], int n)
{
int currentMax = -1;
for ( int i = 0; i < n; i++) {
if (A[i] > currentMax && isPalindrome(A[i]))
currentMax = A[i];
}
return currentMax;
}
int main()
{
int A[] = { 1, 232, 54545, 999991 };
int n = sizeof (A) / sizeof (A[0]);
cout << largestPalindrome(A, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static boolean isPalindrome( int n)
{
int divisor = 1 ;
while (n / divisor >= 10 )
divisor *= 10 ;
while (n != 0 ) {
int leading = n / divisor;
int trailing = n % 10 ;
if (leading != trailing)
return false ;
n = (n % divisor) / 10 ;
divisor = divisor / 100 ;
}
return true ;
}
static int largestPalindrome( int []A, int n)
{
int currentMax = - 1 ;
for ( int i = 0 ; i < n; i++) {
if (A[i] > currentMax && isPalindrome(A[i]))
currentMax = A[i];
}
return currentMax;
}
public static void main(String []args)
{
int []A = { 1 , 232 , 54545 , 999991 };
int n = A.length;
System.out.println(largestPalindrome(A, n));
}
}
|
Python3
def isPalindrome(n):
divisor = 1
while ( int (n / divisor) > = 10 ):
divisor * = 10
while (n ! = 0 ):
leading = int (n / divisor)
trailing = n % 10
if (leading ! = trailing):
return False
n = int ((n % divisor) / 10 )
divisor = int (divisor / 100 )
return True
def largestPalindrome(A, n):
currentMax = - 1
for i in range ( 0 , n, 1 ):
if (A[i] > currentMax and isPalindrome(A[i])):
currentMax = A[i]
return currentMax
if __name__ = = '__main__' :
A = [ 1 , 232 , 54545 , 999991 ]
n = len (A)
print (largestPalindrome(A, n))
|
C#
using System;
class GFG
{
static bool isPalindrome( int n)
{
int divisor = 1;
while (n / divisor >= 10)
divisor *= 10;
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing)
return false ;
n = (n % divisor) / 10;
divisor = divisor / 100;
}
return true ;
}
static int largestPalindrome( int []A, int n)
{
int currentMax = -1;
for ( int i = 0; i < n; i++) {
if (A[i] > currentMax && isPalindrome(A[i]))
currentMax = A[i];
}
return currentMax;
}
public static void Main()
{
int []A = { 1, 232, 54545, 999991 };
int n = A.Length;
Console.WriteLine(largestPalindrome(A, n));
}
}
|
Javascript
<script>
function isPalindrome(n)
{
var divisor = 1;
while (parseInt(n / divisor) >= 10)
divisor *= 10;
while (n != 0)
{
var leading = parseInt(n / divisor);
var trailing = n % 10;
if (leading != trailing)
return false ;
n = parseInt((n % divisor) / 10);
divisor = parseInt(divisor / 100);
}
return true ;
}
function largestPalindrome(A, n)
{
var currentMax = -1;
for ( var i = 0; i < n; i++)
{
if (A[i] > currentMax && isPalindrome(A[i]))
currentMax = A[i];
}
return currentMax;
}
var A = [ 1, 232, 54545, 999991 ];
var n = A.length;
document.write( largestPalindrome(A, n));
</script>
|
PHP
<?php
function isPalindrome( $n )
{
$divisor = 1;
while ((int)( $n / $divisor ) >= 10)
$divisor *= 10;
while ( $n != 0)
{
$leading = (int)( $n / $divisor );
$trailing = $n % 10;
if ( $leading != $trailing )
return false;
$n = ( $n % $divisor ) / 10;
$divisor = $divisor / 100;
}
return true;
}
function largestPalindrome( $A , $n )
{
$currentMax = -1;
for ( $i = 0; $i < $n ; $i ++)
{
if ( $A [ $i ] > $currentMax &&
isPalindrome( $A [ $i ]))
$currentMax = $A [ $i ];
}
return $currentMax ;
}
$A = array (1, 232, 54545, 999991);
$n = sizeof( $A );
echo (largestPalindrome( $A , $n ));
?>
|
Time complexity : O(n)
Auxiliary space : O(1)
Another Approach in Python using Reverse Slicing –
In this approach we will see how using the reverse slicing and comparing the element with the original element we can identify the largest palindromic number in an array.
C++
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
long int largest_palindrome( long int arr[], int n)
{
long int pal = -1;
for ( int i = 0; i < n; i++) {
string str = to_string(arr[i]);
string rev_str = str;
reverse(rev_str.begin(), rev_str.end());
if (str == rev_str) {
if (arr[i] > pal) {
pal = arr[i];
}
}
}
return pal;
}
int main()
{
long int arr[]
= { 1, 232, 54545, 999991, 8813200023188 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << largest_palindrome(arr, n) << endl;
return 0;
}
|
Java
public class Main {
public static long largest_palindrome( long [] arr)
{
long pal = - 1 ;
for ( long i : arr) {
if (String.valueOf(i).equals(
new StringBuilder(String.valueOf(i))
.reverse()
.toString())) {
if (i > pal) {
pal = i;
}
}
}
return pal;
}
public static void main(String[] args)
{
long [] arr
= { 1 , 232 , 54545 , 999991 , 8813200023188L };
System.out.println(largest_palindrome(arr));
}
}
|
Python3
def largest_palindrome(arr):
pal = - 1
for i in arr:
if str (i) = = str (i)[:: - 1 ]:
if i > pal:
pal = i
else :
pass
return pal
arr = [ 1 , 232 , 54545 , 999991 , 8813200023188 ]
print (largest_palindrome(arr))
|
C#
using System;
using System.Linq;
public class MainClass {
public static long largest_palindrome( long [] arr)
{
long pal = -1;
foreach ( long i in arr)
{
if (i.ToString()
== new string (
i.ToString().Reverse().ToArray())) {
if (i > pal) {
pal = i;
}
}
}
return pal;
}
public static void Main( string [] args)
{
long [] arr
= { 1, 232, 54545, 999991, 8813200023188L };
Console.WriteLine(largest_palindrome(arr));
}
}
|
Javascript
function largest_palindrome(arr){
let pal = -1;
let n = arr.length;
for (let i = 0;i<n;i++){
let txt = arr[i].toString();
let rev_txt = arr[i].toString().split( "" ).reverse().join( "" )
if (txt == rev_txt){
if (arr[i] > pal){
pal = arr[i];
}
else {
;
}
}
}
return pal;
}
arr = [1, 232, 54545, 999991,8813200023188];
console.log(largest_palindrome(arr));
|
Time Complexity – O(n), n is the size of the arr
Auxiliary Space – O(1), No extra space is being used apart from a single variable
Approach#4:using optimized approach
Algorithm
1. Initialize the largest_palindrome_number variable to 0.
2. Iterate through the array.
3. For each element, check if it is a palindrome.
4. If it is a palindrome and greater than the largest_palindrome_number, set largest_palindrome_number to the current element.
5. Iterate through the remaining elements in the array but only check the elements that have more digits than the largest_palindrome_number.
6. Return the largest_palindrome_number.
C++
#include <iostream>
#include <string>
#include<bits/stdc++.h>
bool isPalindrome( int n)
{
std::string str = std::to_string(n);
std::string reversedStr = str;
std::reverse(reversedStr.begin(), reversedStr.end());
return str == reversedStr;
}
int largestPalindromeOptimized( int arr[], int size)
{
int largestPalindromeNumber = 0;
for ( int i = 0; i < size; i++) {
if (isPalindrome(arr[i])
&& arr[i] > largestPalindromeNumber) {
largestPalindromeNumber = arr[i];
for ( int j = i + 1; j < size; j++) {
if (arr[j] > largestPalindromeNumber
&& std::to_string(arr[j]).length()
> std::to_string(
largestPalindromeNumber)
.length()) {
break ;
}
}
}
}
return largestPalindromeNumber;
}
int main()
{
int arr[] = { 1, 232, 54545, 999991 };
int size = sizeof (arr) / sizeof (arr[0]);
std::cout << "Largest Palindrome: "
<< largestPalindromeOptimized(arr, size)
<< std::endl;
return 0;
}
|
Java
public class Main {
public static boolean isPalindrome( int n)
{
return Integer.toString(n).equals(
new StringBuilder(Integer.toString(n))
.reverse()
.toString());
}
public static int largestPalindromeOptimized( int [] arr)
{
int largestPalindromeNumber = 0 ;
for ( int i = 0 ; i < arr.length; i++) {
if (isPalindrome(arr[i])
&& arr[i] > largestPalindromeNumber) {
largestPalindromeNumber = arr[i];
for ( int j = i + 1 ; j < arr.length; j++) {
if (arr[j] > largestPalindromeNumber
&& Integer.toString(arr[j]).length()
> Integer
.toString(
largestPalindromeNumber)
.length()) {
break ;
}
}
}
}
return largestPalindromeNumber;
}
public static void main(String[] args)
{
int [] arr = { 1 , 232 , 54545 , 999991 };
System.out.println(largestPalindromeOptimized(arr));
}
}
|
Python3
def is_palindrome(n):
return str (n) = = str (n)[:: - 1 ]
def largest_palindrome_optimized(arr):
largest_palindrome_number = 0
for i in range ( len (arr)):
if is_palindrome(arr[i]) and arr[i] > largest_palindrome_number:
largest_palindrome_number = arr[i]
for j in range (i + 1 , len (arr)):
if arr[j] > largest_palindrome_number and len ( str (arr[j])) > len ( str (largest_palindrome_number)):
break
return largest_palindrome_number
arr = [ 1 , 232 , 54545 , 999991 ]
print (largest_palindrome_optimized(arr))
|
C#
using System;
public class GFG {
static bool IsPalindrome( int n)
{
string str = n.ToString();
char [] charArray = str.ToCharArray();
Array.Reverse(charArray);
string reversedStr = new string (charArray);
return str == reversedStr;
}
static int LargestPalindromeOptimized( int [] arr)
{
int largestPalindromeNumber = 0;
for ( int i = 0; i < arr.Length; i++) {
if (IsPalindrome(arr[i])
&& arr[i] > largestPalindromeNumber) {
largestPalindromeNumber = arr[i];
for ( int j = i + 1; j < arr.Length; j++) {
if (arr[j] > largestPalindromeNumber
&& arr[j].ToString().Length
> largestPalindromeNumber
.ToString()
.Length) {
break ;
}
}
}
}
return largestPalindromeNumber;
}
public static void Main( string [] args)
{
int [] arr = { 1, 232, 54545, 999991 };
Console.WriteLine(LargestPalindromeOptimized(arr));
}
}
|
Javascript
function is_palindrome(n) {
return String(n) === String(n).split( '' ).reverse().join( '' );
}
function largest_palindrome_optimized(arr) {
let largest_palindrome_number = 0;
for (let i = 0; i < arr.length; i++) {
if (is_palindrome(arr[i]) && arr[i] > largest_palindrome_number) {
largest_palindrome_number = arr[i];
for (let j = i + 1; j < arr.length; j++) {
if (arr[j] > largest_palindrome_number && String(arr[j]).length >
String(largest_palindrome_number).length) {
break ;
}
}
}
}
return largest_palindrome_number;
}
const arr = [1, 232, 54545, 999991];
console.log(largest_palindrome_optimized(arr));
|
Time Complexity: The code has two nested loops, one for iterating through the array, and another for iterating through the remaining elements. However, the inner loop will only be executed for a small subset of the array elements. Therefore, the time complexity of the code is O(n*k^2), where n is the length of the array and k is the maximum number of digits in any element in the array.
Space Complexity: The code uses a constant amount of additional memory, so the space complexity is O(1).
Last Updated :
21 Sep, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...