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

Last Updated : 23 Jul, 2022

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

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 switch 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 switch 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 switch 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 switch 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`

## Javascript

 ``

Output:

`-4 7 -3`

Time Complexity : O(n) ,as we are traversing once on the array.

Space Complexity : O(1) ,as we are not using any extra space.