# Maximize number of continuous Automorphic numbers in C++

Given the task is to maximize the number of continuous Automorphic elements in a given array with N number of elements.

An automorphic number is a number whose square ends with the same digits as the number itself. For example 5 is an automorphic number as 5*5 = 25 and 25 ends with 5.

Let’s now understand what we have to do using an example −

Input − arr[]={5,3,625,6,8,1}

Output − 2

Explanation − Automorphic numbers present in the above array are 5, 625, 6 and 1 but the maximum continuous automorphic numbers are {625,6} which makes the output = 2.

Input − arr[]={33, 25, 1, 76, 4}

Output − 3

## Approach used in the below program as follows

• In main() function create a variable ‘n’ of type int and store in it, the size of given array.

• In function MaxAutomorphic initialize CurrentMax=0 and Maximum=0 both of type int to store the current maximum value and maximum value so far respectively.

• Loop from i=0 till i<n and check if given number is automorphic or not by calling the IsAutomorphic() function.

• In the IsAutomophic() function initialize a variable sqr= n*n of type int to store the square of number n

• Loop using the while loop with condition n>0 and compare the last digits of n and sqr to check if the number is automorphic or not.

• Back into the MaxAutomorphic() function, if number is not automorphic then set CurrentMax=0

• Else, if the number is found to be automorphic then add 1 to CurrentMax and store the greater number out of CurrentMax and Maximum into the Maximum variable.

## Example

Live Demo

#include <bits/stdc++.h>
using namespace std;
//Function to check if number is automorphic
bool IsAutomorphic(int n){
//Storing the square of n
int sqr = n * n;
//Comparing the digits
while (n > 0){
/*Return false if any digit of n doesn't
match with its square's last digits*/
if (n % 10 != sqr % 10)
return false;
n /= 10;
sqr /= 10;
}
return true;
}
int MaxAutomorphic(int arr[], int size){
int CurrentMax = 0, Maximum = 0;
for (int i = 0; i < size; i++){
//Checking if the element is non-automorphic
if (IsAutomorphic(arr[i]) == false)
CurrentMax = 0;
//Updating CurrentMax and Maximum if number is automorphic
else{
CurrentMax++;
Maximum = max(CurrentMax, Maximum);
}
}
return Maximum;
}
//Main function
int main(){
int arr[] = { 33, 25, 1, 76, 4 };
int size = sizeof(arr) / sizeof(arr);
cout << MaxAutomorphic(arr, size);
return 0;
}

## Output

If we run the above code we will get the following output −

3