Radix sort example
Here given code implementation process.
//C Program
//Radix sort example
#include <stdio.h>
#include <stdlib.h>
//Return maximum element in given array
int maximum_element(int arr[],int size)
{
int max_value=arr[0],min_value=arr[0];
for (int i = 1; i < size; ++i)
{
if(max_value<arr[i])
{
max_value=arr[i];
}
if(min_value>arr[i])
{
min_value=arr[i];
}
}
if(min_value<0 && -min_value > max_value)
{
max_value=-min_value;
}
return max_value;
}
//Display array elements
void display(int arr[],int size)
{
for (int i = 0; i < size; ++i)
{
//Print array value of i location
printf(" %d",arr[i] );
}
printf("\n");
}
void run_sort(int arr[],int slot[],int auxiliary[], int size,int mod)
{
//set initial slot values
for (int i = 0; i < 10; ++i)
{
slot[i]=0;
}
for (int i = 0; i < size; ++i)
{
if(arr[i]<0)
{
printf("\nThis Algorithm are not capable to work to negative numbers\n");
return;
}
//set slot element
slot[(arr[i]/mod)%10]++;
}
//update slot
for (int i = 1; i < 10; ++i)
{
slot[i]+=slot[i-1];
}
for (int i = size-1; i >=0 ; --i)
{
auxiliary[ slot[ ( arr[i] / mod) %10 ]-1 ] = arr[i];
slot[(arr[i] / mod)%10]--;
}
//Assign value of actual array
for (int i = 0; i < size; ++i)
{
arr[i]=auxiliary[i];
}
}
void radix_sort(int arr[],int size)
{
//Get the maximum element of array
int max_value=maximum_element(arr,size);
int mod = 1;
//allocated slot of 0 - 9 for positive number
int slot[10];
//Allocate auxiliary space to perform radix sort
int auxiliary[size];
while(max_value!=0)
{
run_sort(arr,slot,auxiliary,size,mod);
mod = mod*10;
//remove last digit
max_value /= 10;
}
}
int main()
{
//Define array elements
int arr[]= {8,2,3,8,1,3,73,121,54,23,84,13,67,23,52};
//Get the size of array elements
int size=sizeof(arr)/sizeof(arr[0]);
printf("Before Sort : \n");
display(arr,size);
radix_sort(arr,size);
printf("After Sort : \n");
display(arr,size);
return 0;
}
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
C++ Program
Radix sort example
*/
#include<iostream>
using namespace std;
class MySort {
public:
//Return maximum element in given array
int maximum_element(int arr[], int size) {
int max_value = arr[0], min_value = arr[0];
for (int i = 1; i < size; ++i) {
if (max_value < arr[i]) {
max_value = arr[i];
}
if (min_value > arr[i]) {
min_value = arr[i];
}
}
if (min_value < 0 && -min_value > max_value) {
max_value = -min_value;
}
return max_value;
}
//Display array elements
void display(int arr[], int size) {
for (int i = 0; i < size; ++i) {
cout << " " << arr[i];
}
cout << "\n";
}
void run_sort(int arr[], int slot[], int auxiliary[], int size, int mod) {
//set initial slot values
for (int i = 0; i < 10; ++i) {
slot[i] = 0;
}
for (int i = 0; i < size; ++i) {
if (arr[i] < 0) {
cout << "\nThis Algorithm are not capable to work to negative numbers\n";
return;
}
//set slot element
slot[(arr[i] / mod) % 10]++;
}
//update slot
for (int i = 1; i < 10; ++i) {
slot[i] += slot[i - 1];
}
for (int i = size - 1; i >= 0; --i) {
auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i];
slot[(arr[i] / mod) % 10]--;
}
//Assign value of actual array
for (int i = 0; i < size; ++i) {
arr[i] = auxiliary[i];
}
}
void radix_sort(int arr[], int size) {
//Get the maximum element of array
int max_value = this->maximum_element(arr, size);
int mod = 1;
int slot[10];
int auxiliary[size];
while (max_value != 0) {
this->run_sort(arr, slot, auxiliary, size, mod);
mod = mod *10;
//remove last digit
max_value /= 10;
}
}
};
int main() {
MySort obj ;
int arr[] = {
8,
2,
3,
8,
1,
3,
73,
121,
54,
23,
84,
13,
67,
23,
52
};
//Get the size of array
int size = sizeof(arr) / sizeof(arr[0]);
cout << "Before Sort : \n";
obj.display(arr, size);
obj.radix_sort(arr, size);
cout << "After Sort : \n";
obj.display(arr, size);
return 0;
}
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
Java Program
Radix sort example
*/
public class MySort {
//Return maximum element in given array
public int maximum_element(int []arr,int size)
{
int max_value=arr[0],min_value=arr[0];
for (int i = 1; i < size; ++i)
{
if(max_value<arr[i])
{
max_value=arr[i];
}
if(min_value>arr[i])
{
min_value=arr[i];
}
}
if(min_value<0 && -min_value > max_value)
{
max_value=-min_value;
}
return max_value;
}
//Display array elements
public void display(int []arr, int size)
{
for (int i = 0; i < size; ++i)
{
System.out.print(" "+arr[i] );
}
System.out.print("\n");
}
public void run_sort(int []arr,int []slot,int []auxiliary, int size,int mod)
{
//set initial slot values
for (int i = 0; i < 10; ++i)
{
slot[i]=0;
}
for (int i = 0; i < size; ++i)
{
if(arr[i]<0)
{
System.out.print("\nThis Algorithm are not capable to work to negative numbers\n");
return;
}
//set slot element
slot[(arr[i]/mod)%10]++;
}
//update slot
for (int i = 1; i < 10; ++i)
{
slot[i]+=slot[i-1];
}
for (int i = size-1; i >=0 ; --i)
{
auxiliary[ slot[ ( arr[i] / mod) %10 ]-1 ] = arr[i];
slot[(arr[i] / mod)%10]--;
}
//Assign value of actual array
for (int i = 0; i < size; ++i)
{
arr[i]=auxiliary[i];
}
}
public void radix_sort(int []arr,int size)
{
//Get the maximum element of array
int max_value=maximum_element(arr,size);
int mod = 1;
//allocated slot of 0 - 9 for positive number
int []slot= new int[10];
//Allocate auxiliary space to perform radix sort
int []auxiliary = new int[size];
while(max_value!=0)
{
run_sort(arr,slot,auxiliary,size,mod);
mod = mod*10;
//remove last digit
max_value /= 10;
}
}
public static void main(String[] args)
{
MySort obj = new MySort();
//Define array elements
int []arr= {8,2,3,8,1,3,73,121,54,23,84,13,67,23,52};
//Get the size of array
int size = arr.length;
System.out.print("Before Sort : \n");
obj.display(arr,size);
obj.radix_sort(arr,size);
System.out.print("After Sort : \n");
obj.display(arr,size);
}
}
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
C# Program
Radix sort example
*/
using System;
public class MySort {
//Return maximum element in given array
public int maximum_element(int[] arr, int size) {
int max_value = arr[0], min_value = arr[0];
for (int i = 1; i < size; ++i) {
if (max_value < arr[i]) {
max_value = arr[i];
}
if (min_value > arr[i]) {
min_value = arr[i];
}
}
if (min_value < 0 && -min_value > max_value) {
max_value = -min_value;
}
return max_value;
}
//Display array elements
public void display(int[] arr, int size) {
for (int i = 0; i < size; ++i) {
Console.Write(" " + arr[i]);
}
Console.Write("\n");
}
public void run_sort(int[] arr, int[] slot, int[] auxiliary, int size, int mod) {
//set initial slot values
for (int i = 0; i < 10; ++i) {
slot[i] = 0;
}
for (int i = 0; i < size; ++i) {
if (arr[i] < 0) {
Console.Write("\nThis Algorithm are not capable to work to negative numbers\n");
return;
}
//set slot element
slot[(arr[i] / mod) % 10]++;
}
//update slot
for (int i = 1; i < 10; ++i) {
slot[i] += slot[i - 1];
}
for (int i = size - 1; i >= 0; --i) {
auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i];
slot[(arr[i] / mod) % 10]--;
}
//Assign value of actual array
for (int i = 0; i < size; ++i) {
arr[i] = auxiliary[i];
}
}
public void radix_sort(int[] arr, int size) {
//Get the maximum element of array
int max_value = maximum_element(arr, size);
int mod = 1;
//allocated slot of 0 - 9 for positive number
int[] slot = new int[10];
//Allocate auxiliary space to perform radix sort
int[] auxiliary = new int[size];
while (max_value != 0) {
run_sort(arr, slot, auxiliary, size, mod);
mod = mod * 10;
//remove last digit
max_value /= 10;
}
}
public static void Main(String[] args) {
MySort obj = new MySort();
int[]
//Define array elements
arr = {
8,
2,
3,
8,
1,
3,
73,
121,
54,
23,
84,
13,
67,
23,
52
};
//Get the size of array
int size = arr.Length;
Console.Write("Before Sort : \n");
obj.display(arr, size);
obj.radix_sort(arr, size);
Console.Write("After Sort : \n");
obj.display(arr, size);
}
}
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
<?php
/*
Php Program
Radix sort example
*/
class MySort {
//Return maximum element in given array
public function maximum_element($arr, $size) {
$max_value = $arr[0];
$min_value = $arr[0];
for ($i = 1; $i < $size; ++$i) {
if ($max_value < $arr[$i]) {
$max_value = $arr[$i];
}
if ($min_value > $arr[$i]) {
$min_value = $arr[$i];
}
}
if ($min_value < 0 && -$min_value > $max_value) {
$max_value = -$min_value;
}
return $max_value;
}
//Display array elements
public function display($arr, $size) {
for ($i = 0; $i < $size; ++$i) {
echo(" ". $arr[$i]);
}
echo("\n");
}
public function run_sort(&$arr, $slot, $auxiliary, $size, $mod) {
//set initial slot values
for ($i = 0; $i < 10; ++$i) {
$slot[$i] = 0;
}
for ($i = 0; $i < $size; ++$i) {
if ($arr[$i] < 0) {
echo("\nThis Algorithm are not capable to work to negative numbers\n");
return;
}
//set slot element
$slot[(intval($arr[$i] / $mod)) % 10]++;
}
//update slot
for ($i = 1; $i < 10; ++$i) {
$slot[$i] += $slot[$i - 1];
}
for ($i = $size - 1; $i >= 0; --$i) {
$auxiliary[$slot[(intval($arr[$i] / $mod)) % 10] - 1] = $arr[$i];
$slot[(intval($arr[$i] / $mod)) % 10]--;
}
//Assign value of actual array
for ($i = 0; $i < $size; ++$i) {
$arr[$i] = $auxiliary[$i];
}
}
public function radix_sort(&$arr, $size) {
//Get the maximum element of array
$max_value = $this->maximum_element($arr, $size);
$mod = 1;
//allocated slot of 0 - 9 for positive number
$slot = array_fill(0, 10, 0);
//Allocate auxiliary space to perform radix sort
$auxiliary = array_fill(0, $size, 0);
while ($max_value != 0) {
$this->run_sort($arr, $slot, $auxiliary, $size, $mod);
$mod = $mod *10;
//remove last digit
$max_value = intval($max_value / 10);
}
}
}
function main() {
$obj = new MySort();
//Define array elements
$arr = array(8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52);
//Get the size of array
$size = count($arr);
echo("Before Sort : \n");
$obj->display($arr, $size);
$obj->radix_sort($arr, $size);
echo("After Sort : \n");
$obj->display($arr, $size);
}
main();
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
Node Js Program
Radix sort example
*/
class MySort {
//Return maximum element in given array
maximum_element(arr, size) {
var max_value = arr[0];
var min_value = arr[0];
for (var i = 1; i < size; ++i) {
if (max_value < arr[i]) {
max_value = arr[i];
}
if (min_value > arr[i]) {
min_value = arr[i];
}
}
if (min_value < 0 && -min_value > max_value) {
max_value = -min_value;
}
return max_value;
}
//Display array elements
display(arr, size) {
for (var i = 0; i < size; ++i) {
process.stdout.write(" " + arr[i]);
}
process.stdout.write("\n");
}
run_sort(arr, slot, auxiliary, size, mod) {
//set initial slot values
for (var i = 0; i < 10; ++i) {
slot[i] = 0;
}
for (var i = 0; i < size; ++i) {
if (arr[i] < 0) {
process.stdout.write("\nThis Algorithm are not capable to work to negative numbers\n");
return;
}
//set slot element
slot[(parseInt(arr[i] / mod)) % 10]++;
}
//update slot
for (var i = 1; i < 10; ++i) {
slot[i] += slot[i - 1];
}
for (var i = size - 1; i >= 0; --i) {
auxiliary[slot[(parseInt(arr[i] / mod)) % 10] - 1] = arr[i];
slot[(parseInt(arr[i] / mod)) % 10]--;
}
//Assign value of actual array
for (var i = 0; i < size; ++i) {
arr[i] = auxiliary[i];
}
}
radix_sort(arr, size) {
//Get the maximum element of array
var max_value = this.maximum_element(arr, size);
var mod = 1;
//allocated slot of 0 - 9 for positive number
var slot = Array(10).fill(0);
//Allocate auxiliary space to perform radix sort
var auxiliary = Array(size).fill(0);
while (max_value != 0) {
this.run_sort(arr, slot, auxiliary, size, mod);
mod = mod *10;
//remove last digit
max_value = parseInt(max_value / 10);
}
}
}
function main(args) {
var obj = new MySort();
//Define array elements
var arr = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52];
//Get the size of array
var size = arr.length;
process.stdout.write("Before Sort : \n");
obj.display(arr, size);
obj.radix_sort(arr, size);
process.stdout.write("After Sort : \n");
obj.display(arr, size);
}
main();
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
# Python 3 Program
# Radix sort example
class MySort :
# Return maximum element in given array
def maximum_element(self, arr, size) :
max_value = arr[0]
min_value = arr[0]
i = 1
while (i < size) :
if (max_value < arr[i]) :
max_value = arr[i]
if (min_value > arr[i]) :
min_value = arr[i]
i += 1
if (min_value < 0 and - min_value > max_value) :
max_value = -min_value
return max_value
# Display array elements
def display(self, arr, size) :
i = 0
while (i < size) :
print(" ", arr[i], end = "")
i += 1
print("\n", end = "")
def run_sort(self, arr, slot, auxiliary, size, mod) :
# set initial slot values
i = 0
while (i < 10) :
slot[i] = 0
i += 1
i = 0
while (i < size) :
if (arr[i] < 0) :
print("\nThis Algorithm are not capable to work to negative numbers\n", end = "")
return
# set slot element
slot[(int(arr[i] / mod)) % 10] += 1
i += 1
# update slot
i = 1
while (i < 10) :
slot[i] += slot[i - 1]
i += 1
i = size - 1
while (i >= 0) :
auxiliary[slot[(int(arr[i] / mod)) % 10] - 1] = arr[i]
slot[(int(arr[i] / mod)) % 10] -= 1
i -= 1
# Assign value of actual array
i = 0
while (i < size) :
arr[i] = auxiliary[i]
i += 1
def radix_sort(self, arr, size) :
max_value = self.maximum_element(arr, size)
mod = 1
slot = [0] * 10
auxiliary = [0] * size
while (max_value != 0) :
self.run_sort(arr, slot, auxiliary, size, mod)
mod = mod * 10
# remove last digit
max_value = int(max_value / 10)
def main() :
obj = MySort()
arr = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52]
size = len(arr)
print("Before Sort : \n", end = "")
obj.display(arr, size)
obj.radix_sort(arr, size)
print("After Sort : \n", end = "")
obj.display(arr, size)
if __name__ == "__main__":
main()
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
# Ruby Program
# Radix sort example
class MySort
# Return maximum element in given array
def maximum_element(arr, size)
max_value = arr[0]
min_value = arr[0]
i = 1
while (i < size)
if (max_value < arr[i])
max_value = arr[i]
end
if (min_value > arr[i])
min_value = arr[i]
end
i += 1
end
if (min_value < 0 && -min_value > max_value)
max_value = -min_value
end
return max_value
end
# Display array elements
def display(arr, size)
i = 0
while (i < size)
print(" ", arr[i])
i += 1
end
print("\n")
end
def run_sort(arr, slot, auxiliary, size, mod)
# set initial slot values
i = 0
while (i < 10)
slot[i] = 0
i += 1
end
i = 0
while (i < size)
if (arr[i] < 0)
print("\nThis Algorithm are not capable to work to negative numbers\n")
return
end
# set slot element
slot[(arr[i] / mod) % 10] += 1
i += 1
end
# update slot
i = 1
while (i < 10)
slot[i] += slot[i - 1]
i += 1
end
i = size - 1
while (i >= 0)
auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i]
slot[(arr[i] / mod) % 10] -= 1
i -= 1
end
# Assign value of actual array
i = 0
while (i < size)
arr[i] = auxiliary[i]
i += 1
end
end
def radix_sort(arr, size)
max_value = self.maximum_element(arr, size)
mod = 1
slot = Array.new(10, 0)
auxiliary = Array.new(size, 0)
while (max_value != 0)
self.run_sort(arr, slot, auxiliary, size, mod)
mod = mod * 10
# remove last digit
max_value /= 10
end
end
end
def main()
obj = MySort.new()
arr = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52]
size = arr.length
print("Before Sort :\n")
obj.display(arr, size)
obj.radix_sort(arr, size)
print("After Sort :\n")
obj.display(arr, size)
end
main()
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
Scala Program
Radix sort example
*/
class MySort {
//Return maximum element in given array
def maximum_element(arr: Array[Int], size: Int): Int = {
var max_value: Int = arr(0);
var min_value: Int = arr(0);
var i: Int = 1;
while (i < size) {
if (max_value < arr(i)) {
max_value = arr(i);
}
if (min_value > arr(i)) {
min_value = arr(i);
}
i += 1;
}
if (min_value < 0 && -min_value > max_value) {
max_value = -min_value;
}
return max_value;
}
//Display array elements
def display(arr: Array[Int], size: Int): Unit = {
var i: Int = 0;
while (i < size) {
print(" " + arr(i));
i += 1;
}
print("\n");
}
def run_sort(arr: Array[Int], slot: Array[Int], auxiliary: Array[Int], size: Int, mod: Int): Unit = {
//set initial slot values
var i: Int = 0;
while (i < 10) {
slot(i) = 0;
i += 1;
}
i = 0;
while (i < size) {
if (arr(i) < 0) {
print("\nThis Algorithm are not capable to work to negative numbers\n");
return;
}
//set slot element
slot(((arr(i) / mod).toInt) % 10) += 1;
i += 1;
}
//update slot
i = 1;
while (i < 10) {
slot(i) += slot(i - 1);
i += 1;
}
i = size - 1;
while (i >= 0) {
auxiliary(slot(((arr(i) / mod).toInt) % 10) - 1) = arr(i);
slot(((arr(i) / mod).toInt) % 10) -= 1;
i -= 1;
}
//Assign value of actual array
i = 0;
while (i < size) {
arr(i) = auxiliary(i);
i += 1;
}
}
def radix_sort(arr: Array[Int], size: Int): Unit = {
var max_value: Int = this.maximum_element(arr, size);
var mod: Int = 1;
val slot: Array[Int] = Array.fill[Int](10)(0);
val auxiliary: Array[Int] = Array.fill[Int](size)(0);
while (max_value != 0) {
this.run_sort(arr, slot, auxiliary, size, mod);
mod = mod * 10;
//remove last digit
max_value = (max_value / 10).toInt;
}
}
}
object Main {
def main(args: Array[String]): Unit = {
val obj: MySort = new MySort();
var arr: Array[Int] = Array(8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52);
val size: Int = arr.length;
print("Before Sort : \n");
obj.display(arr, size);
obj.radix_sort(arr, size);
print("After Sort : \n");
obj.display(arr, size);
}
}
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
/*
Swift Program
Radix sort example
*/
class MySort {
//Return maximum element in given array
func maximum_element(_ arr: [Int], _ size: Int) -> Int {
var max_value: Int = arr[0];
var min_value: Int = arr[0];
var i: Int = 1;
while (i < size) {
if (max_value < arr[i]) {
max_value = arr[i];
}
if (min_value > arr[i]) {
min_value = arr[i];
}
i += 1;
}
if (min_value < 0 && -min_value > max_value) {
max_value = -min_value;
}
return max_value;
}
//Display array elements
func display(_ arr: [Int], _ size: Int) {
var i: Int = 0;
while (i < size) {
print(" ", arr[i], terminator: "");
i += 1;
}
print("\n", terminator: "");
}
func run_sort(_ arr: inout [Int], _ slot: inout [Int], _ auxiliary: inout [Int], _ size: Int, _ mod: Int) {
//set initial slot values
var i: Int = 0;
while (i < 10) {
slot[i] = 0;
i += 1;
}
i = 0;
while (i < size) {
if (arr[i] < 0) {
print("\nThis Algorithm are not capable to work to negative numbers\n", terminator: "");
return;
}
//set slot element
slot[(arr[i] / mod) % 10] += 1;
i += 1;
}
//update slot
i = 1;
while (i < 10) {
slot[i] += slot[i - 1];
i += 1;
}
i = size - 1;
while (i >= 0) {
auxiliary[slot[(arr[i] / mod) % 10] - 1] = arr[i];
slot[(arr[i] / mod) % 10] -= 1;
i -= 1;
}
//Assign value of actual array
i = 0;
while (i < size) {
arr[i] = auxiliary[i];
i += 1;
}
}
func radix_sort(_ arr: inout [Int], _ size: Int) {
var max_value: Int = self.maximum_element(arr, size);
var mod: Int = 1;
var slot: [Int] = Array(repeating: 0, count: 10);
var auxiliary: [Int] = Array(repeating: 0, count: size);
while (max_value != 0) {
self.run_sort(&arr, &slot, &auxiliary, size, mod);
mod = mod * 10;
//remove last digit
max_value /= 10;
}
}
}
func main() {
let obj: MySort = MySort();
var arr: [Int] = [8, 2, 3, 8, 1, 3, 73, 121, 54, 23, 84, 13, 67, 23, 52];
let size: Int = arr.count;
print("Before Sort : \n", terminator: "");
obj.display(arr, size);
obj.radix_sort(&arr, size);
print("After Sort : \n", terminator: "");
obj.display(arr, size);
}
main();
Output
Before Sort :
8 2 3 8 1 3 73 121 54 23 84 13 67 23 52
After Sort :
1 2 3 3 8 8 13 23 23 52 54 67 73 84 121
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