Given an array arr[] that contains N real numbers. The task is to sort the array in decreasing order of the Fractional Values
Note: If the values of the fractional part are same then sort those elements in Decreasing order of their Integer Values.
Examples:
Input: arr[] = { 8.33, -3.85, 1.999, 6.33, 5}
Output: { 1.999, 8.33, 6.33, -3.85 , 5}
Explanation:
Element Integer Value Fraction Value 8.33
8
0.33
-3.85
-4
0.15
1.999
1
0.999
6.33
6
0.33
5
5
0.0
1.999 has the biggest fractional value so it will be at index 0 while 5 has the lowest fractional value so it will be at the last index.
6.33 and 8.33 have the same fractional values but the Integer part of 8.33 is greater than 6.33 so we place 8.33 before 6.33 as the given condition in the problem statement.Fractional value = Given number – Integer Value.
Fractional Value of positive value e.g. (8.33) = 8.33 – Integer Value of ( 8.33)= 8.33 – 8= 0.33
Fractional Value of (-3.85) = -3.85- Integer Value of (-3.85)= -3.85 – ( -4 ) = -3.85 + 4 = 0.15Hence, the order for the above example will be: {1.999, 8.33, 6.33, -3.85, 5}
Input: arr[] = { 1.1, 1.11, 1.111, 2.1, 2.11, 2.111}
Output: { 2.111, 1.111, 2.11, 1.11, 2.1, 1.1 }
Explanation: Here the biggest fractional value is 0.111 which is present in both 2.111 and 1.111. But the integer value of 2.111 is greater than 1.111. so, 2.111 will come before 1.111. The same applies to other elements.
Naive Approach: The basic idea to solve the problem is to store the pair of {Fractional value, Integer value} in a vector and then sort the vector in descending order of fractional part. Lastly reverse the vector for the final answer as the desired answer should be in descending order.
Below is the implementation of the above approach:
// C++ program to sort Array // in descending order of fractional value #include <bits/stdc++.h> using namespace std;
// Function to sort the fractional part void SortFraction( long double arr[], int n)
{ // To store fraction and it's
// corresponding integer and the
// original element
vector<pair<pair< long double , int >,
long double > >
v;
for ( int i = 0; i < n; i++) {
// Calculate fractional value
long double fraction
= arr[i] - floorl(arr[i]);
// Calculate integer value
int integer = floorl(arr[i]);
v.push_back({ make_pair(fraction,
integer),
arr[i] });
}
// Sort the vector
sort(v.begin(), v.end());
// To get final answer,
// reverse the vector
reverse(v.begin(), v.end());
// To print output
for ( int i = 0; i < n; i++)
cout << v[i].second << " " ;
} // Driver Code int main()
{ long double arr[] = { 8.33, -3.85,
1.999, 6.33, 5 };
// Size of array
int N = sizeof (arr) / sizeof (arr[0]);
// Sort in descending order
// of fractional value
SortFraction(arr, N);
return 0;
} |
import java.util.*;
import java.io.*;
class GFG{
// Function to sort the fractional part
public static void SortFraction( double arr[], int n){
// To store fraction and it's
// corresponding integer and the
// original element
ArrayList<ArrayList<Double>> v = new ArrayList<ArrayList<Double>>();
for ( int i= 0 ; i<n ; i++){
// Calculate fractional value
double fraction = arr[i]-Math.floor(( double )arr[i]);
// Calculate integer value
double integer = Math.floor(( double )arr[i]);
ArrayList<Double> temp = new ArrayList<Double>();
temp.add(fraction);
temp.add(integer);
temp.add(arr[i]);
v.add(temp);
}
// Sort the vector
Collections.sort(v, new Comp());
// To get final answer,
// reverse the vector
Collections.reverse(v);
// To print output
for ( int i= 0 ; i<n ; i++){
System.out.print(v.get(i).get( 2 ) + " " );
}
}
// Driver code
public static void main(String args[])
{
// Size of array
int N = 5 ;
double arr[] = { 8.33 , - 3.85 , 1.999 , 6.33 , 5 };
// Sort in descending order
// of fractional value
SortFraction(arr, N);
}
} class Comp implements Comparator<ArrayList<Double>>{
public int compare(ArrayList<Double> a, ArrayList<Double> b){
for ( int i= 0 ; i< 2 ; i++){
if (a.get(i).equals(b.get(i))){
continue ;
}
return a.get(i).compareTo(b.get(i));
}
return a.get( 2 ).compareTo(b.get( 2 ));
}
}; // This code is contributed by subhamgoyal2014. |
# Python program to sort Array # in descending order of fractional value import math
# Function to sort the fractional part def SortFraction (arr, n) :
# To store fraction and it's
# corresponding integer and the
# original element
v = []
for i in range (n) :
# Calculate fractional value
fraction = arr[i] - math.floor(arr[i])
# Calculate integer value
integer = math.floor(arr[i])
v.append([[fraction, integer], arr[i]])
# Sort the vector
v.sort()
# To get final answer,
# reverse the vector
v.reverse()
# To print output
for i in range (n) :
print (v[i][ 1 ],end = ' ' )
# Driver Code if __name__ = = "__main__" :
arr = [ 8.33 , - 3.85 , 1.999 , 6.33 , 5 ]
# Size of array
N = len (arr)
# Sort in descending order
# of fractional value
SortFraction(arr, N)
# This code is contributed by jana_sayantan.
|
// C# code using System;
using System.Collections.Generic;
class Program {
// Function to sort the fractional part
public static void SortFraction( double [] arr, int n){
// To store fraction and it's
// corresponding integer and the
// original element
List<List< double >> v = new List<List< double >>();
for ( int i=0 ; i<n ; i++){
// Calculate fractional value
double fraction = arr[i]-Math.Floor(( double )arr[i]);
// Calculate integer value
double integer = Math.Floor(( double )arr[i]);
List< double > temp = new List< double >();
temp.Add(fraction);
temp.Add(integer);
temp.Add(arr[i]);
v.Add(temp);
}
// Sort the list
v.Sort( new Comp());
// To get final answer,
// reverse the list
v.Reverse();
// To print output
foreach ( var item in v){
Console.Write(item[2]+ " " );
}
}
// Driver code
public static void Main( string [] args){
// Size of array
int N = 5;
double [] arr = {8.33, -3.85, 1.999, 6.33, 5};
// Sort in descending order
// of fractional value
SortFraction(arr, N);
}
} class Comp : IComparer<List< double >>{
public int Compare(List< double > a, List< double > b){
for ( int i=0 ; i<2 ; i++){
if (a[i].Equals(b[i])){
continue ;
}
return a[i].CompareTo(b[i]);
}
return a[2].CompareTo(b[2]);
}
}; // This code is contributed by Utkarsh |
<script> // JavaScript program to sort Array
// in descending order of fractional value
// Function to sort the fractional part
const SortFraction = (arr, n) => {
// To store fraction and it's
// corresponding integer and the
// original element
let v = [];
for (let i = 0; i < n; i++) {
// Calculate fractional value
let fraction = arr[i] - Math.floor(arr[i]);
// Calculate integer value
let integer = Math.floor(arr[i]);
v.push([[fraction, integer], arr[i]]);
}
// Sort the vector
v.sort();
// To get final answer,
// reverse the vector
v.reverse();
// To print output
for (let i = 0; i < n; i++)
document.write(`${v[i][1]} `);
}
// Driver Code
let arr = [8.33, -3.85, 1.999, 6.33, 5];
// Size of array
let N = arr.length;
// Sort in descending order
// of fractional value
SortFraction(arr, N);
// This code is contributed by rakeshsahni </script> |
1.999 8.33 6.33 -3.85 5
Time Complexity: O(N * logN)
Auxiliary Space: O(N)
Efficient Approach: The idea to solve the problem in optimized way is by using Comparator, to sort the vector.
Follow the steps to solve the problem:
- Firstly, make a comparator function to sort the array according to the requirements given in the problem.
- Return true if fraction of a > fraction of b, to sort the elements in decreasing order of the fractional Values.
- If fraction of a = fraction of b then return true if integer of a > integer of b
- Return False in every other case.
- The final array is the required sorted array.
Below is the implementation of the above approach:
// C++ program to sort Array // in descending order of fractional value #include <bits/stdc++.h> using namespace std;
// Comparator to sort array // according to question bool comp( long double a, long double b)
{ int int_a = floorl(a);
int int_b = floorl(b);
long double fraction_a = a - int_a;
long double fraction_b = b - int_b;
if (fraction_a > fraction_b)
return true ;
if (fraction_a == fraction_b) {
if (int_a > int_b)
return true ;
else
return false ;
}
return false ;
} // Function to print answer void print( long double arr[], int n)
{ // Sort in descending order of
// fractional value pass comp to sort
sort(arr, arr + n, comp);
for ( int i = 0; i < n; i++)
cout << arr[i] << " " ;
} // Driver Code int main()
{ long double arr[]
= { 8.33, -3.85, 1.999, 6.33, 5 };
// Size of arr
int N = sizeof (arr) / sizeof (arr[0]);
print(arr, N);
return 0;
} |
// Java program to sort Array // in descending order of fractional value import java.util.Arrays;
import java.util.Comparator;
public class Main
{ // Comparator to sort array
// according to question
static class FractionalComparator implements Comparator<Double> {
@Override
public int compare(Double a, Double b) {
int int_a = ( int ) Math.floor(a);
int int_b = ( int ) Math.floor(b);
double fraction_a = a - int_a;
double fraction_b = b - int_b;
if (fraction_a > fraction_b) {
return - 1 ;
}
if (fraction_a == fraction_b) {
if (int_a > int_b) {
return - 1 ;
} else {
return 1 ;
}
}
return 1 ;
}
}
// Driver Code
public static void main(String[] args) {
Double[] arr = { 8.33 , - 3.85 , 1.999 , 6.33 , 5.0 };
// Sort in descending order of
// fractional value pass comp to sort
Arrays.sort(arr, new FractionalComparator());
// Function to print answer
for (Double number : arr) {
System.out.print(number + " " );
}
}
} // This code is contributed by ratiagrawal. |
# Python program to sort Array # in descending order of fractional value import math
from functools import cmp_to_key
# Comparator to sort array # according to question from functools import cmp_to_key
def comp(a, b):
int_a = math.floor(a)
int_b = math.floor(b)
fraction_a = a - int_a
fraction_b = b - int_b
if (fraction_a > fraction_b):
return 1
if (fraction_a = = fraction_b):
if (int_a > int_b):
return 1
else :
return - 1
return - 1
# Function to print answer def Print (arr,n):
# Sort in descending order of
# fractional value pass comp to sort
b = sorted (arr,key = cmp_to_key(comp),reverse = True )
for i in range (n):
print (b[i],end = ' ' )
# Driver Code if __name__ = = "__main__" :
arr = [ 8.33 , - 3.85 , 1.999 , 6.33 , 5 ]
# Size of array
N = len (arr)
Print (arr,N)
# This code is contributed by Pushpesh Raj. |
using System;
using System.Collections.Generic;
public class Program
{ // Comparator to sort array
// according to question
class FractionalComparator : IComparer< double >
{
public int Compare( double a, double b)
{
int int_a = ( int )Math.Floor(a);
int int_b = ( int )Math.Floor(b);
double fraction_a = a - int_a;
double fraction_b = b - int_b;
if (fraction_a > fraction_b)
{
return -1;
}
if (fraction_a == fraction_b)
{
if (int_a > int_b)
{
return -1;
}
else
{
return 1;
}
}
return 1;
}
}
// Main method
static void Main( string [] args)
{
Double[] arr = { 8.33, -3.85, 1.999, 6.33, 5.0 };
// Sort in descending order of
// fractional value pass comp to sort
Array.Sort(arr, new FractionalComparator());
// Function to print answer
for ( int i = 0; i < arr.Length; i++)
{
Console.Write(arr[i] + " " );
}
}
} // This code is contributed by lokeshpotta20. |
function comp(a, b) {
const int_a = Math.floor(a);
const int_b = Math.floor(b);
const fraction_a = a - int_a;
const fraction_b = b - int_b;
if (fraction_a > fraction_b) {
return 1;
}
if (fraction_a === fraction_b) {
if (int_a > int_b) {
return 1;
} else {
return -1;
}
}
return -1;
} function Print(arr, n) {
// Sort in descending order of fractional value
// pass comp to sort
const b = arr.sort(comp).reverse();
for (let i = 0; i < n; i++) {
console.log(b[i] + " " );
}
} const arr = [8.33, -3.85, 1.999, 6.33, 5]; // Size of array const N = arr.length; Print(arr, N); |
1.999 8.33 6.33 -3.85 5
Time Complexity: O(N * logN)
Auxiliary Space: O(1)