Skip to content
Related Articles

Related Articles

Improve Article

Making zero array by decrementing pairs of adjacent

  • Difficulty Level : Easy
  • Last Updated : 06 May, 2021

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 subtract
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 
subtract 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++




// 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";
}

Java




// 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

Python3




# 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

C#




// 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

PHP




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

Javascript




<script>
 
// Javascript 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.
    let even = 0, odd = 0;
 
    for(let 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
let arr = [ 0, 1, 1, 0 ];
let n = arr.length;
 
if (isPossibleToZero(arr, n))
    document.write("YES");
else
    document.write("NO");
     
// This code is contributed by mukesh07
 
</script>
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++




// 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";
}

Java




// 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

Python3




# 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

C#




// 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

PHP




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

Javascript




<script>
 
// Javascript implementation of the above approach
function isPossibleToZero(a, n)
{
     
    // Converting array element into number
    let num = 0;
    for(let i = 0; i < n; i++)
        num = num * 10 + a[i];
 
    // Check if divisible by 11
    return (num % 11 == 0);
}
 
// Driver code
let arr = [ 0, 1, 1, 0 ];
let n = arr.length;
 
if (isPossibleToZero(arr, n))
    document.write("YES");
else
    document.write("NO");
     
// This code is contributed by divyeshrabadiya07
 
</script>
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
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :