Convert an Array to reduced form using Hashing

Last Updated : 08 Oct, 2023

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)

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# 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:

Create a priority_queue pq to get the sorted version of arr in increasing order.
Push the values of arr in the priority queue.
Create a temp array and copy the contents of the priority_queue to temp[].
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 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)

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)

Convert an Array to reduced form using Hashing

Dheeraj Gupta

Improve

Article Tags :

Practice Tags :

Convert an Array to reduced form using Hashing

Similar Reads