Make all elements zero by decreasing any two elements by one at a time
Given an array arr[], the task is to check whether it is possible to make all the elements of the array zero by the given operation. In a single operation, any two elements arr[i] and arr[j] can be decremented by one at the same time.
Examples:
Input: arr[] = {1, 2, 1, 2, 2}
Output: Yes
Decrement the 1st and the 2nd element, arr[] = {0, 1, 1, 2, 2}
Decrement the 2nd and the 3rd element, arr[] = {0, 0, 0, 2, 2}
Decrement the 4th and the 5th element, arr[] = {0, 0, 0, 1, 1}
Decrement the 4th and the 5th element, arr[] = {0, 0, 0, 0, 0}Input: arr[] = {1, 2, 3, 4, 5}
Output: No
Approach: The given array can be only be made zero if it holds the following conditions true:
- The sum of the elements of the array must be even.
- The largest elements must be less than or equal to ⌊sum / 2⌋ where sum is the sum of the other elements.
Below is the implementation of the above approach:
CPP
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function that returns true if all // the array elements can be made // 0 with the given operation bool checkZeroArray(int* arr, int n) { // Find the maximum element // and the sum int sum = 0, maximum = INT_MIN; for (int i = 0; i < n; i++) { sum = sum + arr[i]; maximum = max(maximum, arr[i]); } // Check the required condition if (sum % 2 == 0 && maximum <= sum / 2) return true; return false; } // Driver code int main() { int arr[] = { 1, 2, 1, 2, 2 }; int n = sizeof(arr) / sizeof(int); if (checkZeroArray(arr, n)) cout << "Yes"; else cout << "No"; return 0; } |
chevron_right
filter_none
Java
// Java implementation of the above approach public class GFG { // Function that returns true if all // the array elements can be made // 0 with the given operation static boolean checkZeroArray(int []arr, int n) { // Find the maximum element // and the sum int sum = 0, maximum = Integer.MIN_VALUE; for (int i = 0; i < n; i++) { sum = sum + arr[i]; maximum = Math.max(maximum, arr[i]); } // Check the required condition if (sum % 2 == 0 && maximum <= sum / 2) return true; return false; } // Driver code public static void main (String[] args) { int arr[] = { 1, 2, 1, 2, 2 }; int n = arr.length; if (checkZeroArray(arr, n) == true) System.out.println("Yes"); else System.out.println("No"); } } // This code is contributed by AnkitRai01 |
chevron_right
filter_none
Python
# Python3 implementation of the approach # Function that returns true if all # the array elements can be made # 0 with the given operation def checkZeroArray(arr,n): # Find the maximum element # and the sum sum = 0 maximum = -10**9 for i in range(n): sum = sum + arr[i] maximum = max(maximum, arr[i]) # Check the required condition if (sum % 2 == 0 and maximum <= sum // 2): return True return False # Driver code arr = [1, 2, 1, 2, 2] n = len(arr) if (checkZeroArray(arr, n)): print("Yes") else: print("No") # This code is contributed by mohit kumar 29 |
chevron_right
filter_none
C#
// C# implementation of the above approach using System; class GFG { // Function that returns true if all // the array elements can be made // 0 with the given operation static bool checkZeroArray(int []arr, int n) { // Find the maximum element // and the sum int sum = 0, maximum = int.MinValue; for (int i = 0; i < n; i++) { sum = sum + arr[i]; maximum = Math.Max(maximum, arr[i]); } // Check the required condition if (sum % 2 == 0 && maximum <= sum / 2) return true; return false; } // Driver code public static void Main () { int []arr = { 1, 2, 1, 2, 2 }; int n = arr.Length; if (checkZeroArray(arr, n) == true) Console.WriteLine("Yes"); else Console.WriteLine("No"); } } // This code is contributed by AnkitRai01 |
chevron_right
filter_none
Output:
Yes
Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.
Recommended Posts:
- Minimum decrement operations to make Array elements equal by only decreasing K each time
- Make the list non-decreasing by changing only one digit of the elements
- Minimum value of X to make all array elements equal by either decreasing or increasing by X
- Count of Array elements to be divided by 2 to make at least K elements equal
- Value to be subtracted from array elements to make sum of all elements equals K
- Sum of array elements that is first continuously increasing then decreasing
- Sort even-placed elements in increasing and odd-placed in decreasing order
- Length of the longest subsequence such that xor of adjacent elements is non-decreasing
- Rearrange all elements of array which are multiples of x in decreasing order
- Split the array elements into strictly increasing and decreasing sequence
- Remove minimum elements from array such that no three consecutive element are either increasing or decreasing
- Find an element in an array such that elements form a strictly decreasing and increasing sequence
- Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
- Minimum elements to change so that for an index i all elements on the left are -ve and all elements on the right are +ve
- Make alphabets using the elements of an array
- Make all the elements of array even with given operations
- Make all elements of an array equal with the given operation
- Remove elements to make array sorted
- Minimum array element changes to make its elements 1 to N
- Make all array elements divisible by a number K
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.
- Count of substrings of length K with exactly K distinct characters
- Real-time application of Data Structures
- Replace every element of array with sum of elements on its right side
- Longest subarray whose elements can be made equal by maximum K increments
- Count of subarrays of size K with elements having even frequencies