Given an array arr[] of N non-negative integers, the task is to sort these integers according to their reverse.
Examples:
Input: arr[] = {12, 10, 102, 31, 15}
Output: 10 31 12 15 102
Reversing the numbers:
12 -> 21
10 -> 01
102 -> 201
31 -> 13
15 -> 51
Sorting the reversed numbers: 01 13 21 51 201
Original sorted array: 10 13 12 15 102Input: arr[] = {12, 10}
Output: 10 12
Approach: The idea is to store each element with its reverse in a vector pair and then sort all the elements of the vector according to the reverse stored. Finally, print the elements in order.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the // reverse of n int reverseDigits( int num)
{ int rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
} // Function to sort the array according to // the reverse of elements void sortArr( int arr[], int n)
{ // Vector to store the reverse
// with respective elements
vector<pair< int , int > > vp;
// Inserting reverse with elements
// in the vector pair
for ( int i = 0; i < n; i++) {
vp.push_back(
make_pair(reverseDigits(arr[i]),
arr[i]));
}
// Sort the vector, this will sort the pair
// according to the reverse of elements
sort(vp.begin(), vp.end());
// Print the sorted vector content
for ( int i = 0; i < vp.size(); i++)
cout << vp[i].second << " " ;
} // Driver code int main()
{ int arr[] = { 12, 10, 102, 31, 15 };
int n = sizeof (arr) / sizeof (arr[0]);
sortArr(arr, n);
return 0;
} |
// Java implementation of the approach import java.util.*;
import java.lang.*;
import java.io.*;
class GFG{
// Function to return the // reverse of n static int reverseDigits( int num)
{ int rev_num = 0 ;
while (num > 0 )
{
rev_num = rev_num * 10 + num % 10 ;
num = num / 10 ;
}
return rev_num;
} // Function to sort the array according // to the reverse of elements static void sortArr( int arr[], int n)
{ // Vector to store the reverse
// with respective elements
ArrayList< int []> vp = new ArrayList<>();
// Inserting reverse with elements
// in the vector pair
for ( int i = 0 ; i < n; i++)
{
vp.add( new int []{reversDigits(arr[i]),
arr[i]});
}
// Sort the vector, this will sort the pair
// according to the reverse of elements
Collections.sort(vp, (a, b) -> a[ 0 ] - b[ 0 ]);
// Print the sorted vector content
for ( int i = 0 ; i < vp.size(); i++)
System.out.print(vp.get(i)[ 1 ] + " " );
} // Driver code public static void main(String[] args)
{ int arr[] = { 12 , 10 , 102 , 31 , 15 };
int n = arr.length;
sortArr(arr, n);
} } // This code is contributed by offbeat |
# Python3 implementation of the approach # Function to return the # reverse of n def reverseDigits(num) :
rev_num = 0 ;
while (num > 0 ) :
rev_num = rev_num * 10 + num % 10 ;
num = num / / 10 ;
return rev_num;
# Function to sort the array according to # the reverse of elements def sortArr(arr, n) :
# Vector to store the reverse
# with respective elements
vp = [];
# Inserting reverse with elements
# in the vector pair
for i in range (n) :
vp.append((reversDigits(arr[i]),arr[i]));
# Sort the vector, this will sort the pair
# according to the reverse of elements
vp.sort()
# Print the sorted vector content
for i in range ( len (vp)) :
print (vp[i][ 1 ],end = " " );
# Driver code if __name__ = = "__main__" :
arr = [ 12 , 10 , 102 , 31 , 15 ];
n = len (arr);
sortArr(arr, n);
# This code is contributed by AnkitRai01 |
// C# implementation of the approach using System;
using System.Collections.Generic;
class GFG
{ // Function to return the
// reverse of n
static int reverseDigits( int num)
{
int rev_num = 0;
while (num > 0)
{
rev_num = rev_num * 10 + num % 10;
num = num / 10;
}
return rev_num;
}
// Function to sort the array according to
// the reverse of elements
static void sortArr( int [] arr, int n)
{
// Vector to store the reverse
// with respective elements
List<Tuple< int , int >> vp = new List<Tuple< int , int >>();
// Inserting reverse with elements
// in the vector pair
for ( int i = 0; i < n; i++)
{
vp.Add( new Tuple< int , int >(reversDigits(arr[i]),arr[i]));
}
// Sort the vector, this will sort the pair
// according to the reverse of elements
vp.Sort();
// Print the sorted vector content
for ( int i = 0; i < vp.Count; i++)
Console.Write(vp[i].Item2 + " " );
}
// Driver code
static void Main()
{
int [] arr = { 12, 10, 102, 31, 15 };
int n = arr.Length;
sortArr(arr, n);
}
} // This code is contributed by divyesh072019 |
<script> // Javascript implementation of the // above approach // Function to return the // reverse of n function reverseDigits(num)
{ var rev_num = 0;
while (num > 0) {
rev_num = rev_num * 10 + num % 10;
num = Math.floor(num / 10);
}
return rev_num;
} // Function to sort the array according to // the reverse of elements function sortArr(arr, n)
{ // Vector to store the reverse
// with respective elements
var vp = new Array(n);
for ( var i = 0; i < n; i++) {
vp[i] = [];
}
// Inserting reverse with elements
// in the vector pair
for ( var i = 0; i < n; i++) {
var pair = [];
pair.push(reversDigits(arr[i]));
pair.push(arr[i]);
vp[i] = pair;
}
// Sort the vector, this will sort the pair
// according to the reverse of elements
vp = vp.sort( function (a,b) {
return a[0] - b[0];
});
// Print the sorted vector content
for ( var i = 0; i < n; i++){
document.write(vp[i][1] + " " );
}
} // Driver code var arr = [ 12, 10, 102, 31, 15 ];
var n = arr.length;
sortArr(arr, n); // This code is contributed by Shivanisingh </script> |
Output:
10 31 12 15 102
Time Complexity:
Auxiliary Space: O(N)