Count of possible rotations of given Array to remove largest element from first half
Given an array arr[ ] with even length N, the task is to find the number of cyclic shifts (rotations) possible for this array, such that the first half of array does not contain the maximum element.
Examples:
Input: N = 6, arr[ ] = { 3, 3, 5, 3, 3, 3 }
Output: 3
Explanation: The maximum element here is 5 at index 2. This 5 can be shifted to second half of the array using any of the below three valid right shifts:
- shift by 1: (3, 3, 3, 5, 3, 3)
- shift by 2: (3, 3, 3, 3, 5, 3)
- shift by 3: (3, 3, 3, 3, 3, 5)
Input: N = 6, arr[ ] = {8, 8, 9, 8, 8, 9}
Output: 0
Explanation: Any rotation in the article wont help in removing the maximum element from 1st half, as there are two occurrences of 9 at index 2 and 5. So any rotation will keep atleast one 9 at index 0, 1 or 2.
Naive Approach: The most basic approach to solve this problem, is based on below idea:
Find all rotations of given array. In the end, just return the count of such rotations which do not have the maximum element in first half.
Time Complexity: O(N3) where N^2 is for rotations and N is for finding maximum in each rotation.
Auxiliary Space: O(1)
Efficient Approach: The idea to solve the problem is by traversing the array and some basic concepts of maths.
The idea is to find distance between maximum elements and simply check if the range is greater than half of array size. If yes, rotation is possible, or else rotation is not possible.
For case when rotation is possible, we can find the [range – (n/2)] as the valid number of rotations.
Follow the steps to solve the problem:
- Firstly, find the maximum element
- Then find the maximal ranges between pairs of maximum elements.
- A range with length m adds max(m-frac(N/2)+1, 0) to the answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int find( int arr[], int N)
{
int maxele = *max_element(arr, arr + N);
int left = -1;
int right = -1;
for ( int i = 0; i < N; i++) {
if (arr[i] == maxele) {
left = i;
break ;
}
}
for ( int i = N - 1; i >= 0; i--) {
if (arr[i] == maxele) {
right = i;
break ;
}
}
int ans = (N / 2) - (right - left);
if (ans <= 0) {
return 0;
}
else {
return ans;
}
}
int main()
{
int arr[] = { 3, 3, 5, 3, 3, 3 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << find(arr, N);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int find( int arr[], int N)
{
int maxele = Integer.MIN_VALUE;
for ( int i = 0 ; i < N; i++){
maxele = Math.max(arr[i], maxele);
}
int left = - 1 ;
int right = - 1 ;
for ( int i = 0 ; i < N; i++) {
if (arr[i] == maxele) {
left = i;
break ;
}
}
for ( int i = N - 1 ; i >= 0 ; i--) {
if (arr[i] == maxele) {
right = i;
break ;
}
}
int ans = (N / 2 ) - (right - left);
if (ans <= 0 ) {
return 0 ;
}
else {
return ans;
}
}
public static void main (String[] args) {
int arr[] = { 3 , 3 , 5 , 3 , 3 , 3 };
int N = arr.length;
System.out.print(find(arr, N));
}
}
|
Python3
def find(arr, N):
maxele = max (arr)
left = - 1
right = - 1
for i in range (N):
if (arr[i] = = maxele):
left = i
break
for i in range (N - 1 , - 1 , - 1 ):
if (arr[i] = = maxele):
right = i
break
ans = (N / / 2 ) - (right - left)
if (ans < = 0 ):
return 0
else :
return ans
arr = [ 3 , 3 , 5 , 3 , 3 , 3 ]
N = len (arr)
print (find(arr, N))
|
C#
using System;
class GFG {
static int find( int [] arr, int N)
{
int maxele = Int32.MinValue;
for ( int i = 0; i < N; i++) {
maxele = Math.Max(arr[i], maxele);
}
int left = -1;
int right = -1;
for ( int i = 0; i < N; i++) {
if (arr[i] == maxele) {
left = i;
break ;
}
}
for ( int i = N - 1; i >= 0; i--) {
if (arr[i] == maxele) {
right = i;
break ;
}
}
int ans = (N / 2) - (right - left);
if (ans <= 0) {
return 0;
}
else {
return ans;
}
}
public static void Main()
{
int [] arr = { 3, 3, 5, 3, 3, 3 };
int N = arr.Length;
Console.Write(find(arr, N));
}
}
|
Javascript
<script>
function find(arr, N) {
let maxele = Math.max([...arr]);
let left = -1;
let right = -1;
for (let i = 0; i < N; i++) {
if (arr[i] == maxele) {
left = i;
break ;
}
}
for (let i = N - 1; i >= 0; i--) {
if (arr[i] == maxele) {
right = i;
break ;
}
}
let ans = Math.floor(N / 2) - (right - left);
if (ans <= 0) {
return 0;
}
else {
return ans;
}
}
let arr = [3, 3, 5, 3, 3, 3];
let N = arr.length;
document.write(find(arr, N));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Last Updated :
28 Mar, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...