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] = 1000
Subsets 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 = { 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++
#include <bits/stdc++.h>
using namespace std;
void printNewArray(vector<int> a, int n)
{
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
v.push_back({ a[i], i });
}
sort(v.begin(), v.end());
int ans[n];
for (int i = 0; i < n; i++) {
ans[v[(i + 1) % n].second]
= v[i].first;
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
int main()
{
vector<int> a = { 4, 1, 2, 5, 3 };
int n = a.size();
printNewArray(a, n);
return 0;
}
|
Java
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;
}
}
static void printNewArray(List<Integer> a, int n)
{
List<pair> v = new ArrayList<>();
for(int i = 0; i < n; i++)
{
v.add(new pair(a.get(i), i));
}
Collections.sort(v, (pair s1, pair s2) ->
{
return s1.first - s2.first;
});
int ans[] = new int[n];
for(int i = 0; i < n; i++)
{
ans[v.get((i + 1) % n).second] = v.get(i).first;
}
for(int i = 0; i < n; i++)
{
System.out.print(ans[i] + " ");
}
}
public static void main(String args[])
{
List<Integer> a = Arrays.asList(4, 1, 2, 5, 3);
int n = a.size();
printNewArray(a, n);
}
}
|
Python3
def printNewArray(a, n):
v = []
for i in range (n):
v.append((a[i], i ))
v.sort()
ans = [0] * n
for i in range (n):
ans[v[(i + 1) % n][1]] = v[i][0]
for i in range (n):
print (ans[i], end = " ")
if __name__ == "__main__":
a = [4, 1, 2, 5, 3]
n = len(a)
printNewArray(a, n)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static void printNewArray(List<int> a, int n)
{
List<Tuple<int, int>> v = new List<Tuple<int, int>>();
for (int i = 0; i < n; i++)
{
v.Add(new Tuple<int, int>(a[i],i));
}
v.Sort();
int[] ans = new int[n];
for (int i = 0; i < n; i++)
{
ans[v[(i + 1) % n].Item2]
= v[i].Item1;
}
for (int i = 0; i < n; i++)
{
Console.Write(ans[i] + " ");
}
}
static void Main()
{
List<int> a = new List<int>(new int[]{4, 1, 2, 5, 3});
int n = a.Count;
printNewArray(a, n);
}
}
|
Javascript
<script>
function printNewArray(a, n)
{
var v = [];
for (var i = 0; i < n; i++) {
v.push([ a[i], i]);
}
v.sort();
var ans = Array(n);
for (var i = 0; i < n; i++) {
ans[v[(i + 1) % n][1]]
= v[i][0];
}
for (var i = 0; i < n; i++) {
document.write( ans[i] + " ");
}
}
var a = [4, 1, 2, 5, 3];
var n = a.length;
printNewArray(a, n);
</script>
|
Time Complexity: O(N log N)
Auxiliary Space: O(N)