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;

// Converts arr[0..n-1] to reduced form.
void convert(int arr[], int n)
{
    // A vector of pairs. Every element of
    // pair contains array element and its
    // index
    vector<pair<int, int> > v;

    // Put all elements and their index in
    // the vector
    for (int i = 0; i < n; i++)
        v.push_back(make_pair(arr[i], i));

    // Sort the vector by array values
    sort(v.begin(), v.end());

    // Put indexes of modified vector in arr[]
    for (int i = 0; i < n; i++)
        arr[v[i].second] = i;
}

// Utility function to print an array.
void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}

// Driver program to test above method
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;
}

Python3

# Converts arr[0..n-1] to reduced form.
def convert(arr, n):

    # A list of tuples. Every element of
    # tuple contains array element and its
    # index
    v = []

    # Put all elements and their index in
    # the list
    for i in range(n):
        v.append((arr[i], i))

    # Sort the list by array values
    v.sort()

    # Put indexes of modified list in arr[]
    for i in range(n):
        arr[v[i][1]] = i

# Utility function to print an array.
def printArr(arr, n):
    for i in range(n):
        print(arr[i], end=" ")

# Driver program to test above method
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)

# This code is contributed by Prasad Kandekar(prasad264)

Javascript

// Converts arr[0..n-1] to reduced form.
function convert(arr, n) {

    // An array of pairs. Every element of
    // pair contains array element and its
    // index
    let v = [];

    // Put all elements and their index in
    // the array
    for (let i = 0; i < n; i++)
        v.push([arr[i], i]);

    // Sort the array by array values
    v.sort((a, b) => a[0] - b[0]);

    // Put indexes of modified array in arr[]
    for (let i = 0; i < n; i++)
        arr[v[i][1]] = i;
}

// Utility function to print an array.
function printArr(arr, n) {
    for (let i = 0; i < n; i++)
        console.log(arr[i] + " ");
}

// Driver program to test above method
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);

// This code is contributed by prasad264

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;

// Converts arr[0..n-1] to reduced form.
void convert(int arr[], int n)
{
    // Make a copy of the input array
    int sorted_arr[n];
    copy(arr, arr+n, sorted_arr);

    // Sort the copy in non-decreasing order
    sort(sorted_arr, sorted_arr+n);

    // Map each element of the sorted array to its index in the range 0 to n-1
    unordered_map<int, int> mp;
    for (int i = 0; i < n; i++) {
        mp[sorted_arr[i]] = i;
    }

    // Replace each element of the input array with its corresponding index
    for (int i = 0; i < n; i++) {
        arr[i] = mp[arr[i]];
    }
}

// Utility function to print an array.
void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}

// Driver program to test above method
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 {
    // Converts arr[0..n-1] to reduced form.
    public static void convert(int arr[], int n)
    {
        // Make a copy of the input array
        int[] sorted_arr = Arrays.copyOf(arr, n);

        // Sort the copy in non-decreasing order
        Arrays.sort(sorted_arr);

        // Map each element of the sorted array to its index
        // in the range 0 to n-1
        HashMap<Integer, Integer> mp
            = new HashMap<Integer, Integer>();
        for (int i = 0; i < n; i++) {
            mp.put(sorted_arr[i], i);
        }

        // Replace each element of the input array with its
        // corresponding index
        for (int i = 0; i < n; i++) {
            arr[i] = mp.get(arr[i]);
        }
    }

    // Utility function to print an array.
    public static void printArr(int arr[], int n)
    {
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    // Driver program to test above method
    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);
    }
}
// This code is contributed by Prajwal Kandekar

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.

This article is contributed by Arpit Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above