Making zero array by decrementing pairs of adjacent

Given a sequence of non-negative integers, say a1, a2, …, an. Only following actions can be performed on the given sequence:

  • Subtract 1 from a[i] and a[i+1] both.

Find if the series can be modified into all zeros using any required number of above operations.

Examples :

Input  : 1 2
Output : NO
Explanation: Only two elements, if we substract
1 then it will convert into [0, 1].
so answer is NO. Input : 0 1 1 0 Output : YES Explanation: Here we can choose both 1 and substract 1 from them then array becomes [0, 0, 0, 0].
So answer is YES. Input : 1 2 3 4 Output : NO Explanation: if we try to subtract 1 any number of times then array will be [0, 0, 0, 1]. [1, 2, 3, 4]->[0, 1, 3, 4]->[0, 0, 2, 3]-> [0, 0, 1, 2]->[0, 0, 0, 1].

Approach 1 : If all adjacent elements(i, i+1) in array are equal and total number of element in array is even then it’s all element can be converted to zero. For example, if array elements are like {1, 1, 2, 2, 3, 3} then its all element is convertible into zero.

Then in this case sum of every odd positioned value are always equal to the sum of even positioned value.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find if it is possible
// to make all array elements 0 by decrement
// operations.
#include <bits/stdc++.h>
using namespace std;
  
bool isPossibleToZero(int a[], int n)
{
    // used for storing the sum of even 
    // and odd position element in array.
    int even = 0, odd = 0; 
      
    for (int i = 0; i < n; i++) 
    {
        // if position is odd, store sum 
        // value of odd position in odd
        if (i & 1) 
            odd += a[i];
          
        // if position is even, store sum 
        // value of even position in even
        else 
            even += a[i];
    }
      
    return (odd == even);
}
  
// Driver program
int main()
{
    int arr[] = { 0, 1, 1, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    if (isPossibleToZero(arr, n))
        cout << "YES";
    else
        cout << "NO";
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find if
// it is possible to make 
// all array elements 0 by
// decrement operations.
import java.io.*;
  
class GFG 
{
    static boolean isPossibleToZero(int a[],    
                                    int n)
{
    // used for storing the 
    // sum of even and odd 
    // position element in array.
    int even = 0, odd = 0
      
    for (int i = 0; i < n; i++) 
    {
        // if position is odd, 
        // store sum value of 
        // odd position in odd
        if ((i & 1) == 0
            odd += a[i];
          
        // if position is even, 
        // store sum value of 
        // even position in even
        else
            even += a[i];
    }
      
    return (odd == even);
}
  
// Driver Code
public static void main(String[] args) 
{
    int arr[] = { 0, 1, 1, 0 };
    int n = arr.length;
    if (isPossibleToZero(arr, n))
        System.out.println("YES");
    else
        System.out.println("NO");
}
}
  
// This code is contributed by m_kit

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to find if it is 
# possible to make all array elements
# 0 by decrement operations.
def isPossibleToZero(a, n):
  
    # used for storing the 
    # sum of even and odd 
    # position element in array.
    even = 0
    odd = 0
      
    for i in range(n): 
          
        # if position is odd, store sum 
        # value of odd position in odd
        if (i & 1): 
            odd += a[i];
          
        # if position is even, store sum 
        # value of even position in even
        else:
            even += a[i];
      
    return (odd == even);
  
# Driver Code
arr = [0, 1, 1, 0];
n = len(arr);
if (isPossibleToZero(arr, n)):
    print("YES");
else:
    print("NO");
  
# This code is contributed by mits

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find if
// it is possible to make 
// all array elements 0 by
// decrement operations.
using System;
  
class GFG
{
static bool isPossibleToZero(int []a, 
                             int n)
{
    // used for storing the 
    // sum of even and odd 
    // position element in array.
    int even = 0, odd = 0; 
      
    for (int i = 0; i < n; i++) 
    {
        // if position is odd, 
        // store sum value of 
        // odd position in odd
        if ((i & 1) == 0) 
            odd += a[i];
          
        // if position is even, 
        // store sum value of 
        // even position in even
        else
            even += a[i];
    }
      
    return (odd == even);
}
  
// Driver Code
static public void Main ()
{
    int []arr = {0, 1, 1, 0};
    int n = arr.Length;
    if (isPossibleToZero(arr, n))
        Console.WriteLine("YES");
    else
        Console.WriteLine("NO");
}
}
  
// This code is contributed
// by m_kit

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find if it 
// is possible to make all
// array elements 0 by 
// decrement operations.
function isPossibleToZero($a, $n)
{
    // used for storing the 
    // sum of even and odd 
    // position element in array.
    $even = 0; $odd = 0; 
      
    for ($i = 0; $i < $n; $i++) 
    {
        // if position is odd, 
        // store sum value of 
        // odd position in odd
        if ($i & 1) 
            $odd += $a[$i];
          
        // if position is even, 
        // store sum value of 
        // even position in even
        else
            $even += $a[$i];
    }
      
    return ($odd == $even);
}
  
// Driver Code
$arr = array (0, 1, 1, 0);
$n = sizeof($arr);
if (isPossibleToZero($arr, $n))
    echo "YES";
else
    echo "NO";
  
// This code is contributed by ajit
?>

chevron_right


Output:

YES

Approach 2: If Number formed by given array element is divisible by 11 then all elements of array also can be convertible to zero.

For ex: given array {0, 1, 1, 0}, number formed by this array is 110 then it is divisible by 11. So all elements can be converted into zero.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP implementation of the 
// above approach
#include <bits/stdc++.h>
using namespace std;
  
bool isPossibleToZero(int a[], int n)
{  
    // converting array element into number
    int num = 0;
    for (int i = 0; i < n; i++)
        num = num * 10 + a[i]; 
  
    // Check if divisible by 11
    return (num % 11 == 0);
}
  
// Driver program
int main()
{
    int arr[] = { 0, 1, 1, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    if (isPossibleToZero(arr, n))
        cout << "YES";
    else
        cout << "NO";
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach
import java.io.*;
  
class GFG {
      
    static boolean isPossibleToZero(int a[], int n)
    
        // converting array element into number
        int num = 0;
        for (int i = 0; i < n; i++)
            num = num * 10 + a[i]; 
      
        // Check if divisible by 11
        return (num % 11 == 0);
    }
      
    // Driver program
    public static void main (String[] args)
    {
  
        int arr[] = {0, 1, 1, 0};
        int n = arr.length;
        if (isPossibleToZero(arr, n))
                System.out.println( "YES");
        else
                System.out.println ("NO");
    }
}
  
// This code is contributed by @ajit

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the 
# above approach
  
def isPossibleToZero(a, n):
      
    # converting array element 
    # into number
    num = 0;
    for i in range(n):
        num = num * 10 + a[i]; 
  
    # Check if divisible by 11
    return (num % 11 == 0);
  
# Driver Code
arr = [ 0, 1, 1, 0 ];
n = len(arr);
if (isPossibleToZero(arr, n)):
    print("YES");
else:
    print("NO");
  
# This code is contributed mits

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach
using System;
  
class GFG 
{
      
static bool isPossibleToZero(int[] a, int n)
    // converting array element into number
    int num = 0;
    for (int i = 0; i < n; i++)
        num = num * 10 + a[i]; 
  
    // Check if divisible by 11
    return (num % 11 == 0);
}
  
// Driver Code
public static void Main()
{
    int[] arr = {0, 1, 1, 0};
    int n = arr.Length;
    if (isPossibleToZero(arr, n))
        Console.WriteLine("YES");
    else
        Console.WriteLine("NO");
}
}
  
// This code is contributed 
// by Akanksha Rai

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of 
// the above approach
  
function isPossibleToZero($a, $n)
    // converting array 
    // element into number
    $num = 0;
    for ($i = 0; $i < $n; $i++)
        $num = $num * 10 + $a[$i]; 
  
    // Check if divisible by 11
    return ($num % 11 == 0);
}
  
// Driver Code
$arr = array( 0, 1, 1, 0 );
$n = sizeof($arr);
if (isPossibleToZero($arr, $n))
    echo "YES";
else
    echo "NO";
  
// This code is contributed ajit
?>

chevron_right


Output:

YES

The above implementation causes overflow for slightly bigger arrays. We can use below method to avoid overflow.Check if a large number is divisible by 11 or not



My Personal Notes arrow_drop_up

Working in Coviam As Backend Developer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





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.