Skip to main content

Convert an array to reduced form

Here given code implementation process.

/*
   Java Program
   Convert an array to reduced form
*/
import java.util.HashMap;
import java.util.HashSet;
import java.util.Arrays;
public class Reduction
{
	//Function which is display array elements
	public void display(int[] arr, int n)
	{
		for (int i = 0; i < n; ++i)
		{
			System.out.print("   " + arr[i]);
		}
		System.out.print("\n");
	}
	// Handles the request to get sorted order element position
	public void convert(int[] arr, int n)
	{
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		HashMap < Integer, HashSet < Integer > > record 
          = new HashMap < Integer, HashSet < Integer > > ();
		// Loop controlling variable
		int temp = 0;
		int i = 0;
		// Auxiliary array 
		int[] auxiliary = arr.clone();
		// Sort array elements in ascending order
		Arrays.sort(auxiliary);
		// Get order of sorted elements in proper way
		for (i = 0; i < n; ++i)
		{
			if (record.containsKey(auxiliary[i]))
			{
				// When element is repeated
				record.get(auxiliary[i]).add(i);
			}
			else
			{
				// Add new key
				record.put(auxiliary[i], new HashSet < Integer > ());
				// Add first value
				record.get(auxiliary[i]).add(i);
			}
		}
		// Assign the calculated result to actual array
		for (i = 0; i < n; ++i)
		{
			// Get sorted position
			temp = record.get(arr[i]).iterator().next();
			// Remove first element
			record.get(arr[i]).remove(temp);
			// Assign sort position
			arr[i] = temp;
		}
	}
	public static void main(String[] arg)
	{
		Reduction task = new Reduction();
		// Define array of integer elements
		// Element duplicates are allowed
		int[] arr = {
			3 , 5 , 8 , 2 , 10 , 6 , 9 , 5 , 3
		};
		// Get the length of array
		int n = arr.length;
		System.out.print(" Before Convert \n ");
		task.display(arr, n);
		task.convert(arr, n);
		System.out.print(" After Convert \n ");
		task.display(arr, n);
	}
}

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
// Include header file
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <set>

using namespace std;
/*
   C++ Program
   Convert an array to reduced form
*/
class Reduction
{
	public:
		//Function which is display array elements
		void display(int arr[], int n)
		{
			for (int i = 0; i < n; ++i)
			{
				cout << "   " << arr[i];
			}
			cout << "\n";
		}
	// Handles the request to get sorted order element position
	void convert(int arr[], int n)
	{
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		unordered_map < int, set < int > > record;
		// Loop controlling variable
		int temp = 0;
		int i = 0;
		// Auxiliary array
		int auxiliary[n];
      	// Get actual array element
		for (i = 0; i < n; ++i)
		{
        	auxiliary[i] = arr[i];
        }
		// Sort array elements in ascending order
      	sort(auxiliary, auxiliary+n);
		// Get order of sorted elements in proper way
		for (i = 0; i < n; ++i)
		{
			if (record.find(auxiliary[i]) != record.end())
			{
				// When element is repeated
				record[auxiliary[i]].insert(i);
			}
			else
			{
				// Add first value
				record[auxiliary[i]].insert(i);
			}
		}
		// Assign the calculated result to actual array
		for (i = 0; i < n; ++i)
		{
			// Get sorted position
			temp = *record[arr[i]].begin();
			// Remove first element
			record[arr[i]].erase(temp);
			// Assign sort position
			arr[i] = temp;
		}
	}
};
int main()
{
	Reduction task = Reduction();
	// Define array of integer elements
	// Element duplicates are allowed
	int arr[] = {
		3 , 5 , 8 , 2 , 10 , 6 , 9 , 5 , 3
	};
	// Get the length of array
	int n = sizeof(arr) / sizeof(arr[0]);
	cout << " Before Convert \n ";
	task.display(arr, n);
	task.convert(arr, n);
	cout << " After Convert \n ";
	task.display(arr, n);
	return 0;
}

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
// Include namespace system
using System;
using System.Linq;
using System.Collections.Generic;
/*
   C# Program
   Convert an array to reduced form
*/
public class Reduction
{
	//Function which is display array elements
	public void display(int[] arr, int n)
	{
		for (int i = 0; i < n; ++i)
		{
			Console.Write("   " + arr[i]);
		}
		Console.Write("\n");
	}
	// Handles the request to get sorted order element position
	public void convert(int[] arr, int n)
	{
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		Dictionary <int, HashSet <int> > record 
          = new Dictionary < int, HashSet < int > > ();
		// Loop controlling variable
		int temp = 0;
		int i = 0;
		// Auxiliary array
		int[] auxiliary = (int[])arr.Clone();
		// Sort array elements in ascending order
		Array.Sort(auxiliary);
		// Get order of sorted elements in proper way
		for (i = 0; i < n; ++i)
		{
			if (record.ContainsKey(auxiliary[i]))
			{
				// When element is repeated
				record[auxiliary[i]].Add(i);
			}
			else
			{
				// Add new key
				record.Add(auxiliary[i], new HashSet < int > ());
				// Add first value
				record[auxiliary[i]].Add(i);
			}
		}
		// Assign the calculated result to actual array
		for (i = 0; i < n; ++i)
		{
			// Get sorted position
			temp = record[arr[i]].First();
			// Remove first element
			record[arr[i]].Remove(temp);
			// Assign sort position
			arr[i] = temp;
		}
	}
	public static void Main(String[] arg)
	{
		Reduction task = new Reduction();
		// Define array of integer elements
		// Element duplicates are allowed
		int[] arr = {
			3 , 5 , 8 , 2 , 10 , 6 , 9 , 5 , 3
		};
		// Get the length of array
		int n = arr.Length;
		Console.Write(" Before Convert \n ");
		task.display(arr, n);
		task.convert(arr, n);
		Console.Write(" After Convert \n ");
		task.display(arr, n);
	}
}

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
<?php
/*
   Php Program
   Convert an array to reduced form
*/
class Reduction
{
	//Function which is display array elements
	public
	function display( & $arr, $n)
	{
		for ($i = 0; $i < $n; ++$i)
		{
			echo "   ".$arr[$i];
		}
		echo "\n";
	}
	// Handles the request to get sorted order element position
	public
	function convert( & $arr, $n)
	{
		if ($n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		$record = array();
		// Loop controlling variable
		$temp = 0;
		$i = 0;
		// Auxiliary array
		$auxiliary = array_merge(array(), $arr);
		sort($auxiliary);
		// Get order of sorted elements in proper way
		for ($i = 0; $i < $n; ++$i)
		{
			if (array_key_exists($auxiliary[$i], $record))
			{
				$record[$auxiliary[$i]][] = $i;
			}
			else
			{
				$record[$auxiliary[$i]] = array();
				$record[$auxiliary[$i]][] = $i;
			}
		}
		// Assign the calculated result to actual array
		for ($i = 0; $i < $n; ++$i)
		{
			// Get sorted position
			$temp = reset($record[$arr[$i]]);
			array_shift($record[$arr[$i]]);
			// Assign sort position
			$arr[$i] = $temp;
		}
	}
}

function main()
{
	$task = new Reduction();
	// Define array of integer elements
	// Element duplicates are allowed
	$arr = array(3, 5, 8, 2, 10, 6, 9, 5, 3);
	// Get the length of array
	$n = count($arr);
	echo " Before Convert \n ";
	$task->display($arr, $n);
	$task->convert($arr, $n);
	echo " After Convert \n ";
	$task->display($arr, $n);
}
main();

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
/*
   Node Js Program
   Convert an array to reduced form
*/
class Reduction
{
	//Function which is display array elements
	display(arr, n)
	{
		for (var i = 0; i < n; ++i)
		{
			process.stdout.write("   " + arr[i]);
		}
		process.stdout.write("\n");
	}
	// Handles the request to get sorted order element position
	convert(arr, n)
	{
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
	
		var record = new Map();
		// Loop controlling variable
		var temp = 0;
		var i = 0;
		// Auxiliary array
		var auxiliary = arr.slice();
		// Sort array elements in ascending order
		auxiliary.sort(function(x, y){return x-y});
		// Get order of sorted elements in proper way
		for (i = 0; i < n; ++i)
		{
			if (record.has(auxiliary[i]))
			{
				// When element is repeated
				record.get(auxiliary[i]).add(i);
			}
			else
			{
				// Add new key
				record.set(auxiliary[i], new Set());
				// Add first value
				record.get(auxiliary[i]).add(i);
			}
		}
		// Assign the calculated result to actual array
		for (i = 0; i < n; ++i)
		{
			// Get sorted position
			temp = record.get(arr[i]).values().next().value;
       
			// Remove first element
			record.get(arr[i]).delete(temp);
			// Assign sort position
			arr[i] = temp;
		}
	}
}

function main()
{
	var task = new Reduction();
	// Define array of integer elements
	// Element duplicates are allowed
	var arr = [3, 5, 8, 2, 10, 6, 9, 5, 3];
	// Get the length of array
	var n = arr.length;
	process.stdout.write(" Before Convert \n ");
	task.display(arr, n);
	task.convert(arr, n);
	process.stdout.write(" After Convert \n ");
	task.display(arr, n);
}
main();

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
#    Python 3 Program
#    Convert an array to reduced form

class Reduction :
	# Function which is display list elements
	def display(self, arr, n) :
		i = 0
		while (i < n) :
			print("  ", arr[i], end = "")
			i += 1
		
		print(end = "\n")
	
	#  Handles the request to get sorted order element position
	def convert(self, arr, n) :
		if (n <= 0) :
			return
		
		#  Used to collecting the sorted order sequence
		record = dict()
		#  Loop controlling variable
		temp = 0
		i = 0
		#  Auxiliary list
		auxiliary = arr.copy()
		#  Sort list elements in ascending order
		auxiliary.sort()
		#  Get order of sorted elements in proper way
		i = 0
		while (i < n) :
			if (auxiliary[i] in record.keys()) :
				#  When element is repeated
				record.get(auxiliary[i]).add(i)
			else :
				#  Add new key
				record[auxiliary[i]] = set()
				#  Add first value
				record.get(auxiliary[i]).add(i)
			
			i += 1
		
		#  Assign the calculated result to actual list
		i = 0
		while (i < n) :
			#  Get sorted position
			temp = record.get(arr[i]).pop()
			#  Assign sort position
			arr[i] = temp
			i += 1
		
	

def main() :
	task = Reduction()
	#  Define list of integer elements
	#  Element duplicates are allowed
	arr = [3, 5, 8, 2, 10, 6, 9, 5, 3]
	#  Get the length of list
	n = len(arr)
	print(" Before Convert \n ", end = "")
	task.display(arr, n)
	task.convert(arr, n)
	print(" After Convert \n ", end = "")
	task.display(arr, n)

if __name__ == "__main__": main()

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
#    Ruby Program
#    Convert an array to reduced form

class Reduction 
	# Function which is display array elements
	def display(arr, n) 
		i = 0
		while (i < n) 
			print("   ", arr[i])
			i += 1
		end

		print("\n")
	end

	#  Handles the request to get sorted order element position
	def convert(arr, n) 
		if (n <= 0) 
			return
		end

		#  Used to collecting the sorted order sequence
		record = Hash.new
		#  Loop controlling variable
		temp = 0
		i = 0
		#  Auxiliary array
		auxiliary = arr.sort
	
		#  Get order of sorted elements in proper way
		i = 0
		while (i < n) 
			if (record.key?(auxiliary[i])) 
				record[auxiliary[i]].push(i)
			else 
				record[auxiliary[i]] = []
				record[auxiliary[i]].push(i)
			end

			i += 1
		end

		#  Assign the calculated result to actual array
		i = 0
		while (i < n) 
			#  Get sorted position
			temp = record[arr[i]].pop()
			#  Assign sort position
			arr[i] = temp
			i += 1
		end

	end

end

def main() 
	task = Reduction.new()
	#  Define array of integer elements
	#  Element duplicates are allowed
	arr = [3, 5, 8, 2, 10, 6, 9, 5, 3]
	#  Get the length of array
	n = arr.length
	print(" Before Convert \n ")
	task.display(arr, n)
	task.convert(arr, n)
	print(" After Convert \n ")
	task.display(arr, n)
end

main()

Output

 Before Convert 
    3   5   8   2   10   6   9   5   3
 After Convert 
    2   4   6   0   8   5   7   3   1

import scala.collection.mutable._;
/*
   Scala Program
   Convert an array to reduced form
*/
class Reduction
{
	//Function which is display array elements
	def display(arr: Array[Int], n: Int): Unit = {
		var i: Int = 0;
		while (i < n)
		{
			print("   " + arr(i));
			i += 1;
		}
		print("\n");
	}
	// Handles the request to get sorted order element position
	def convert(arr: Array[Int], n: Int): Unit = {
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		var record: Map[Int, Set[Int]] = Map();
		// Loop controlling variable
		var temp: Int = 0;
		var i: Int = 0;
		// Auxiliary array
		var auxiliary: Array[Int] = Array.fill[Int](n)(0);
		// Sort array elements in ascending order
		while (i < n)
		{
			auxiliary(i) = arr(i);
			i += 1;
		}
		scala.util.Sorting.quickSort(auxiliary);
		i = 0;
		while (i < n)
		{
			if (record.contains(auxiliary(i)))
			{
				// When element is repeated
				record.get(auxiliary(i)).get.add(i);
			}
			else
			{
				// Add new key
				record.addOne(auxiliary(i), Set());
				// Add first value
				record.get(auxiliary(i)).get.add(i);
			}
			i += 1;
		}
		// Assign the calculated result to actual array
		i = 0;
		while (i < n)
		{
			// Get sorted position
			temp = record.get(arr(i)).get.head;
			// Remove first element
			record.get(arr(i)).get.remove(temp);
			// Assign sort position
			arr(i) = temp;
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Reduction = new Reduction();
		// Define array of integer elements
		// Element duplicates are allowed
		var arr: Array[Int] = Array(3, 5, 8, 2, 10, 6, 9, 5, 3);
		// Get the length of array
		var n: Int = arr.length;
		print(" Before Convert \n ");
		task.display(arr, n);
		task.convert(arr, n);
		print(" After Convert \n ");
		task.display(arr, n);
	}
}

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
import Foundation
/*
   Swift 4 Program
   Convert an array to reduced form
*/
class Reduction
{
	//Function which is display array elements
	func display(_ arr: [Int], _ n: Int)
	{
		var i: Int = 0;
		while (i < n)
		{
			print("   ", arr[i], terminator: "");
			i += 1;
		}
		print(terminator: "\n");
	}
	// Handles the request to get sorted order element position
	func convert(_ arr: inout[Int], _ n: Int)
	{
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		var record = [Int: Set <Int> ]();
		// Loop controlling variable
		var temp: Int = 0;
		var i: Int = 0;
		// Auxiliary array
		var auxiliary: [Int] = Array(repeating: 0, count: n);
		// Sort array elements in ascending order
		while (i < n)
		{
			auxiliary[i] = arr[i];
			i += 1;
		}
      	auxiliary.sort();
		i = 0;
		while (i < n)
		{
			if (record.keys.contains(auxiliary[i]))
			{
				// When element is repeated
				record[auxiliary[i]]!.insert(i);
			}
			else
			{
				// Add new key
				record[auxiliary[i]] = Set<Int>();
				// Add first value
				record[auxiliary[i]]!.insert(i);
			}
			i += 1;
		}
		// Assign the calculated result to actual array
		i = 0;
		while (i < n)
		{
			// Get sorted position
			temp = record[arr[i]]!.first!;
			// Remove first element
			record[arr[i]]!.remove(temp);
			// Assign sort position
			arr[i] = temp;
			i += 1;
		}
	}
}
func main()
{
	let task: Reduction = Reduction();
	// Define array of integer elements
	// Element duplicates are allowed
	var arr: [Int] = [3, 5, 8, 2, 10, 6, 9, 5, 3];
	// Get the length of array
	let n: Int = arr.count;
	print(" Before Convert \n ", terminator: "");
	task.display(arr, n);
	task.convert(&arr, n);
	print(" After Convert \n ", terminator: "");
	task.display(arr, n);
}
main();

Output

 Before Convert
     3    5    8    2    10    6    9    5    3
 After Convert
     2    3    6    0    8    5    7    4    1
/*
   Kotlin Program
   Convert an array to reduced form
*/
class Reduction
{
	//Function which is display array elements
	fun display(arr: Array < Int > , n: Int): Unit
	{
		var i: Int = 0;
		while (i < n)
		{
			print("   " + arr[i]);
			i += 1;
		}
		print("\n");
	}
	// Handles the request to get sorted order element position
	fun convert(arr: Array < Int > , n: Int): Unit
	{
		if (n <= 0)
		{
			return;
		}
		// Used to collecting the sorted order sequence
		var record = mutableMapOf<Int, MutableSet <Int>>();
		// Loop controlling variable
		var temp: Int ;
		var i: Int = 0;
		// Auxiliary array
		var auxiliary: Array < Int > = Array(n)
		{
			0
		};
		// Sort array elements in ascending order
		while (i < n)
		{
			auxiliary[i] = arr[i];
			i += 1;
		}
      	auxiliary.sort();
		i = 0;
		while (i < n)
		{
			if (record.containsKey(auxiliary[i]))
			{
				// When element is repeated
				record.getValue(auxiliary[i]).add(i);
			}
			else
			{
				// Add new key
				record.put(auxiliary[i], mutableSetOf <Int> ());
				// Add first value
				record.getValue(auxiliary[i]).add(i);
			}
			i += 1;
		}
		// Assign the calculated result to actual array
		i = 0;
		while (i < n)
		{
			// Get sorted position
			temp = record.getValue(arr[i]).elementAt(0);
			// Remove first element
			record.getValue(arr[i]).remove(temp);
			// Assign sort position
			arr[i] = temp;
			i += 1;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	var task: Reduction = Reduction();
	// Define array of integer elements
	// Element duplicates are allowed
	var arr: Array < Int > = arrayOf(3, 5, 8, 2, 10, 6, 9, 5, 3);
	// Get the length of array
	var n: Int = arr.count();
	print(" Before Convert \n ");
	task.display(arr, n);
	task.convert(arr, n);
	print(" After Convert \n ");
	task.display(arr, n);
}

Output

 Before Convert
    3   5   8   2   10   6   9   5   3
 After Convert
    1   3   6   0   8   5   7   4   2
Last updated on by Kalkicode




Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment