Last Updated : 23 Jul, 2025
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.
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);
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:
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
// https://www.geeksforgeeks.org/cpp/unordered_map-in-cpp-stl/
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>
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:
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
// https://www.geeksforgeeks.org/cpp/unordered_map-in-cpp-stl/
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
// https://www.geeksforgeeks.org/cpp/unordered_map-in-cpp-stl/
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);
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
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4