# Reduce every element of the array to it’s half retaining the sum zero

Given an array arr[] of N integers with total element sum equal to zero. The task is to reduce every element to it’s half such that the total sum remain zero. For every odd element X in the array, it could be reduced to either(X + 1) / 2 or (X – 1) / 2.

Examples:

Input: arr[] = {-7, 14, -7}
Output: -4 7 -3
-4 + 7 -3 = 0

Input: arr[] = {-14, 14}
Output: -7 7

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: All the even elements could be divided by 2 but for odd elements, they have to be alternatively reduced to (X + 1) / 2 and (X – 1) / 2 in order to retain the original sum (i.e. 0) in the final array.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach  ` `#include ` `using` `namespace` `std; ` ` `  `// Function to reduce every  ` `// element to it's half such that  ` `// the total sum remain zero ` `void` `half(``int` `arr[], ``int` `n) ` `{  ` `    ``int` `i; ` `     `  `    ``// Flag to swith between alternating  ` `    ``// odd numbers in the array  ` `    ``int` `flag = 0; ` `     `  `    ``// For every element of the array  ` `    ``for` `(i = 0; i < n; i++) ` `    ``{  ` `         `  `        ``// If its even then reduce it to half  ` `        ``if` `(arr[i] % 2 == 0 )  ` `            ``cout << arr[i] / 2 << ``" "``; ` `             `  `        ``// If its odd  ` `        ``else` `        ``{ ` `             `  `            ``// Reduce the odd elements  ` `            ``// alternatively  ` `            ``if` `(flag == 0) ` `            ``{ ` `                ``cout << arr[i] / 2 - 1 << ``" "``; ` `                 `  `                ``// Switch flag  ` `                ``flag = 1; ` `            ``} ` `            ``else` `            ``{ ` `                ``int` `q = arr[i] / 2; ` `                ``cout<

## Java

 `// Java implementation of the above approach  ` `class` `GFG  ` `{ ` ` `  `// Function to reduce every  ` `// element to it's half such that  ` `// the total sum remain zero  ` `static` `void` `half(``int` `arr[], ``int` `n) ` `{  ` `    ``int` `i; ` `     `  `    ``// Flag to swith between alternating  ` `    ``// odd numbers in the array  ` `    ``int` `flag = ``0``; ` `     `  `    ``// For every element of the array  ` `    ``for` `(i = ``0``; i < n; i++) ` `    ``{  ` `         `  `        ``// If its even then reduce it to half  ` `        ``if` `(arr[i] % ``2` `== ``0` `)  ` `            ``System.out.print(arr[i] / ``2` `+ ``" "``); ` `             `  `        ``// If its odd  ` `        ``else`  `        ``{ ` `             `  `            ``// Reduce the odd elements  ` `            ``// alternatively  ` `            ``if` `(flag == ``0``) ` `            ``{ ` `                ``System.out.print(arr[i] / ``2` `- ``1` `+ ``" "``); ` `                 `  `                ``// Switch flag  ` `                ``flag = ``1``; ` `            ``} ` `            ``else` `            ``{ ` `                ``int` `q = arr[i] / ``2``; ` `                ``System.out.print(q + ``" "``); ` `                 `  `                ``// Switch flag  ` `                ``flag = ``0``; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code  ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``int` `arr[] = {-``7``, ``14``, -``7``}; ` `    ``int` `len = arr.length; ` `    ``half(arr, len) ; ` `} ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to reduce every ` `# element to it's half such that  ` `# the total sum remain zero ` `def` `half(arr, n) : ` `     `  `    ``# Flag to swith between alternating  ` `    ``# odd numbers in the array ` `    ``flag ``=` `0` `     `  `    ``# For every element of the array ` `    ``for` `i ``in` `range``(n): ` `         `  `        ``# If its even then reduce it to half ` `        ``if` `arr[i] ``%` `2` `=``=` `0` `: ` `            ``print``(arr[i]``/``/``2``, end ``=``" "``) ` `             `  `        ``# If its odd ` `        ``else` `: ` `             `  `            ``# Reduce the odd elements  ` `            ``# alternatively ` `            ``if` `flag ``=``=` `0``: ` `                ``print``(arr[i]``/``/``2``, end ``=``" "``) ` `                 `  `                ``# Switch flag ` `                ``flag ``=` `1` `            ``else` `: ` `                ``q ``=` `arr[i]``/``/``2` `                ``q``+``=` `1` `                ``print``(q, end ``=``" "``) ` `                 `  `                ``# Switch flag ` `                ``flag ``=` `0` ` `  `# Driver code ` `arr ``=` `[``-``7``, ``14``, ``-``7``] ` `half(arr, ``len``(arr)) `

## C#

 `// C# implementation of the above approach  ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to reduce every  ` `// element to it's half such that  ` `// the total sum remain zero  ` `static` `void` `half(``int` `[]arr, ``int` `n) ` `{  ` `    ``int` `i; ` `     `  `    ``// Flag to swith between alternating  ` `    ``// odd numbers in the array  ` `    ``int` `flag = 0; ` `     `  `    ``// For every element of the array  ` `    ``for` `(i = 0; i < n; i++) ` `    ``{  ` `         `  `        ``// If its even then reduce it to half  ` `        ``if` `(arr[i] % 2 == 0 )  ` `            ``Console.Write(arr[i] / 2 + ``" "``); ` `             `  `        ``// If its odd  ` `        ``else` `        ``{ ` `             `  `            ``// Reduce the odd elements  ` `            ``// alternatively  ` `            ``if` `(flag == 0) ` `            ``{ ` `                ``Console.Write(arr[i] / 2 - 1 + ``" "``); ` `                 `  `                ``// Switch flag  ` `                ``flag = 1; ` `            ``} ` `            ``else` `            ``{ ` `                ``int` `q = arr[i] / 2; ` `                ``Console.Write(q + ``" "``); ` `                 `  `                ``// Switch flag  ` `                ``flag = 0; ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code  ` `public` `static` `void` `Main ()  ` `{ ` `    ``int` `[] arr = {-7, 14, -7}; ` `    ``int` `len = arr.Length; ` `    ``half(arr, len) ; ` `} ` `} ` ` `  `// This code is contributed by mohit kumar 29 `

Output:

```-4 7 -3
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.