Given an array arr[] of size N, the task is to find an array of size N, such that for every ith element of the array arr[], the output array should contain at least arr[i] elements that are not equal to the ith element of the output array. If there exists no such array, then print “Impossible“.
Examples:
Input: N = 5, arr[] = {4, 4, 4, 4, 4}
Output: 1 2 3 4 5Input: N = 10, arr[] = {7, 7, 7, 7, 7, 9, 8, 8, 7, 9}
Output: 4 4 4 5 5 1 3 3 5 2
Approach: The given problem can be solved based on the observation that there should be a maximum of N-arr[i] elements that are equal to the ith element of the output array. Follow the steps below to solve the problem:
- Initialize an array, say res[] of size N+5, to store the output array.
- Also, initialize an array of pairs, say V of size N+5, where V[i] stores the pair of the count of elements equal to res[i], and the index i.
- Iterate in the range [1, N] using the variable i, and in each iteration assign the value of the pair {N-arr[i], i} to V[i].
- Sort the array of pairs in ascending order.
- Initialize two variables, say l and r as 0 to traverse the array.
-
Iterate over the range [0, N-1] using the variable l and perform the following steps:
-
Iterate over the range [l, N-1] using the variable r and do the following:
- If V[r + 1].first is not equal to V[r]. first, then break the loop.
- If the count of the same elements i.e (r-l+1) is not divisible by V[l].first then print “Impossible” and return.
- Initialize a variable, say X, as 1 to assign the values to array res[].
-
Iterate over the range [l, r] using the variable i and perform the following steps:
- Iterate over the range [i, i+V[l].first] using the variable j and then in each iteration assign X to res[V[j].second].
- Increment i by V[l].first and X by 1.
- Update the value of l to r+1.
-
Iterate over the range [l, N-1] using the variable r and do the following:
- Finally, after completing the above steps, print the array, res[].
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the possible // output array void findPossibleArray( int N, int arr[])
{ pair< int , int > V[N + 5];
// Stores the output array
int res[N + 5];
int cnt = 0;
// Iterate over the range [1, N]
for ( int i = 0; i < N; i++) {
// Update V[i]
V[i].first = N - arr[i];
V[i].second = i;
}
// Sort the array
sort(V, V + N);
// Iterate in the range [1, N]
for ( int l = 0, r = 0; l < N; l = r + 1) {
// Iterate until r is less than N
for (r = l; r < N - 1; ++r) {
// If V[i+1].first is equal to
// V[r].first
if (V[r + 1].first != V[r].first) {
break ;
}
}
// If r-l+1 is divisible by V[i].first
if ((r - l + 1) % V[l].first) {
cout << "Impossible" << endl;
return ;
}
// Otherwise,
for ( int i = l; i <= r; i += V[l].first) {
cnt++;
// Traverse the array over the range
// [i, i+V[l].second]
for ( int j = i; j < i + V[l].first && j < N;
++j)
res[V[j].second] = cnt;
}
}
// Print the array res[]
for ( int i = 0; i < N; i++)
cout << res[i] << ' ' ;
} // Driver Code int main()
{ int arr[] = { 4, 4, 4, 4, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
findPossibleArray(N, arr);
return 0;
} |
// Java program for the above approach import java.util.Arrays;
class GFG {
// Function to find the possible
// output array
public static void findPossibleArray( int N, int arr[]) {
int [][] V = new int [N][ 2 ];
// Stores the output array
int [] res = new int [N + 5 ];
int cnt = 0 ;
// Iterate over the range [1, N]
for ( int i = 0 ; i < N; i++) {
// Update V[i]
V[i][ 0 ] = N - arr[i];
V[i][ 1 ] = i;
}
// Sort the array
Arrays.sort(V, (a, b) -> a[ 0 ] - b[ 0 ]);
// Iterate in the range [1, N]
for ( int l = 0 , r = 0 ; l < N; l = r + 1 ) {
// Iterate until r is less than N
for (r = l; r < N - 1 ; ++r) {
// If V[i+1][0] is equal to
// V[r][0]
if (V[r + 1 ][ 0 ] != V[r][ 0 ]) {
break ;
}
}
// If r-l+1 is divisible by V[i][0]
if (V[l][ 0 ] == 0 || ((r - l + 1 ) % V[l][ 0 ]) > 0 ) {
System.out.println( "Impossible" );
return ;
}
// Otherwise,
for ( int i = l; i <= r; i += V[l][ 0 ]) {
cnt++;
// Traverse the array over the range
// [i, i+V[l][1]]
for ( int j = i; j < i + V[l][ 0 ] && j < N; ++j)
res[V[j][ 1 ]] = cnt;
}
}
// Print the array res[]
for ( int i : res) {
if (i > 0 ) {
System.out.print(i + " " );
}
}
}
// Driver Code
public static void main(String args[]) {
int arr[] = { 4 , 4 , 4 , 4 , 4 };
int N = arr.length;
findPossibleArray(N, arr);
}
} //This code is contributed by saurabh_jaiswal. |
import bisect
def findPossibleArray(N, arr):
V = [[ 0 , 0 ] for i in range (N)]
# Stores the output array
res = [ 0 for i in range (N + 5 )]
cnt = 0
# Iterate over the range [1, N]
for i in range (N):
# Update V[i]
V[i][ 0 ] = N - arr[i]
V[i][ 1 ] = i
# Sort the array
V.sort(key = lambda x: x[ 0 ])
# Iterate in the range [1, N]
l = 0
while l < N:
# Find the range r that satisfies V[i+1][0] == V[r][0]
r = l
while r < N - 1 and V[r + 1 ][ 0 ] = = V[r][ 0 ]:
r + = 1
# If r-l+1 is not divisible by V[i][0]
if V[l][ 0 ] = = 0 or ((r - l + 1 ) % V[l][ 0 ]) > 0 :
print ( "Impossible" )
return
# Otherwise,
for i in range (l, r + 1 , V[l][ 0 ]):
cnt + = 1
# Traverse the array over the range
# [i, i+V[l][1]]
for j in range (i, min (i + V[l][ 0 ], N)):
res[V[j][ 1 ]] = cnt
l = r + 1
# Print the array res[]
for i in res:
if i > 0 :
print (i, end = ' ' )
print ()
# Driver Code arr = [ 4 , 4 , 4 , 4 , 4 ]
N = len (arr)
findPossibleArray(N, arr) |
using System;
using System.Collections;
using System.Collections.Generic;
// C# program for the above approach class GFG {
// Custom sort function
private static void Sort<T>(T[][] data, int col)
{
Comparer<T> comparer = Comparer<T>.Default;
Array.Sort<T[]>(data, (x,y) => comparer.Compare(x[col],y[col]));
}
// Function to find the possible
// output array
public static void findPossibleArray( int N, int [] arr)
{
int [][] V = new int [N][];
for ( int i = 0; i < N; i++){
V[i] = new int [2];
}
// Stores the output array
int [] res = new int [N];
int cnt = 0;
// Iterate over the range [1, N]
for ( int i = 0; i < N; i++) {
// Update V[i]
V[i][0] = N - arr[i];
V[i][1] = i;
// Console.WriteLine(V[i][0] + " " + V[i][1]);
}
// Sort the array
Sort< int >(V, 0);
for ( int i = 0; i < N; i++) {
// Update V[i]
V[i][0] = N - arr[i];
V[i][1] = i;
}
// Iterate in the range [1, N]
for ( int l = 0, r = 0; l < N; l = r + 1) {
// Iterate until r is less than N
for (r = l; r < N - 1; ++r) {
// If V[i+1].first is equal to
// V[r].first
if (V[r + 1][0] != V[r][0]) {
break ;
}
}
// If r-l+1 is divisible by V[i].first
if (((r - l + 1) % V[l][0]) != 0) {
Console.WriteLine( "Impossible" );
return ;
}
// Otherwise,
for ( int i = l; i <= r; i += V[l][0]) {
cnt++;
// Traverse the array over the range
// [i, i+V[l].second]
for ( int j = i; j < i + V[l][0] && j < N; ++j)
res[V[j][1]] = cnt;
}
}
// Print the array res[]
for ( int i = 0; i < N; i++)
Console.Write(res[i] + " " );
}
static void Main() {
int [] arr = { 4, 4, 4, 4, 4 };
int N = arr.Length;
findPossibleArray(N, arr);
}
} // The code is contributed by Nidhi goel. |
<script> // Javascript program for the above approach // Function to find the possible // output array function findPossibleArray(N, arr)
{ let V = new Array(N + 5).fill(0).map(() => new Array(2));
// Stores the output array
let res = new Array(N + 5);
let cnt = 0;
// Iterate over the range [1, N]
for (let i = 0; i < N; i++)
{
// Update V[i]
V[i][0] = N - arr[i];
V[i][1] = i;
}
// Sort the array
V.sort((a, b) => a[0] - b[0]);
// Iterate in the range [1, N]
for (let l = 0, r = 0; l < N; l = r + 1) {
// Iterate until r is less than N
for (r = l; r < N - 1; ++r) {
// If V[i+1][0] is equal to
// V[r][0]
if (V[r + 1][0] != V[r][0]) {
break ;
}
}
// If r-l+1 is divisible by V[i][0]
if ((r - l + 1) % V[l][0]) {
document.write( "Impossible" + "<br>" );
return ;
}
// Otherwise,
for (let i = l; i <= r; i += V[l][0]) {
cnt++;
// Traverse the array over the range
// [i, i+V[l][1]]
for (let j = i; j < i + V[l][0] && j < N; ++j)
res[V[j][1]] = cnt;
}
}
// Print the array res[]
for (let i = 0; i < N; i++)
document.write(res[i] + ' ' );
} // Driver Code let arr = [4, 4, 4, 4, 4]; let N = arr.length findPossibleArray(N, arr); // This code is contributed by _saurabh_jaiswal. </script> |
1 2 3 4 5
Time Complexity: O(N*log(N))
Auxiliary Space: O(N)