# Find the non decreasing order array from given array

• Last Updated : 23 Jun, 2022

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

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

 ``

## Javascript

 ``

Output:

`0 1 5 5`

Time Complexity: O(n)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up