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

Last Updated : 31 Aug, 2022

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.

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 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 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);` ` `  `    `  `}` `}`

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

## Javascript

 ``

Output

```Yes
```

Complexity Analysis:

• Time Complexity: O(p*q)
• Auxiliary Space: O(1)

Previous
Next