Convert an Array to reduced form using Vector of pairs
Given an array with n distinct elements, convert the given array to a form where all elements are in range from 0 to n-1. The order of elements is same, i.e., 0 is placed in place of smallest element, 1 is placed for second smallest element, … n-1 is placed for largest element.
Input: arr[] = {10, 40, 20}
Output: arr[] = {0, 2, 1}
Input: arr[] = {5, 10, 40, 30, 20}
Output: arr[] = {0, 1, 4, 3, 2}
We have discussed simple and hashing based solutions. In this post, a new solution is discussed. The idea is to create a vector of pairs. Every element of pair contains element and index. We sort vector by array values. After sorting, we copy indexes to original array.
C++
#include <bits/stdc++.h>
using namespace std;
void convert( int arr[], int n)
{
vector<pair< int , int > > v;
for ( int i = 0; i < n; i++)
v.push_back(make_pair(arr[i], i));
sort(v.begin(), v.end());
for ( int i = 0; i < n; i++)
arr[v[i].second] = i;
}
void printArr( int arr[], int n)
{
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 10, 20, 15, 12, 11, 50 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Given Array is \n" ;
printArr(arr, n);
convert(arr, n);
cout << "\n\nConverted Array is \n" ;
printArr(arr, n);
return 0;
}
|
Java
import java.util.*;
public class Main {
static void convert( int arr[], int n)
{
List<Pair> v = new ArrayList<>();
for ( int i = 0 ; i < n; i++)
v.add( new Pair(arr[i], i));
Collections.sort(v, new SortByVal());
for ( int i = 0 ; i < n; i++)
arr[v.get(i).getIndex()] = i;
}
static void printArr( int arr[], int n)
{
for ( int i = 0 ; i < n; i++)
System.out.print(arr[i] + " " );
}
public static void main (String[] args)
{
int arr[] = { 10 , 20 , 15 , 12 , 11 , 50 };
int n = arr.length;
System.out.println( "Given Array is \n" );
printArr(arr, n);
convert(arr, n);
System.out.println( "\n\nConverted Array is \n" );
printArr(arr, n);
}
static class Pair {
int val;
int index;
public Pair( int val, int index)
{
this .val = val;
this .index = index;
}
public int getVal()
{
return val;
}
public int getIndex()
{
return index;
}
}
static class SortByVal implements Comparator<Pair> {
public int compare(Pair a, Pair b)
{
return a.getVal() - b.getVal();
}
}
}
|
Python3
def convert(arr, n):
v = []
for i in range (n):
v.append((arr[i], i))
v.sort()
for i in range (n):
arr[v[i][ 1 ]] = i
def printArr(arr, n):
for i in range (n):
print (arr[i], end = " " )
arr = [ 10 , 20 , 15 , 12 , 11 , 50 ]
n = len (arr)
print ( "Given Array is " )
printArr(arr, n)
convert(arr, n)
print ( "\n\nConverted Array is " )
printArr(arr, n)
|
C#
using System;
using System.Collections.Generic;
public class Program {
static void Convert( int [] arr, int n)
{
List<Pair> v = new List<Pair>();
for ( int i = 0; i < n; i++)
v.Add( new Pair(arr[i], i));
v.Sort( new SortByVal());
for ( int i = 0; i < n; i++)
arr[v[i].GetIndex()] = i;
}
static void PrintArr( int [] arr, int n)
{
for ( int i = 0; i < n; i++)
Console.Write(arr[i] + " " );
}
public static void Main()
{
int [] arr = { 10, 20, 15, 12, 11, 50 };
int n = arr.Length;
Console.WriteLine( "Given Array is " );
PrintArr(arr, n);
Convert(arr, n);
Console.WriteLine( "\n\nConverted Array is" );
PrintArr(arr, n);
}
class Pair {
int val;
int index;
public Pair( int val, int index)
{
this .val = val;
this .index = index;
}
public int GetVal() { return val; }
public int GetIndex() { return index; }
}
class SortByVal : IComparer<Pair> {
public int Compare(Pair a, Pair b)
{
return a.GetVal() - b.GetVal();
}
}
}
|
Javascript
function convert(arr, n) {
let v = [];
for (let i = 0; i < n; i++)
v.push([arr[i], i]);
v.sort((a, b) => a[0] - b[0]);
for (let i = 0; i < n; i++)
arr[v[i][1]] = i;
}
function printArr(arr, n) {
for (let i = 0; i < n; i++)
console.log(arr[i] + " " );
}
let arr = [10, 20, 15, 12, 11, 50];
let n = arr.length;
console.log( "Given Array is " );
printArr(arr, n);
convert(arr, n);
console.log( "\n\nConverted Array is " );
printArr(arr, n);
|
Output
Given Array is
10 20 15 12 11 50
Converted Array is
0 4 3 2 1 5
Time Complexity : O(n Log n)
Auxiliary Space : O(n)
Another Approach:
1) Create a copy of the input array and sort it in non-decreasing order.
2) Create a map where each element of the sorted array is mapped to its corresponding index in the range 0 to n-1.
3) Traverse the input array and for each element, replace it with the value obtained from the map.
C++
#include <bits/stdc++.h>
using namespace std;
void convert( int arr[], int n)
{
int sorted_arr[n];
copy(arr, arr+n, sorted_arr);
sort(sorted_arr, sorted_arr+n);
unordered_map< int , int > mp;
for ( int i = 0; i < n; i++) {
mp[sorted_arr[i]] = i;
}
for ( int i = 0; i < n; i++) {
arr[i] = mp[arr[i]];
}
}
void printArr( int arr[], int n)
{
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
}
int main()
{
int arr[] = { 10, 20, 15, 12, 11, 50 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << "Given Array is \n" ;
printArr(arr, n);
convert(arr, n);
cout << "\n\nConverted Array is \n" ;
printArr(arr, n);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static void convert( int arr[], int n)
{
int [] sorted_arr = Arrays.copyOf(arr, n);
Arrays.sort(sorted_arr);
HashMap<Integer, Integer> mp
= new HashMap<Integer, Integer>();
for ( int i = 0 ; i < n; i++) {
mp.put(sorted_arr[i], i);
}
for ( int i = 0 ; i < n; i++) {
arr[i] = mp.get(arr[i]);
}
}
public static void printArr( int arr[], int n)
{
for ( int i = 0 ; i < n; i++) {
System.out.print(arr[i] + " " );
}
}
public static void main(String[] args)
{
int arr[] = { 10 , 20 , 15 , 12 , 11 , 50 };
int n = arr.length;
System.out.println( "Given Array is " );
printArr(arr, n);
convert(arr, n);
System.out.println( "\n\nConverted Array is " );
printArr(arr, n);
}
}
|
Python3
def convert(arr, n):
sorted_arr = arr.copy()
sorted_arr.sort()
mp = {}
for i in range (n):
mp[sorted_arr[i]] = i
for i in range (n):
arr[i] = mp[arr[i]]
def print_arr(arr, n):
for i in range (n):
print (arr[i], end = ' ' )
print ()
if __name__ = = '__main__' :
arr = [ 10 , 20 , 15 , 12 , 11 , 50 ]
n = len (arr)
print ( "Given Array is " )
print_arr(arr, n)
convert(arr, n)
print ( "\nConverted Array is " )
print_arr(arr, n)
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static void Convert( int [] arr, int n)
{
int [] sortedArr = new int [n];
Array.Copy(arr, sortedArr, n);
Array.Sort(sortedArr);
Dictionary< int , int > mp
= new Dictionary< int , int >();
for ( int i = 0; i < n; i++) {
mp.Add(sortedArr[i], i);
}
for ( int i = 0; i < n; i++) {
arr[i] = mp[arr[i]];
}
}
static void PrintArr( int [] arr, int n)
{
for ( int i = 0; i < n; i++) {
Console.Write(arr[i] + " " );
}
}
static public void Main()
{
int [] arr = { 10, 20, 15, 12, 11, 50 };
int n = arr.Length;
Console.WriteLine( "Given Array is " );
PrintArr(arr, n);
Convert(arr, n);
Console.WriteLine( "\n\nConverted Array is " );
PrintArr(arr, n);
}
}
|
Javascript
function convert(arr, n) {
let sorted_arr = [...arr];
sorted_arr.sort((a, b) => a - b);
let mp = {};
for (let i = 0; i < n; i++) {
mp[sorted_arr[i]] = i;
}
for (let i = 0; i < n; i++) {
arr[i] = mp[arr[i]];
}
}
function print_arr(arr, n) {
for (let i = 0; i < n; i++) {
process.stdout.write(`${arr[i]} `);
}
console.log();
}
let arr = [10, 20, 15, 12, 11, 50];
let n = arr.length;
process.stdout.write( "Given Array is \n" );
print_arr(arr, n);
convert(arr, n);
process.stdout.write( "\nConverted Array is \n" );
print_arr(arr, n);
|
Output
Given Array is
10 20 15 12 11 50
Converted Array is
0 4 3 2 1 5
Time Complexity: O(n log n) where n is the size of the input array. This is because the function creates a copy of the input array using the “copy” function, which takes O(n) time, sorts the copy using the “sort” function, which has a time complexity of O(n log n)
Space Complexity: O(n) we are using extra space as a map.
Last Updated :
17 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...