# 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.

My Personal Notes arrow_drop_up