# Majority element in a circular array of 0’s and 1’s

Given a circular array containing only 0’s and 1’s, of size n where n = p*q (p and q are both odd integers). The task is to check if there is a way such that 1 will be in majority after applying the following operations:

1. Divide circular array into p subarrays each of size q.
2. In each subarray, the number which is in majority will get stored into array B.
3. Now, 1 will said to be in majority if it is in majority into array B.

Note: A number is in majority in an array if it occurs more than half times of the size of an array.

Examples:

Input: p = 3, q = 3, array[] = {0, 0, 1, 1, 0, 1, 1, 0, 0}
Output: Yes
Assume index of the array from 1 to N, Since the array is circular so index N and 1 will be adjacent.
Divide this circular array into subarray in this way :-
{2, 3, 4}, {5, 6, 7} and {8, 9, 1}. [These are the index of elements]
In {2, 3, 4}, 1 is in majority,
in {5, 6, 7}, again 1 is in majority and
In {8, 9, 1}, 0 is in majority.
Now insert 1, 1, 0 into array B so array B = {1, 1, 0}
In array B, 1 is the majority element so print Yes.

Input: p = 3, q = 3, array[] = {1, 0, 0, 1, 1, 0, 1, 0, 0}
Output: No
No matter how you divide this circular subarray,
1 will not be in majority. Hence, the answer is No.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. First of all, iterate over the circular array and count the total number of 1’s in each of p subarray(of size q).
2. Store this number into another array (of size p).
3. If in this case, 1 is in majority then, print yes.
4. Else take another set by moving the previous set’s index 1 unit either increasing or decreasing it, and keep track of only those indices which are new in given set and update number of 1’s in the array.
5. Repeat the 2nd and 3rd step.

We will repeat q times if there is no majority of 1 found until that, the answer would be NO, else ( like in the previous example case ) the answer would be 1.
Since at the maximum, we can repeat this process q times and each time we are tracking only two elements in each of p subarray.

Explanation:
In given example-1, we will divide circular subarray as [indices] => {1, 2, 3}, {4, 5, 6}, {7, 8, 9} and store number of 1’s in another array which are [1, 2, 1] in subarrays respectively.

Taking another set in example 1 by increasing 1 unit so set will be {2, 3, 4}, {5, 6, 7}, {8, 9, 1} now in set 1 only change is inclusion of element 4 and removal of element 1, we will only track these so updated number of 1’s will be 2, 2, 0.

Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to check if 1 is the majority ` `// element or not ` `void` `majority(``bool` `a[], ``int` `p, ``int` `q, ``int` `size) ` `{ ` `    ``// assuming starting and ending index of 1st subarray ` `    ``int` `start = 0, ends = q; ` ` `  `    ``// to store majority of p ` `    ``int` `arr[p]; ` ` `  `    ``// subarrays each of size q ; ` `    ``int` `k = 0; ` ` `  `    ``// Loop to calculate total number ` `    ``// of 1's in subarray which will get ` `    ``// stored in array arr[] ` `    ``while` `(k < p) { ` `        ``int` `one = 0; ` `        ``for` `(``int` `j = start; j < ends; j++) { ` `            ``if` `(a[j] == 1) { ` `                ``one++; ` `            ``} ` `        ``} ` ` `  `        ``// starting index of next subarray ` `        ``start = ends; ` ` `  `        ``// ending index of next subarray ` `        ``ends = ends + q; ` ` `  `        ``// storing 1's ` `        ``arr[k] = one; ` `        ``k++; ` `    ``} ` ` `  `    ``start = 0; ` `    ``ends = q; ` ` `  `    ``// variable to keep a check ` `    ``// if 1 is in majority or not ` `    ``bool` `found = 0; ` ` `  `    ``// In this case, we are repeating ` `    ``// the task of calculating ` `    ``// total number of 1's backward ` `    ``while` `(ends > 0) { ` ` `  `        ``// to store the total number of 1's ` `        ``int` `dist_one = 0; ` ` `  `        ``// Check if 1 is in majority in ` `        ``// this subarray ` `        ``for` `(``int` `i = 0; i < p; i++) ` `            ``if` `(arr[i] > q / 2) ` `                ``dist_one++; ` ` `  `        ``// If 1 is in majority return ` `        ``if` `(dist_one > p / 2) { ` `            ``found = 1; ` `            ``cout << ``"Yes"` `<< endl; ` ` `  `            ``return``; ` `        ``} ` ` `  `        ``// shifting starting index of ` `        ``// subarray by 1 unit leftwards ` `        ``start--; ` ` `  `        ``// shifting ending index of ` `        ``// subarray by 1 unit leftwards ` `        ``ends--; ` ` `  `        ``// to ensure it is a valid index ` `        ``// ( array is circular) -1 index means ` `        ``// last index of a circular array ` `        ``if` `(start < 0) ` `            ``start = size + start; ` ` `  `        ``int` `st = start, en = ends, l = 0; ` ` `  `        ``// now to track changes occur ` `        ``// due to shifting of the subarray ` `        ``while` `(en < size) { ` ` `  `            ``if` `(a[st % size] != a[en % size]) { ` ` `  `                ``// st refers to starting index of ` `                ``// new subarray and en refers to ` `                ``// last element of of same subarray ` `                ``// but in previous iteration ` `                ``if` `(a[st % size] == 1) ` `                    ``arr[l]++; ` ` `  `                ``else` `                    ``arr[l]--; ` `            ``} ` `            ``l++; ` ` `  `            ``// now repeating the same ` `            ``// for other subarrays too ` `            ``st = (st + q); ` `            ``en = en + q; ` `        ``} ` `    ``} ` ` `  `    ``if` `(found == 0) { ` `        ``cout << ``"No"` `<< endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `p = 3, q = 3; ` `    ``int` `n = p * q; ` ` `  `    ``bool` `a[] = { 0, 0, 1, 1, 0, 1, 1, 0, 0 }; ` ` `  `    ``// circular array of given size ` `    ``majority(a, p, q, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach ` ` `  `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` `// Function to check if 1 is the majority ` `// element or not ` `static` `void` `majority(``int` `a[], ``int` `p, ``int` `q, ``int` `size) ` `{ ` `    ``// assuming starting and ending index of 1st subarray ` `    ``int` `start = ``0``, ends = q; ` `  `  `    ``// to store majority of p ` `    ``int` `[]arr = ``new` `int``[p]; ` `  `  `    ``// subarrays each of size q ; ` `    ``int` `k = ``0``; ` `  `  `    ``// Loop to calculate total number ` `    ``// of 1's in subarray which will get ` `    ``// stored in array arr[] ` `    ``while` `(k < p) { ` `        ``int` `one = ``0``; ` `        ``for` `(``int` `j = start; j < ends; j++) { ` `            ``if` `(a[j] == ``1``) { ` `                ``one++; ` `            ``} ` `        ``} ` `  `  `        ``// starting index of next subarray ` `        ``start = ends; ` `  `  `        ``// ending index of next subarray ` `        ``ends = ends + q; ` `  `  `        ``// storing 1's ` `        ``arr[k] = one; ` `        ``k++; ` `    ``} ` `  `  `    ``start = ``0``; ` `    ``ends = q; ` `  `  `    ``// variable to keep a check ` `    ``// if 1 is in majority or not ` `    ``boolean`  `found = ``false``; ` `  `  `    ``// In this case, we are repeating ` `    ``// the task of calculating ` `    ``// total number of 1's backward ` `    ``while` `(ends > ``0``) { ` `  `  `        ``// to store the total number of 1's ` `        ``int` `dist_one = ``0``; ` `  `  `        ``// Check if 1 is in majority in ` `        ``// this subarray ` `        ``for` `(``int` `i = ``0``; i < p; i++) ` `            ``if` `(arr[i] > q / ``2``) ` `                ``dist_one++; ` `  `  `        ``// If 1 is in majority return ` `        ``if` `(dist_one > p / ``2``) { ` `            ``found = ``true``; ` `            ``System.out.println( ``"Yes"` `); ` `  `  `            ``return``; ` `        ``} ` `  `  `        ``// shifting starting index of ` `        ``// subarray by 1 unit leftwards ` `        ``start--; ` `  `  `        ``// shifting ending index of ` `        ``// subarray by 1 unit leftwards ` `        ``ends--; ` `  `  `        ``// to ensure it is a valid index ` `        ``// ( array is circular) -1 index means ` `        ``// last index of a circular array ` `        ``if` `(start < ``0``) ` `            ``start = size + start; ` `  `  `        ``int` `st = start, en = ends,l = ``0``; ` `  `  `        ``// now to track changes occur ` `        ``// due to shifting of the subarray ` `        ``while` `(en < size) { ` `  `  `            ``if` `(a[st % size] != a[en % size]) { ` `  `  `                ``// st refers to starting index of ` `                ``// new subarray and en refers to ` `                ``// last element of of same subarray ` `                ``// but in previous iteration ` `                ``if` `(a[st % size] == ``1``) ` `                    ``arr[l]++; ` `  `  `                ``else` `                    ``arr[l]--; ` `            ``} ` `            ``l++; ` `  `  `            ``// now repeating the same ` `            ``// for other subarrays too ` `            ``st = (st + q); ` `            ``en = en + q; ` `        ``} ` `    ``} ` `  `  `    ``if` `(found == ``false` `) { ` `        ``System.out.println( ``"No"` `); ` `    ``} ` `} ` `  `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `p = ``3``, q = ``3``; ` `    ``int` `n = p * q; ` `  `  `    ``int` `a[] = { ``0``, ``0``, ``1``, ``1``, ``0``, ``1``, ``1``, ``0``, ``0` `}; ` `  `  `    ``// circular array of given size ` `    ``majority(a, p, q, n); ` `  `  `     `  `} ` `} `

// This code is Contributed by tufan_gupta2000

[/sourcecode]

## Python3

 `# Python3 implementation of ` `# above approach  ` ` `  `# Function to check if 1 is  ` `# the majority element or not  ` `def` `majority(a, p, q, size) : ` ` `  `    ``# assuming starting and  ` `    ``# ending index of 1st subarray  ` `    ``start ``=` `0` `    ``ends ``=` `q  ` ` `  `    ``# to store arr = [] ` `    ``arr ``=` `[``None``] ``*` `p ` `     `  `    ``# subarrays each of size q  ` `    ``k ``=` `0` `     `  `    ``# Loop to calculate total number  ` `    ``# of 1's in subarray which  ` `    ``# will get stored in array arr ` `    ``while` `(k < p):  ` `        ``one ``=` `0` `        ``for` `j ``in` `range``(start, ends):  ` `            ``if` `(a[j] ``=``=` `1``):  ` `                ``one ``=` `one ``+` `1` `             `  `        ``# starting index of  ` `        ``# next subarray  ` `        ``start ``=` `ends  ` ` `  `        ``# ending index of next ` `        ``# subarray  ` `        ``ends ``=` `ends ``+` `q  ` ` `  `        ``# storing 1's  ` `        ``arr[k] ``=` `one ` `        ``k ``=` `k ``+` `1` `     `  `    ``start ``=` `0` `    ``ends ``=` `q  ` ` `  `    ``# variable to keep a check  ` `    ``# if 1 is in majority or not  ` `    ``found ``=` `0` ` `  `    ``# In this case, we are  ` `    ``# repeating the task of  ` `    ``# calculating total number ` `    ``# of 1's backward  ` `    ``while` `(ends > ``0``) :  ` ` `  `        ``# to store the total  ` `        ``# number of 1's  ` `        ``dist_one ``=` `0` `  `  `        ``# Check if 1 is in majority  ` `        ``# in this subarray  ` `        ``for` `i ``in` `range``(``0``, p): ` `            ``if` `(arr[i] > q ``/` `2``):  ` `                ``dist_one ``=` `dist_one ``+` `1` ` `  `        ``# If 1 is in majority return  ` `        ``if` `(dist_one > p ``/` `2``) : ` `            ``found ``=` `1` `            ``print``(``"Yes"``)  ` `            ``return` ` `  `        ``# shifting starting index of  ` `        ``# subarray by 1 unit leftwards  ` `        ``start ``=` `start ``-` `1` ` `  `        ``# shifting ending index  ` `        ``# of subarray by 1 unit  ` `        ``# leftwards  ` `        ``ends ``=` `ends ``-` `1` ` `  `        ``# to ensure it is a valid  ` `        ``# index( array is circular) -1 ` `        ``# index means last index of ` `        ``# a circular array  ` `        ``if` `(start < ``0``): ` `            ``start ``=` `size ``+` `start ` ` `  `        ``st ``=` `start ` `        ``en ``=` `ends ` `        ``l ``=` `0` ` `  `        ``# now to track changes occur  ` `        ``# due to shifting of the  ` `        ``# subarray  ` `        ``while` `(en < size) : ` ` `  `            ``if` `(a[st ``%` `size] !``=` `a[en ``%` `size]) : ` ` `  `                ``# st refers to starting index of  ` `                ``# new subarray and en refers to  ` `                ``# last element of of same subarray  ` `                ``# but in previous iteration  ` `                ``if` `(a[st ``%` `size] ``=``=` `1``): ` `                    ``arr[l] ``=` `arr[l] ``+` `1` ` `  `                ``else``: ` `                    ``arr[l] ``=` `arr[l] ``-` `1` `             `  `            ``l ``=` `l ``+` `1` ` `  `            ``# now repeating the same  ` `            ``# for other subarrays too  ` `            ``st ``=` `(st ``+` `q)  ` `            ``en ``=` `en ``+` `q  ` `         `  `    ``if` `(found ``=``=` `0``) :  ` `        ``print``(``"No"``)  ` `     `  `# Driver code  ` `p ``=` `3` `q ``=` `3` `n ``=` `p ``*` `q ` ` `  `a ``=` `[ ``0``, ``0``, ``1``, ``1``, ``0``, ``1``, ``1``, ``0``, ``0` `]  ` ` `  `# circular array of given size  ` `majority(a, p, q, n) ` ` `  `# This code is contributed ` `# by Yatin Gupta `

## C#

 `// C# implementation of above approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Function to check if 1 is the  ` `// majority element or not  ` `public` `static` `void` `majority(``int``[] a, ``int` `p,  ` `                            ``int` `q, ``int` `size) ` `{ ` `    ``// assuming starting and ending ` `    ``// index of 1st subarray  ` `    ``int` `start = 0, ends = q; ` ` `  `    ``// to store majority of p  ` `    ``int``[] arr = ``new` `int``[p]; ` ` `  `    ``// subarrays each of size q ;  ` `    ``int` `k = 0; ` ` `  `    ``// Loop to calculate total number  ` `    ``// of 1's in subarray which will  ` `    ``// get stored in array arr[]  ` `    ``while` `(k < p) ` `    ``{ ` `        ``int` `one = 0; ` `        ``for` `(``int` `j = start; j < ends; j++) ` `        ``{ ` `            ``if` `(a[j] == 1) ` `            ``{ ` `                ``one++; ` `            ``} ` `        ``} ` ` `  `        ``// starting index of next subarray  ` `        ``start = ends; ` ` `  `        ``// ending index of next subarray  ` `        ``ends = ends + q; ` ` `  `        ``// storing 1's  ` `        ``arr[k] = one; ` `        ``k++; ` `    ``} ` ` `  `    ``start = 0; ` `    ``ends = q; ` ` `  `    ``// variable to keep a check  ` `    ``// if 1 is in majority or not  ` `    ``bool` `found = ``false``; ` ` `  `    ``// In this case, we are repeating  ` `    ``// the task of calculating  ` `    ``// total number of 1's backward  ` `    ``while` `(ends > 0) ` `    ``{ ` ` `  `        ``// to store the total number of 1's  ` `        ``int` `dist_one = 0; ` ` `  `        ``// Check if 1 is in majority in  ` `        ``// this subarray  ` `        ``for` `(``int` `i = 0; i < p; i++) ` `        ``{ ` `            ``if` `(arr[i] > q / 2) ` `            ``{ ` `                ``dist_one++; ` `            ``} ` `        ``} ` ` `  `        ``// If 1 is in majority return  ` `        ``if` `(dist_one > p / 2) ` `        ``{ ` `            ``found = ``true``; ` `            ``Console.WriteLine(``"Yes"``); ` ` `  `            ``return``; ` `        ``} ` ` `  `        ``// shifting starting index of  ` `        ``// subarray by 1 unit leftwards  ` `        ``start--; ` ` `  `        ``// shifting ending index of  ` `        ``// subarray by 1 unit leftwards  ` `        ``ends--; ` ` `  `        ``// to ensure it is a valid index  ` `        ``// ( array is circular) -1 index means  ` `        ``// last index of a circular array  ` `        ``if` `(start < 0) ` `        ``{ ` `            ``start = size + start; ` `        ``} ` ` `  `        ``int` `st = start, en = ends, l = 0; ` ` `  `        ``// now to track changes occur  ` `        ``// due to shifting of the subarray  ` `        ``while` `(en < size) ` `        ``{ ` ` `  `            ``if` `(a[st % size] != a[en % size]) ` `            ``{ ` ` `  `                ``// st refers to starting index of  ` `                ``// new subarray and en refers to  ` `                ``// last element of of same subarray  ` `                ``// but in previous iteration  ` `                ``if` `(a[st % size] == 1) ` `                ``{ ` `                    ``arr[l]++; ` `                ``} ` ` `  `                ``else` `                ``{ ` `                    ``arr[l]--; ` `                ``} ` `            ``} ` `            ``l++; ` ` `  `            ``// now repeating the same  ` `            ``// for other subarrays too  ` `            ``st = (st + q); ` `            ``en = en + q; ` `        ``} ` `    ``} ` ` `  `    ``if` `(found == ``false``) ` `    ``{ ` `        ``Console.WriteLine(``"No"``); ` `    ``} ` `} ` ` `  `// Driver code  ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``int` `p = 3, q = 3; ` `    ``int` `n = p * q; ` ` `  `    ``int``[] a = ``new` `int``[] {0, 0, 1, 1,  ` `                         ``0, 1, 1, 0, 0}; ` ` `  `    ``// circular array of given size  ` `    ``majority(a, p, q, n); ` `} ` `} ` ` `  `// This code is contributed by Shrikant13 `

## PHP

 ` 0) {  ` ` `  `        ``// to store the total number of 1's  ` `        ``\$dist_one` `= 0;  ` ` `  `        ``// Check if 1 is in majority in  ` `        ``// this subarray  ` `        ``for` `(``\$i` `= 0; ``\$i` `< ``\$p``; ``\$i``++)  ` `            ``if` `(``\$arr``[``\$i``] > ``\$q` `/ 2)  ` `                ``\$dist_one``++;  ` ` `  `        ``// If 1 is in majority return  ` `        ``if` `(``\$dist_one` `> ``\$p` `/ 2) {  ` `            ``\$found` `= 1;  ` `            ``echo`  `"Yes"` `,``"\n"``;  ` ` `  `            ``return``;  ` `        ``}  ` ` `  `        ``// shifting starting index of  ` `        ``// subarray by 1 unit leftwards  ` `        ``\$start``--;  ` ` `  `        ``// shifting ending index of  ` `        ``// subarray by 1 unit leftwards  ` `        ``\$ends``--;  ` ` `  `        ``// to ensure it is a valid index  ` `        ``// ( array is circular) -1 index means  ` `        ``// last index of a circular array  ` `        ``if` `(``\$start` `< 0)  ` `            ``\$start` `= ``\$size` `+ ``\$start``;  ` ` `  `         ``\$st` `= ``\$start``; ``\$en` `= ``\$ends``; ``\$l` `= 0;  ` ` `  `        ``// now to track changes occur  ` `        ``// due to shifting of the subarray  ` `        ``while` `(``\$en` `< ``\$size``) {  ` ` `  `            ``if` `(``\$a``[``\$st` `% ``\$size``] != ``\$a``[``\$en` `% ``\$size``]) {  ` ` `  `                ``// st refers to starting index of  ` `                ``// new subarray and en refers to  ` `                ``// last element of of same subarray  ` `                ``// but in previous iteration  ` `                ``if` `(``\$a``[``\$st` `% ``\$size``] == 1)  ` `                    ``\$arr``[``\$l``]++;  ` ` `  `                ``else` `                    ``\$arr``[``\$l``]--;  ` `            ``}  ` `            ``\$l``++;  ` ` `  `            ``// now repeating the same  ` `            ``// for other subarrays too  ` `            ``\$st` `= (``\$st` `+ ``\$q``);  ` `            ``\$en` `= ``\$en` `+ ``\$q``;  ` `        ``}  ` `    ``}  ` ` `  `    ``if` `(``\$found` `== 0) {  ` `        ``echo`  `"No"` `,``"\n"``;  ` `    ``}  ` `}  ` ` `  `// Driver code  ` `    ``\$p` `= 3; ``\$q` `= 3;  ` `    ``\$n` `= ``\$p` `* ``\$q``;  ` ` `  `     ``\$a` `= ``array``( 0, 0, 1, 1, 0, 1, 1, 0, 0 );  ` ` `  `    ``// circular array of given size  ` `    ``majority(``\$a``, ``\$p``, ``\$q``, ``\$n``);  ` ` `  ` `  ` `  `#This Code is Contributed by ajit ` `?> `

Output:

```Yes
```

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.