# Minimum count of elements required to obtain the given Array by repeated mirror operations

Given an array arr[] consisting of N integers, the task is to find the array K[] of minimum possible length such that after performing multiple mirror operations on K[], the given array arr[] can be obtained.

Mirror Operation: Appending all the array elements to the original array in reverse order.
Illustration:
arr[] = {1, 2, 3}
After 1st mirror operation, arr[] modifies to {1, 2, 3, 3, 2, 1}
After 2nd mirror operation, arr[] modifies to {1, 2, 3, 3, 2, 1, 1, 2, 3, 3, 2, 1}

Examples:

Input: N = 6, arr[] = { 1, 2, 3, 3, 2, 1 }
Output:
Explanation:
Subarrays {1, 2, 3} and {3, 2, 1} are mirror images of each other.
Single mirror operation on {1, 2, 3} obtains the given array.
Therefore, the minimum number of elements required is 3.

Input: N = 8, arr[] = { 1, 2, 2, 1, 1, 2, 2, 1 }
Output:
Explanation:
Subarrays {1, 2, 2, 1} and {1, 2, 2, 1} are mirror images of each other.
Subarray {1, 2} and {2, 1} are mirror images of each other.
{1, 2} -> {1, 2, 2, 1} -> {1, 2, 2, 1, 1, 2, 2, 1}
Therefore, the minimum number of elements required is 2.

Naive Approach:
The simplest approach to solve the problem is to generate all the possible subarrays from the given array of size less than equal to N/2 and, for each subarray, check if performing mirror operation gives the array arr[] or not. Print the minimum length subarray satisfying the condition. If no subarray is found to be satisfying, print No

Time Complexity: O(N3
Auxiliary Space: O(N)

Efficient Approach:
The above approach can be further optimized using Divide and Conquer technique. Follow the steps below to solve the problem:

• Initialize a variable K = N and then, check whether the prefix of A[] of length K is a palindrome or not.
• If the prefix of length K is a palindrome then divide K by 2 and perform the above checking.
• If the prefix is not a palindrome then the answer is the current value of K.
• Keep checking while K > 0 until K is odd.
• If K is odd, then print the current value of K.

Below is the implementation of the above approach:

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find minimum number ` `// of elements required to form A[] ` `// by performing mirroring operation ` `int` `minimumrequired(``int` `A[], ``int` `N) ` `{ ` `    ``// Initialize K ` `    ``int` `K = N; ` ` `  `    ``int` `ans; ` ` `  `    ``while` `(K > 0) { ` ` `  `        ``// Odd length array ` `        ``// cannot be formed by ` `        ``// mirror operation ` `        ``if` `(K % 2 == 1) { ` `            ``ans = K; ` `            ``break``; ` `        ``} ` ` `  `        ``bool` `ispalindrome = 1; ` ` `  `        ``// Check if prefix of ` `        ``// length K is palindrome ` `        ``for` `(``int` `i = 0; i < K / 2; i++) { ` ` `  `            ``// Check if not a palindrome ` `            ``if` `(A[i] != A[K - 1 - i]) ` ` `  `                ``ispalindrome = 0; ` `        ``} ` ` `  `        ``// If found to be palindrome ` `        ``if` `(ispalindrome) { ` `            ``ans = K / 2; ` `            ``K /= 2; ` `        ``} ` ` `  `        ``// Otherwise ` `        ``else` `{ ` `            ``ans = K; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Return the final answer ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 2, 2, 1, 1, 2, 2, 1 }; ` `    ``int` `N = ``sizeof` `a / ``sizeof` `a; ` ` `  `    ``cout << minimumrequired(a, N); ` `    ``return` `0; ` `} `

 `// Java Program to implement ` `// the above approach ` `class` `GFG{ ` `   `  `// Function to find minimum number ` `// of elements required to form A[] ` `// by performing mirroring operation ` `static` `int` `minimumrequired(``int` `A[], ``int` `N) ` `{ ` `    ``// Initialize K ` `    ``int` `K = N; ` `  `  `    ``int` `ans=``0``; ` `  `  `    ``while` `(K > ``0``) ` `    ``{ ` `  `  `        ``// Odd length array ` `        ``// cannot be formed by ` `        ``// mirror operation ` `        ``if` `(K % ``2` `== ``1``)  ` `        ``{ ` `            ``ans = K; ` `            ``break``; ` `        ``} ` `  `  `        ``int` `ispalindrome = ``1``; ` `  `  `        ``// Check if prefix of ` `        ``// length K is palindrome ` `        ``for` `(``int` `i = ``0``; i < K / ``2``; i++) ` `        ``{ ` `  `  `            ``// Check if not a palindrome ` `            ``if` `(A[i] != A[K - ``1` `- i]) ` `  `  `                ``ispalindrome = ``0``; ` `        ``} ` `  `  `        ``// If found to be palindrome ` `        ``if` `(ispalindrome == ``1``) ` `        ``{ ` `            ``ans = K / ``2``; ` `            ``K /= ``2``; ` `        ``} ` `  `  `        ``// Otherwise ` `        ``else`  `        ``{ ` `            ``ans = K; ` `            ``break``; ` `        ``} ` `    ``} ` `  `  `    ``// Return the final answer ` `    ``return` `ans; ` `} ` `  `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `a[] = { ``1``, ``2``, ``2``, ``1``, ``1``, ``2``, ``2``, ``1` `}; ` `    ``int` `N = a.length; ` `  `  `    ``System.out.println(minimumrequired(a, N)); ` `} ` `} ` ` `  `// This code is contributed by rock_cool`

 `# Python3 program to implement  ` `# the above approach  ` ` `  `# Function to find minimum number  ` `# of elements required to form A[]  ` `# by performing mirroring operation  ` `def` `minimumrequired(A, N): ` `     `  `    ``# Initialize K  ` `    ``K ``=` `N ` `     `  `    ``while` `(K > ``0``): ` `         `  `        ``# Odd length array  ` `        ``# cannot be formed by  ` `        ``# mirror operation ` `        ``if` `(K ``%` `2``) ``=``=` `1``: ` `            ``ans ``=` `K ` `            ``break` `         `  `        ``ispalindrome ``=` `1` `         `  `        ``# Check if prefix of  ` `        ``# length K is palindrome  ` `        ``for` `i ``in` `range``(``0``, K ``/``/` `2``): ` `             `  `            ``# Check if not a palindrome ` `            ``if` `(A[i] !``=` `A[K ``-` `1` `-` `i]): ` `                ``ispalindrome ``=` `0` `                 `  `        ``# If found to be palindrome  ` `        ``if` `(ispalindrome ``=``=` `1``): ` `            ``ans ``=` `K ``/``/` `2` `            ``K ``=` `K ``/``/` `2` `             `  `        ``# Otherwise ` `        ``else``: ` `            ``ans ``=` `K ` `            ``break` `     `  `    ``# Return the final answer  ` `    ``return` `ans ` ` `  `# Driver code ` `A ``=` `[ ``1``, ``2``, ``2``, ``1``, ``1``, ``2``, ``2``, ``1` `] ` `N ``=` `len``(A) ` ` `  `print``(minimumrequired(A, N)) ` `         `  `# This code is contributed by VirusBuddah_ `

 `// C# program to implement ` `// the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to find minimum number ` `// of elements required to form []A ` `// by performing mirroring operation ` `static` `int` `minimumrequired(``int``[] A, ``int` `N) ` `{ ` `     `  `    ``// Initialize K ` `    ``int` `K = N; ` ` `  `    ``int` `ans = 0; ` ` `  `    ``while` `(K > 0)  ` `    ``{ ` ` `  `        ``// Odd length array ` `        ``// cannot be formed by ` `        ``// mirror operation ` `        ``if` `(K % 2 == 1)  ` `        ``{ ` `            ``ans = K; ` `            ``break``; ` `        ``} ` ` `  `        ``int` `ispalindrome = 1; ` ` `  `        ``// Check if prefix of ` `        ``// length K is palindrome ` `        ``for``(``int` `i = 0; i < K / 2; i++) ` `        ``{ ` ` `  `            ``// Check if not a palindrome ` `            ``if` `(A[i] != A[K - 1 - i]) ` `                ``ispalindrome = 0; ` `        ``} ` ` `  `        ``// If found to be palindrome ` `        ``if` `(ispalindrome == 1) ` `        ``{ ` `            ``ans = K / 2; ` `            ``K /= 2; ` `        ``} ` ` `  `        ``// Otherwise ` `        ``else` `        ``{ ` `            ``ans = K; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Return the readonly answer ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int``[] a = { 1, 2, 2, 1, 1, 2, 2, 1 }; ` `    ``int` `N = a.Length; ` ` `  `    ``Console.WriteLine(minimumrequired(a, N)); ` `} ` `} ` ` `  `// This code is contributed by amal kumar choubey `

Output:
```2
```

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.