Related Articles
Rearrange an Array such that Sum of same-indexed subsets differ from their Sum in the original Array
• Difficulty Level : Hard
• Last Updated : 28 Dec, 2020

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 = 1000  B = 100
A = 100   B = 10
A = 10    B = 1
A = 1     B = 1000```

Subsets of size 2:

```{A, A} = 1100  {B, B} = 110
{A, A} = 1010  {B, B} = 101
{A, A} = 110   {B, B} = 11
.....
Similarly, all same-indexed subsets of size 2 have a different sum.```

Subsets of size 3:

```{A, A, A} = 1110  {B, B, B} = 111
{A, A, A} = 1011 {B, B, B} = 1101
{A, A, A} = 111  {B, B, B} = 1011```

Therefore, 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 = { arr1, arr2, …, arrk } be a subset.
If u does not belong to S initially, upon insertion of u into S, the sum of the subset changes.
Similarly, if u belongs to S, let S’ contains all the elements not present in S. This means that u 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 ``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 > 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;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{``    ` `static` `class` `pair``{``    ``int` `first, second;``    ` `    ``pair(``int` `first, ``int` `second)``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}``}` `// Function to rearrange the array such``// that no same-indexed subset have sum``// equal to that in the original array``static` `void` `printNewArray(List a, ``int` `n)``{``    ` `    ``// Initialize a vector``    ``List v = ``new` `ArrayList<>();``    ` `    ``// Iterate the array``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``v.add(``new` `pair(a.get(i), i));``    ``}``    ` `    ``// Sort the vector``    ``Collections.sort(v, (pair s1, pair s2) ->``    ``{``        ``return` `s1.first - s2.first;``    ``});``    ` `    ``int` `ans[] = ``new` `int``[n];` `    ``// Shift of elements to the``    ``// index of its next cyclic element``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``ans[v.get((i + ``1``) % n).second] = v.get(i).first;``    ``}``    ` `    ``// Print the answer``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``System.out.print(ans[i] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``List a = Arrays.asList(``4``, ``1``, ``2``, ``5``, ``3``);` `    ``int` `n = a.size();``    ``printNewArray(a, n);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 Program to implement``# the above approach` `# Function to rearrange the array such``# that no same-indexed subset have sum``# equal to that in the original array``def` `printNewArray(a, n):` `    ``# Initialize a vector``    ``v ``=` `[]` `    ``# Iterate the array``    ``for` `i ``in` `range` `(n):``        ``v.append((a[i], i ))``    ` `    ``# Sort the vector``    ``v.sort()` `    ``ans ``=` `[``0``] ``*` `n` `    ``# Shift of elements to the``    ``# index of its next cyclic element``    ``for` `i ``in` `range` `(n):``        ``ans[v[(i ``+` `1``) ``%` `n][``1``]] ``=` `v[i][``0``]``   ` `    ``# Print the answer``    ``for` `i ``in` `range` `(n):``        ``print` `(ans[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``: ``    ``a ``=` `[``4``, ``1``, ``2``, ``5``, ``3``]``    ``n ``=` `len``(a)``    ``printNewArray(a, n)` `# This code is contributed by Chitranayal`

## C#

 `// C# Program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``    ` `    ``// Function to rearrange the array such``    ``// that no same-indexed subset have sum``    ``// equal to that in the original array``    ``static` `void` `printNewArray(List<``int``> a, ``int` `n)``    ``{``      ` `        ``// Initialize a vector``        ``List> v = ``new` `List>();``     ` `        ``// Iterate the array``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``     ` `            ``v.Add(``new` `Tuple<``int``, ``int``>(a[i],i));``        ``}``     ` `        ``// Sort the vector``        ``v.Sort();     ``        ``int``[] ans = ``new` `int``[n];``     ` `        ``// Shift of elements to the``        ``// index of its next cyclic element``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``ans[v[(i + 1) % n].Item2]``                ``= v[i].Item1;``        ``}``     ` `        ``// Print the answer``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``Console.Write(ans[i] + ``" "``);``        ``}``    ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``List<``int``> a = ``new` `List<``int``>(``new` `int``[]{4, 1, 2, 5, 3});``    ``int` `n = a.Count;``    ``printNewArray(a, n);``  ``}``}` `// This code is contributed by divyesh072019`
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.

My Personal Notes arrow_drop_up