Given an array **A[]** consisting of **N** distinct integers, the task is to rearrange the given array such that the sum of every same-indexed non-empty subsets of size less than **N**, is not equal to their sum in the original array.

**Examples:**

Input:A[] = {1000, 100, 10, 1}

Output:100 10 1 1000

Explanation:

Original Array A[] = {1000, 100, 10, 1}

Final Array B[] = {100, 10, 1, 1000}

Subsets of size 1:A[0] = 1000 B[0] = 100 A[1] = 100 B[1] = 10 A[2] = 10 B[2] = 1 A[3] = 1 B[3] = 1000Subsets of size 2:

{A[0], A[1]} = 1100 {B[0], B[1]} = 110 {A[0], A[2]} = 1010 {B[0], B[2]} = 101 {A[1], A[2]} = 110 {B[1], B[2]} = 11 ..... Similarly, all same-indexed subsets of size 2 have a different sum.Subsets of size 3:

{A[0], A[1], A[2]} = 1110 {B[0], B[1], B[2]} = 111 {A[0], A[2], A[3]} = 1011 {B[0], B[2], B[3]} = 1101 {A[1], A[2], A[3]} = 111 {B[1], B[2], B[3]} = 1011Therefore, no same-indexed subsets have equal sum.

Input:A[] = {1, 2, 3, 4, 5}

Output:5 1 2 3 4

**Approach:**

The idea is to simply replace every array element except one, by a smaller element. Follow the steps below to solve the problem:

- Store the array elements in pairs of
**{A[i], i}**. - Sort the pairs in ascending order of the array elements
- Now, traverse the sorted order, and insert each element at the original index of its next greater element(i.e. at the index
**v[(i + 1) % n].second**). This ensures that every index except one, now has a smaller element than the previous value stored in it.

Proof:

Let S = { arr_{1}, arr_{2}, …, arr_{k}} be a subset.

Ifu does not belong to Sinitially, upon insertion ofuinto S, the sum of the subset changes.

Similarly, ifu belongs to S,letS’contains all the elements not present inS. This means thatu do not belong to S’. Then, by the same reasoning above, the sum of the subset S’ differs from its original sum.

Below is the implementation of the above approach:

## C++

`// C++ Program to implement ` `// the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to rearrange the array such ` `// that no same-indexed subset have sum ` `// equal to that in the original array ` `void` `printNewArray(vector<` `int` `> a, ` `int` `n) ` `{ ` ` ` `// Initialize a vector ` ` ` `vector<pair<` `int` `, ` `int` `> > v; ` ` ` ` ` `// Iterate the array ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `v.push_back({ a[i], i }); ` ` ` `} ` ` ` ` ` `// Sort the vector ` ` ` `sort(v.begin(), v.end()); ` ` ` ` ` `int` `ans[n]; ` ` ` ` ` `// Shift of elements to the ` ` ` `// index of its next cyclic element ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `ans[v[(i + 1) % n].second] ` ` ` `= v[i].first; ` ` ` `} ` ` ` ` ` `// Print the answer ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `cout << ans[i] << ` `" "` `; ` ` ` `} ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `vector<` `int` `> a = { 4, 1, 2, 5, 3 }; ` ` ` ` ` `int` `n = a.size(); ` ` ` ` ` `printNewArray(a, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

3 5 1 4 2

**Time Complexity: **O(N log N)

**Auxiliary Space: **O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Find original array from encrypted array (An array of sums of other elements)
- Generate original array from an array that store the counts of greater elements on right
- Count number of permutation of an Array having no SubArray of size two or more from original Array
- Rearrange the array to maximize the number of primes in prefix sum of the array
- Searching in an array where adjacent differ by at most k
- Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
- Divide array in two Subsets such that sum of square of sum of both subsets is maximum
- Build original array from the given sub-sequences
- Rearrange an array such that arr[i] = i
- Rearrange array such that arr[i] >= arr[j] if i is even and arr[i]<=arr[j] if i is odd and j < i
- Rearrange an array such that 'arr[j]' becomes 'i' if 'arr[i]' is 'j' | Set 1
- Find the deleted value from the array when average of original elements is given
- Find the original Array using XOR values of all adjacent elements
- Find k maximum elements of array in original order
- Check if original Array is retained after performing XOR with M exactly K times
- Print n smallest elements from given array in their original order
- Generate original array from difference between every two consecutive elements
- Rearrange an array to maximize i*arr[i]
- Minimum time to return array to its original state after given modifications
- Count subarrays having total distinct elements same as original array

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.