Related Articles
Find the non decreasing order array from given array
• Last Updated : 14 Jan, 2019

Given an array A[] of size N / 2, the task is to construct the array B[] of size N such that:

1. B[] is sorted in non-decreasing order.
2. A[i] = B[i] + B[n – i + 1].

Note: Array A[] is given in such a way that the answer is always possible.

Examples:

Input: A[] = {3, 4}
Output: 0 1 3 3

Input: A[] = {4, 1}
Output: 0 0 1 4

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

Approach: Let’s present the following greedy approach. The numbers will be restored in pairs (B, B[n – 1]), (B, B[n – 2]) and so on. Thus, we can have some limits on the values of the current pair (satisfying the criteria about sorted result).
Initially, l = 0 and r = 109, they are updated with l = a[i] and r = a[n – i + 1]. Let l be minimal possible in the answer. Take a[i] = max(l, b[i] – r) and r = b[i] – l, that way l was chosen in such a way that both l and r are within the restrictions and l is also minimal possible.
If l was any greater than we would move both l limit up and r limit down leaving less freedom for later choices.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Utility function to print ``// the contents of the array``void` `printArr(``int` `b[], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << b[i] << ``" "``;``}`` ` `// Function to build array B[]``void` `ModifiedArray(``int` `a[], ``int` `n)``{``    ``// Lower and upper limits``    ``int` `l = 0, r = INT_MAX;`` ` `    ``// To store the required array``    ``int` `b[n] = { 0 };`` ` `    ``// Apply greedy approach``    ``for` `(``int` `i = 0; i < n / 2; i++) {``        ``b[i] = max(l, a[i] - r);``        ``b[n - i - 1] = a[i] - b[i];``        ``l = b[i];``        ``r = b[n - i - 1];``    ``}`` ` `    ``// Print the built array b[]``    ``printArr(b, n);``}`` ` `// Driver code``int` `main()``{``    ``int` `a[] = { 5, 6 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``ModifiedArray(a, 2 * n);`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``  ` `class` `solution``{``    ``// Utility function to print ``    ``// the contents of the array``    ``void` `printArr(``int` `b[], ``int` `n)``    ``{``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{``             ``System.out.print(``" "` `+ b[i] + ``" "``);``         ``}``    ``}`` ` `    ``// Function to build array B[]``    ``void` `ModifiedArray(``int` `a[], ``int` `n)``    ``{``        ``// Lower and upper limits``        ``int` `l = ``0``, r = Integer.MAX_VALUE;`` ` `        ``// To store the required array``        ``int``[] b = ``new` `int``[n];``         ` `    ``// Apply greedy approach``    ``for` `(``int` `i = ``0``; i < n / ``2``; i++) {``        ``b[i] = Math.max(l, a[i] - r);``        ``b[n - i - ``1``] = a[i] - b[i];``        ``l = b[i];``        ``r = b[n - i - ``1``];``    ``}`` ` `    ``// Print the built array b[]``    ``printArr(b, n);``}    ``// Driver code``public` `static` `void` `main(String args[])``{``   ``int` `a[] = { ``5``, ``6` `};``   ``int` `n = a.length ;``   ``solution s=``new` `solution();``   ``s.ModifiedArray(a, ``2` `* n);`` ` `}``}``//This code is contributed by Shivi_Aggarwal`

## Python3

 `# Python 3 implementation of the approach``import` `sys`` ` `# Utility function to print the ``# contents of the array``def` `printArr(b, n):``    ``for` `i ``in` `range``(``0``, n, ``1``):``        ``print``(b[i], end ``=` `" "``)`` ` `# Function to build array B[]``def` `ModifiedArray(a, n):``     ` `    ``# Lower and upper limits``    ``l ``=` `0``    ``r ``=` `sys.maxsize`` ` `    ``# To store the required array``    ``b ``=` `[``0` `for` `i ``in` `range``(n)] `` ` `    ``# Apply greedy approach``    ``for` `i ``in` `range``(``0``, ``int``(n ``/` `2``), ``1``):``        ``b[i] ``=` `max``(l, a[i] ``-` `r)``        ``b[n ``-` `i ``-` `1``] ``=` `a[i] ``-` `b[i]``        ``l ``=` `b[i]``        ``r ``=` `b[n ``-` `i ``-` `1``]`` ` `    ``# Print the built array b[]``    ``printArr(b, n)`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``a ``=` `[``5``, ``6``]``    ``n ``=` `len``(a)``    ``ModifiedArray(a, ``2` `*` `n)`` ` `# This code is contributed by``# Shashank_Sharma`

## C#

 `// C# implementation of the approach`` ` `using` `System;`` ` `public` `class` `GFG{`` ` `// Utility function to print ``// the contents of the array``static` `void` `printArr(``int` `[]b, ``int` `n)``    ``{``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``Console.Write(``" "` `+ b[i] + ``" "``);``        ``}``    ``}`` ` `    ``// Function to build array B[]``static`    `void` `ModifiedArray(``int` `[]a, ``int` `n)``    ``{``        ``// Lower and upper limits``        ``int` `l = 0, r = ``int``.MaxValue;`` ` `        ``// To store the required array``        ``int``[] b = ``new` `int``[n];``         ` `    ``// Apply greedy approach``    ``for` `(``int` `i = 0; i < n / 2; i++) {``        ``b[i] = Math.Max(l, a[i] - r);``        ``b[n - i - 1] = a[i] - b[i];``        ``l = b[i];``        ``r = b[n - i - 1];``    ``}`` ` `    ``// Print the built array b[]``    ``printArr(b, n);``} `` ` `        ``// Driver code``    ``static` `public` `void` `Main (){``    ``int` `[]a = { 5, 6 };``    ``int` `n = a.Length;``    ``ModifiedArray(a, 2 * n);``    ``}``}``// This code is contributed``// by Sach_Code`

## PHP

 ``
Output:
```0 1 5 5
``` My Personal Notes arrow_drop_up