Get the best out of our app
GFG App
Open App
Browser
Continue

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 ` `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

Output

```Given Array is
10 20 15 12 11 50

Converted Array is
0 4 3 2 1 5 ```

Time complexity: O(N2)
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 ` `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

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

 ``

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 ` `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

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)`

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)

This article is contributed by Dheeraj Gupta. Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up
Similar Reads
Related Tutorials