 Open in App
Not now

# Find if 0 is removed more or 1 by deleting middle element if consecutive triplet is divisible by 3 in given Binary Array

• Last Updated : 21 Feb, 2022

Given a binary array a[] of size N of 1’s and 0’s. The task is to remove an element if a[i-1]+a[i]+a[i+1] is divisible by 3. Print 1 if more number of 1’s are removed than 0, otherwise print 0.

Examples:

Input: a[] = { 1, 1, 1, 0, 1, 0, 0}
Output: 1
Explanation: Remove the second 1 from the left since that is the only ‘1’ for which (a[i]+a[i-1]+a[i+1]) %3==0. So print 1.

Input: a[] = { 1, 1}
Output: 0
Explanation: No removal possible, so print 0.

Approach: The idea is based on the observation that if both neighbours are equal to current element because if (a[i]=a[i-1]=a[i+1]) then there sum will always divisible by 3. Let’s say A stores the number of 1’s removed and B stores the number of 0’s removed. If ith element is equal to the neighbours, then if a[i] =1, increment A, otherwise B. If the count of A is greater than B, print 1, otherwise print 2=0. Follow the steps below to solve the problem:

• Initialize the variables A and B as 0 to store the number of 1 and 0 removed.
• Iterate over the range [0, N) using the variable i and perform the following steps:
• If a[i-1], a[i] and a[i+1] are equal, then if a[i] equals 1, then increase the value of A by 1 else B by 1.
• If A is greater than B, then print 1 else print 0.

Below is the implementation of the above approach.

## C++

 `#include ``using` `namespace` `std;` `// Function to if more number of``// 1's are removed or 0's``void` `solution(vector<``int``> a)``{` `    ``// Stores count of 1's removes``    ``int` `A = 0;` `    ``// Stores count of 0's removes``    ``int` `B = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 1; i < a.size() - 1; i++) {` `        ``// Check the divisibility``        ``if` `(a[i] == a[i - 1] && a[i] == a[i + 1]) {` `            ``// Check for 1 or 0``            ``if` `(a[i] == 1)``                ``A++;``            ``else``                ``B++;``        ``}``    ``}` `    ``// Print the result``    ``if` `(A > B)``        ``cout << (``"1"``);``    ``else``        ``cout << (``"0"``);``}` `// Driver Code``int` `main()``{` `    ``vector<``int``> a = { 1, 1, 1, 0, 1, 0, 0 };``    ``solution(a);``    ``return` `0;``}` `// This code is contributed by lokeshpotta20.`

## Java

 `// Java program for above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to if more number of``    ``// 1's are removed or 0's``    ``public` `static` `void` `solution(``int``[] a)``    ``{` `        ``// Stores count of 1's removes``        ``int` `A = ``0``;` `        ``// Stores count of 0's removes``        ``int` `B = ``0``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``1``; i < a.length - ``1``; i++) {` `            ``// Check the divisibility``            ``if` `(a[i] == a[i - ``1``]``                ``&& a[i] == a[i + ``1``]) {` `                ``// Check for 1 or 0``                ``if` `(a[i] == ``1``)``                    ``A++;``                ``else``                    ``B++;``            ``}``        ``}` `        ``// Print the result``        ``if` `(A > B)``            ``System.out.println(``"1 "``);``        ``else``            ``System.out.println(``"0 "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a[] = { ``1``, ``1``, ``1``, ``0``, ``1``, ``0``, ``0` `};``        ``solution(a);``    ``}``}`

## Python3

 `# Python3 program for above approach`  `# Function to if more number of``# 1's are removed or 0's``def` `solution(a) :` `    ``# Stores count of 1's removes``    ``A ``=` `0``;` `    ``# Stores count of 0's removes``    ``B ``=` `0``;` `    ``# Traverse the array``    ``for` `i ``in` `range``(``1` `, ``len``(a)``-` `1``) :` `        ``# Check the divisibility``        ``if` `(a[i] ``=``=` `a[i ``-` `1``] ``and` `a[i] ``=``=` `a[i ``+` `1``]) :` `            ``# Check for 1 or 0``            ``if` `(a[i] ``=``=` `1``) :``                ``A ``+``=` `1``;``            ``else` `:``                ``B ``+``=` `1``;` `    ``# Print the result``    ``if` `(A > B) :``        ``print``(``"1"``);``    ``else` `:``        ``print``(``"0"``);` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:`  `    ``a ``=` `[ ``1``, ``1``, ``1``, ``0``, ``1``, ``0``, ``0` `];``    ``solution(a);` `    ``# This code is contributed by AnkThon`

## C#

 `// C# program for above approach``using` `System;``public` `class` `GFG {` `    ``// Function to if more number of``    ``// 1's are removed or 0's``    ``public` `static` `void` `solution(``int``[] a)``    ``{` `        ``// Stores count of 1's removes``        ``int` `A = 0;` `        ``// Stores count of 0's removes``        ``int` `B = 0;` `        ``// Traverse the array``        ``for` `(``int` `i = 1; i < a.Length - 1; i++) {` `            ``// Check the divisibility``            ``if` `(a[i] == a[i - 1]``                ``&& a[i] == a[i + 1]) {` `                ``// Check for 1 or 0``                ``if` `(a[i] == 1)``                    ``A++;``                ``else``                    ``B++;``            ``}``        ``}` `        ``// Print the result``        ``if` `(A > B)``            ``Console.WriteLine(``"1 "``);``        ``else``            ``Console.WriteLine(``"0 "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int` `[]a = { 1, 1, 1, 0, 1, 0, 0 };``        ``solution(a);``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`1 `

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

My Personal Notes arrow_drop_up