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

• Last Updated : 01 Apr, 2021

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++

 `// 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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up