Convert an Array to reduced form using Hashing

Given an array with N distinct elements, convert the given array to a form where all elements are in the range from 0 to N-1. The order of elements is the same, i.e., 0 is placed in the place of the smallest element, 1 is placed for the second smallest element, … N-1 is placed for the largest element. 

Examples:

Input:  arr[] = {10, 40, 20}
Output: arr[] = {0, 2, 1}

Input:  arr[] = {5, 10, 40, 30, 20}
Output: arr[] = {0, 1, 4, 3, 2}

Naive Approach:

A simple solution is to first find the minimum element, replace it with 0, consider the remaining array and find the minimum in the remaining array and replace it with 1, and so on.

• Iterate over the array
  • Find the minimum element and keep its position of occurrence.
  • Update the result at the minimum index element with the new Position
  • Increment the new position by 1.
  • Update the original element at the current minimum element with the maximum value possible, so that it won’t be minimum in a further iteration
• Return the result

Below is the implementation of the above approach:

C++

// C++ program to convert an array in reduced
// form
#include <bits/stdc++.h>
using namespace std;

vector<int> convert(vector<int>& arr)
{
    int n = arr.size();
    vector<int> result(n);
    int currPos = 0;

    // Iterate over the array
    for (int i = 0; i < n; i++) {
        int minn = INT_MAX;
        int idx = -1;

        // Find the minimum element and keep
        // its position of occurrence
        for (int j = 0; j < n; j++) {
            if (minn > arr[j]) {
                minn = arr[j];
                idx = j;
            }
        }

        // Update the result at minimum index element
        // with new Position
        result[idx] = currPos;

        // Increment the new position
        currPos++;

        // Update the original element at current minimum
        // element with maximum value possible, so that it
        // won't be minimum in further iteration
        arr[idx] = INT_MAX;
    }

    // Return the result
    return result;
}

void printArr(vector<int>& arr)
{
    for (auto i : arr) {
        cout << i << " ";
    }
}

// Driver program to test above method
int main()
{
    vector<int> arr = { 10, 20, 15, 12, 11, 50 };
    int n = arr.size();

    cout << "Given Array is \n";
    printArr(arr);

    vector<int> result = convert(arr);

    cout << "\n\nConverted Array is \n";
    printArr(result);

    return 0;
}

Java

import java.util.*;
import java.io.*;

public class Gfg {
    static int[] convert(int[] arr)
    {
        int n = arr.length;
        int[] result = new int[n];
        int currPos = 0;
        // Iterate over the array
        for (int i = 0; i < n; i++) {
            int minn = Integer.MAX_VALUE;
            int idx = -1;

            // Find the minimum element and keep
            // its position of occurrence
            for (int j = 0; j < n; j++) {
                if (minn > arr[j]) {
                    minn = arr[j];
                    idx = j;
                }
            }

            // Update the result at minimum index element
            // with new Position
            result[idx] = currPos;

            // Increment the new position
            currPos++;

            // Update the original element at current
            // minimum element with maximum value possible,
            // so that it won't be minimum in further
            // iteration
            arr[idx] = Integer.MAX_VALUE;
        }

        // Return the result
        return result;
    }

    static void printArr(int[] arr)
    {
        for (int i : arr) {
            System.out.print(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);

        int[] result = convert(arr);

        System.out.println("\n\nConverted Array is");
        printArr(result);
    }
}

Python3

from typing import List
import sys

def convert(arr: List[int])->List[int]:
    n = len(arr)
    result = [0]*n
    curr_pos = 0

    # Iterate over the array
    for i in range(n):
        minn = sys.maxsize
        idx = -1

        # Find the minimum element and keep
        # its position of occurrence
        for j in range(n):
            if (minn > arr[j]):
                minn = arr[j]
                idx = j

        # Update the result at minimum index element
        # with new Position
        result[idx] = curr_pos

        # Increment the new position
        curr_pos += 1

        # Update the original element at current minimum
        # element with maximum value possible, so that it
        # won't be minimum in further iteration
        arr[idx] = sys.maxsize

    # Return the result
    return result


def printArr(arr: List[int]):
    for i in arr:
        print(i, end=" ")


# Driver program to test above method
if __name__ == '__main__':
    arr = [10, 20, 15, 12, 11, 50]
    n = len(arr)

    print("Given Array is ")
    printArr(arr)

    result = convert(arr)

    print("\n\nConverted Array is ")
    printArr(result)

C#

using System;

class Gfg
{
  static int[] Convert(int[] arr)
  {
    int n = arr.Length;
    int[] result = new int[n];
    int currPos = 0;
    // Iterate over the array
    for (int i = 0; i < n; i++)
    {
      int minn = int.MaxValue;
      int idx = -1;

      // Find the minimum element and keep
      // its position of occurrence
      for (int j = 0; j < n; j++)
      {
        if (minn > arr[j])
        {
          minn = arr[j];
          idx = j;
        }
      }

      // Update the result at minimum index element
      // with new Position
      result[idx] = currPos;

      // Increment the new position
      currPos++;

      // Update the original element at current
      // minimum element with maximum value possible,
      // so that it won't be minimum in further
      // iteration
      arr[idx] = int.MaxValue;
    }

    // Return the result
    return result;
  }

  static void PrintArr(int[] arr)
  {
    for (int i = 0; i < arr.Length; i++)
    {
      Console.Write(arr[i] + " ");
    }
  }

  public static void Main(string[] args)
  {
    int[] arr = { 10, 20, 15, 12, 11, 50 };
    int n = arr.Length;

    Console.WriteLine("Given Array is");
    PrintArr(arr);

    int[] result = Convert(arr);

    Console.WriteLine("\n\nConverted Array is");
    PrintArr(result);
  }
}

// This code is contributed by hkdass001.

Javascript

// Javascript program to convert an array in reduced form

function convert(arr)
{
    let n = arr.length;
    let result=new Array(n);
    let currPos = 0;

    // Iterate over the array
    for (let i = 0; i < n; i++) {
        let minn = Number.MAX_SAFE_INTEGER;
        let idx = -1;

        // Find the minimum element and keep
        // its position of occurrence
        for (let j = 0; j < n; j++) {
            if (minn > arr[j]) {
                minn = arr[j];
                idx = j;
            }
        }

        // Update the result at minimum index element
        // with new Position
        result[idx] = currPos;

        // Increment the new position
        currPos++;

        // Update the original element at current minimum
        // element with maximum value possible, so that it
        // won't be minimum in further iteration
        arr[idx] = Number.MAX_SAFE_INTEGER;
    }

    // Return the result
    return result;
}

function printArr(arr)
{
    for (let i=0; i<arr.length; i++) {
        document.write(arr[i] + " ");
    }
}

// Driver program to test above method
let arr = [ 10, 20, 15, 12, 11, 50 ];
let n = arr.length;

document.write("Given Array is");
printArr(arr);

let result = convert(arr);

document.write("Converted Array is ");
printArr(result);

Output

Given Array is 
10 20 15 12 11 50 

Converted Array is 
0 4 3 2 1 5 

Time complexity: O(N²)
Auxiliary space: O(N)

Efficient Approach:

The idea is to sort the given array and use an unordered map to store the reduced form of each value of array then update the whole array to its reduced form using values from unordered map.

Follow the below steps to implement the idea: 

• Create a temp array and copy the contents of the given array to temp[]. 
• Sort temp[] in ascending order. 
• Create an empty hash table.  
• Traverse temp[] from left to right and store mapping of numbers and their values (in converted array) in the hash table. 
• Traverse given array and change elements to their positions using a hash table. 

Below are implementations of the above idea. 

C++

// C++ program to convert an array in reduced
// form
#include <bits/stdc++.h>
using namespace std;

void convert(int arr[], int n)
{
    // Create a temp array and copy contents
    // of arr[] to temp
    int temp[n];
    memcpy(temp, arr, n*sizeof(int));

    // Sort temp array
    sort(temp, temp + n);

    // Create a hash table. Refer
    // http://tinyurl.com/zp5wgef
    unordered_map<int, int> umap;

    // One by one insert elements of sorted
    // temp[] and assign them values from 0
    // to n-1
    int val = 0;
    for (int i = 0; i < n; i++)
        umap[temp[i]] = val++;

    // Convert array by taking positions from
    // umap
    for (int i = 0; i < n; i++)
        arr[i] = umap[arr[i]];
}

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

// Java Program to convert an Array
// to reduced form
import java.util.*;

class GFG
{
    public static void convert(int arr[], int n)
    {
        // Create a temp array and copy contents
        // of arr[] to temp
        int temp[] = arr.clone();

        // Sort temp array
        Arrays.sort(temp);

        // Create a hash table.
        HashMap<Integer, Integer> umap = new HashMap<>();

        // One by one insert elements of sorted
        // temp[] and assign them values from 0
        // to n-1
        int val = 0;
        for (int i = 0; i < n; i++)
            umap.put(temp[i], val++);

        // Convert array by taking positions from
        // umap
        for (int i = 0; i < n; i++)
            arr[i] = umap.get(arr[i]);
    }

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

    // Driver code
    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 Abhishek Panwar

Python3

# Python3 program to convert an array
# in reduced form
def convert(arr, n):
    # Create a temp array and copy contents
    # of arr[] to temp
    temp = [arr[i] for i in range (n) ]

    # Sort temp array
    temp.sort()

    # create a map
    umap = {}


    # One by one insert elements of sorted
    # temp[] and assign them values from 0
    # to n-1
    val = 0
    for i in range (n):
        umap[temp[i]] = val
        val += 1

    # Convert array by taking positions from umap
    for i in range (n):
        arr[i] = umap[arr[i]]

def printArr(arr, n):
    for i in range(n):
        print(arr[i], end = " ")

# Driver Code
if __name__ == "__main__":
    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 Abhishek Gupta

C#

// C# Program to convert an Array
// to reduced form
using System;
using System.Collections.Generic;
using System.Linq;

class GFG
{
    public static void convert(int []arr, int n)
    {
        // Create a temp array and copy contents
        // of []arr to temp
        int []temp = new int[arr.Length];
        Array.Copy(arr, 0, temp, 0, arr.Length);

        // Sort temp array
        Array.Sort(temp);

        // Create a hash table.
        Dictionary<int, int> umap =
            new Dictionary<int, int>();

        // One by one insert elements of sorted
        // []temp and assign them values from 0
        // to n - 1
        int val = 0;
        for (int i = 0; i < n; i++)
            if(umap.ContainsKey(temp[i]))
                umap[temp[i]] = val++;
            else
                umap.Add(temp[i], val++);

        // Convert array by taking positions from
        // umap
        for (int i = 0; i < n; i++)
            arr[i] = umap[arr[i]];
    }

    public static void printArr(int []arr, int n)
    {
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }

    // Driver code
    public static void Main(String[] args)
    {

        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);
    }
}

// This code is contributed by PrinciRaj1992

Javascript

<script>

// Javascript Program to convert an Array
// to reduced form

    function convert(arr, n)
    {
        // Create a temp array and copy contents
        // of arr[] to temp
        let temp = [...arr];

        // Sort temp array
        temp.sort((a, b) => a - b);

        // Create a hash table.
        let umap = new Map();

        // One by one insert elements of sorted
        // temp[] and assign them values from 0
        // to n-1
        let val = 0;
        for (let i = 0; i < n; i++)
            umap.set(temp[i], val++);

        // Convert array by taking positions from
        // umap
        for (let i = 0; i < n; i++)
            arr[i] = umap.get(arr[i]);
    }

    function prletArr(arr, n)
    {
        for (let i = 0; i < n; i++)
            document.write(arr[i] + " ");
    }

// Driver program

         let arr = [10, 20, 15, 12, 11, 50];
        let n = arr.length;

        document.write("Given Array is " + "<br/>");
        prletArr(arr, n);

        convert(arr , n);

        document.write("<br/>" + "Converted Array is "  + "<br/>");
        prletArr(arr, n);

</script>

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)

Using priority_queue and hashmap:

The idea is to sort the given array using priority_queue instead of calling sort stl and use an unordered map to store the reduced form of each value of array then update the whole array to its reduced form using values from unordered map.

Algorithm:

1. Create a priority_queue pq to get the sorted version of arr in increasing order.
2. Push the values of arr in the priority queue.
3. Create a temp array and copy the contents of the priority_queue to temp[]. 
4. Create an empty hash table.  
5. Traverse temp[] from left to right and store mapping of numbers and their values (in converted array) in the hash table. 
6. Traverse given array and change elements to their positions using a hash table.

Below is the implementation of the approach:

C++

// C++ program to convert an array in reduced
// form

#include <bits/stdc++.h>
using namespace std;

// Function to convert an array in reduced
// form
void convert(int arr[], int n) {
    // Create a temp array and copy contents
    // of arr[] to temp
    int temp[n];
    memcpy(temp, arr, n*sizeof(int));

      // prioirty queue to get array sorted
      // in increasing order
      priority_queue<int, vector<int>, greater<int>> pq;

      for( int i = 0; i < n; i++)
      pq.push( arr[i] );

      int i = 0;

    // taking elements from priority queue
      // to temp array
      while(!pq.empty()) {
      temp[i++] = pq.top();
      pq.pop();
    }

    // Create a hash table. Refer
    // http://tinyurl.com/zp5wgef
    unordered_map<int, int> umap;

    // One by one insert elements of sorted
    // temp[] and assign them values from 0
    // to n-1
    int val = 0;
    for (int i = 0; i < n; i++)
        umap[temp[i]] = val++;

    // Convert array by taking positions from
    // umap
    for (int i = 0; i < n; i++)
        arr[i] = umap[arr[i]];
}

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

// Java program to convert an array in reduced
// form

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

// Function to convert an array in reduced
// form

class Gfg {
    public static void convert(int[] arr, int n) {

        // Create a temp array and copy contents
        // of arr[] to temp
        int[] temp = Arrays.copyOf(arr, n);

        // prioirty queue to get array sorted
        // in increasing order
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < n; i++) {
            pq.offer(arr[i]);
        }

        int i = 0;

        // taking elements from priority queue
        // to temp array
        while (!pq.isEmpty()) {
            temp[i++] = pq.poll();
        }

        // Create a hash table. Refer
        // http://tinyurl.com/zp5wgef
        Map<Integer, Integer> umap = new HashMap<>();

        // One by one insert elements of sorted
        // temp[] and assign them values from 0
        // to n-1
        int val = 0;
        for (i = 0; i < n; i++) {
            umap.put(temp[i], val++);
        }

        // Convert array by taking positions from
        // umap
        for (i = 0; i < n; i++) {
            arr[i] = umap.get(arr[i]);
        }
    }

    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);
    }
}

Python3

import heapq # Import heapq for the priority queue data structure

# Function to convert an array into its reduced form
def convert(arr):
    n = len(arr) # Get the length of the input array

    # Create a temporary list and copy the contents of arr to it
    temp = list(arr)

    # Create a priority queue to get the array sorted in increasing order
    # using heapq module
    pq = []
    for i in range(n):
        heapq.heappush(pq, arr[i])

    i = 0

    # Taking elements from priority queue to temp list
    while len(pq) != 0:
        temp[i] = heapq.heappop(pq)
        i += 1

    # Create a dictionary to store the index of each element in the sorted list
    umap = {}

    # Assign ranks to the elements of the sorted list
    val = 0
    for i in range(n):
        umap[temp[i]] = val
        val += 1

    # Replace each element of the input array with its rank in the dictionary
    for i in range(n):
        arr[i] = umap[arr[i]]

# Driver code to test the convert function
if __name__ == "__main__":
    arr = [10, 20, 15, 12, 11, 50]
    print("Given array is")
    print(arr)

    convert(arr)

    print("\nConverted array is")
    print(arr)

C#

using System;
using System.Collections.Generic;

class GFG
{
    // Function to convert an array in reduced form
    static void Convert(int[] arr, int n)
    {
        // Create a temp array and copy contents
        // of arr[] to temp
        int[] temp = new int[n];
        Array.Copy(arr, temp, n);

        // Sorted array using Priority Queue
        // to get array sorted in increasing order
        var pq = new SortedSet<int>(temp);

        int i = 0;

        // Taking elements from the sorted set
        // and assigning them values from 0 to n-1
        foreach (var num in pq)
        {
            temp[i++] = num;
        }

        // Create a dictionary (hash table)
        // to store the positions of elements
        var dict = new Dictionary<int, int>();

        // Assigning positions to elements in the sorted array
        int val = 0;
        foreach (var num in temp)
        {
            if (!dict.ContainsKey(num))
            {
                dict[num] = val++;
            }
        }

        // Convert array by taking positions from the dictionary
        for (int j = 0; j < n; j++)
        {
            arr[j] = dict[arr[j]];
        }
    }

    // Function to print the array
    static void PrintArr(int[] arr)
    {
        foreach (int num in arr)
        {
            Console.Write(num + " ");
        }
    }

    // Driver program to test the above method
    static void Main()
    {
        int[] arr = { 10, 20, 15, 12, 11, 50 };
        int n = arr.Length;

        Console.WriteLine("Given Array is:");
        PrintArr(arr);
       // Console.WriteLine("\n");
        Convert(arr, n);

        Console.WriteLine("\n\nConverted Array is:");
        PrintArr(arr);
    }
}

Javascript

// Function to convert an array in reduced form
function convert(arr) {
    // Create a copy of the array
    let temp = arr.slice();

    // Sort the copy in increasing order
    temp.sort((a, b) => a - b);

    // Create a map to store original indices
    let umap = new Map();

    // Assign values from 0 to n-1
    for (let i = 0; i < arr.length; i++) {
        umap.set(temp[i], i);
    }

    // Convert the array using the map
    for (let i = 0; i < arr.length; i++) {
        arr[i] = umap.get(arr[i]);
    }
}

function printArr(arr) {
    for (let i = 0; i < arr.length; i++) {
        console.log(arr[i] + " ");
    }
}

// Driver program to test above method
let arr = [10, 20, 15, 12, 11, 50];

console.log("Given Array is:");
printArr(arr);

convert(arr);

console.log("\nConverted Array is:");
printArr(arr);

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) as insertion of N elements in priority_queue takes N*logN time. Here, N is size of the input array.

Space Complexity: O(N) as priority_queue pq and temp array has been created.

Convert an array to reduced form | Set 2 (Using vector of pairs)

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.