Sort the sides of triangle on the basis of increasing area
Given an array arr[] of sides of N triangles, the task is to sort the given sides of triangles on the basis of the increasing order of area.
Examples:
Input: arr[] = {{5, 3, 7}, {15, 20, 4}, {4, 9, 6}, {8, 4, 5}}
Output: {{5, 3, 7}, {8, 4, 5}, {4, 9, 6}, {15, 20, 17}}
Explanation:
Following are the areas of triangle:
- Area of 1st triangle (5, 3, 7) is 6.4.
- Area of 2nd triangle (15, 20, 4) is 124.2.
- Area of 3rd triangle (4, 9, 6) is 9.5.
- Area of 4th triangle (8, 4, 5) is 8.1.
Therefore, ordering them increasing order of the area modifies the given array as 6.4 {5, 3, 7}, 8.1 {8, 4, 5}, 9.5 {4, 9, 6}, 124.2 {15, 20, 4}.
Input: arr[] = {{7, 24, 25}, {5, 12, 13}, {3, 4, 5}}
Output: {{3, 4, 5}, {5, 12, 13}, {7, 24, 25}}
Approach: The given can be solved by storing the sides with the area of the triangle in another array and then sort the array in increasing order of area stored and then print the sides stored in another array as the result.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void rearrangeTriangle(
vector<vector< int > > arr, int N)
{
vector<pair< float , int > > area;
for ( int i = 0; i < N; i++) {
float a = (arr[i][0]
+ arr[i][1]
+ arr[i][2])
/ 2.0;
float Area = sqrt ( abs (a * (a - arr[i][0])
* (a - arr[i][1])
* (a - arr[i][2])));
area.push_back({ Area, i });
}
sort(area.begin(), area.end());
for ( int i = 0; i < area.size(); i++) {
cout << arr[area[i].second][0]
<< " "
<< arr[area[i].second][1]
<< " "
<< arr[area[i].second][2]
<< '\n' ;
}
}
int main()
{
vector<vector< int > > arr = {
{ 5, 3, 7 }, { 15, 20, 4 }, { 4, 9, 6 }, { 8, 4, 5 }
};
int N = arr.size();
rearrangeTriangle(arr, N);
return 0;
}
|
Java
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
static void rearrangeTriangle(List<List<Integer>> arr, int N)
{
List<Pair<Float, Integer>> area = new ArrayList<>();
for ( int i = 0 ; i < N; i++) {
float a = ( float )(arr.get(i).get( 0 ) + arr.get(i).get( 1 ) + arr.get(i).get( 2 )) / 2 ;
float Area = ( float ) Math.sqrt(Math.abs(a * (a - arr.get(i).get( 0 )) * (a - arr.get(i).get( 1 )) * (a - arr.get(i).get( 2 ))));
area.add( new Pair<>(Area, i));
}
Collections.sort(area, (x, y) -> Float.compare(x.first, y.first));
for ( int i = 0 ; i < area.size(); i++) {
System.out.println(arr.get(area.get(i).second).get( 0 ) + " " + arr.get(area.get(i).second).get( 1 ) + " " + arr.get(area.get(i).second).get( 2 ));
}
}
public static void main(String[] args)
{
List<List<Integer>> arr = new ArrayList<>(){{
add( new ArrayList<>(){{ add( 5 ); add( 3 ); add( 7 ); }});
add( new ArrayList<>(){{ add( 15 ); add( 20 ); add( 4 ); }});
add( new ArrayList<>(){{ add( 4 ); add( 9 ); add( 6 ); }});
add( new ArrayList<>(){{ add( 8 ); add( 4 ); add( 5 ); }});
}};
int N = arr.size();
rearrangeTriangle(arr, N);
}
}
class Pair<F, S> {
public F first;
public S second;
public Pair(F first, S second) {
this .first = first;
this .second = second;
}
}
|
Python3
import math
def rearrangeTriangle(arr, N):
area = []
for i in range ( 0 , N):
a = (arr[i][ 0 ] + arr[i][ 1 ] + arr[i][ 2 ]) / 2.0
Area = math.sqrt(
abs (a * (a - arr[i][ 0 ]) * (a - arr[i][ 1 ]) * (a - arr[i][ 2 ])))
area.append([Area, i])
area.sort()
for i in range ( 0 , len (area)):
print (arr[area[i][ 1 ]][ 0 ], end = " " )
print (arr[area[i][ 1 ]][ 1 ], end = " " )
print (arr[area[i][ 1 ]][ 2 ])
if __name__ = = "__main__" :
arr = [
[ 5 , 3 , 7 ], [ 15 , 20 , 4 ], [ 4 , 9 , 6 ], [ 8 , 4 , 5 ]
]
N = len (arr)
rearrangeTriangle(arr, N)
|
C#
using System;
using System.Collections.Generic;
class GFG {
static void rearrangeTriangle(
List<List< int > > arr, int N)
{
List<KeyValuePair< float , int > > area = new List<KeyValuePair< float , int > >();
for ( int i = 0; i < N; i++) {
float a = ( float )(arr[i][0]
+ arr[i][1]
+ arr[i][2])
/ 2;
float Area = ( float )Math.Sqrt(Math.Abs(a * (a - arr[i][0])
* (a - arr[i][1])
* (a - arr[i][2])));
area.Add( new KeyValuePair < float , int >(Area, i ));
}
area.Sort((x, y) => x.Key.CompareTo(y.Key));
for ( int i = 0; i < area.Count; i++) {
Console.WriteLine(arr[area[i].Value][0] + " "
+ arr[area[i].Value][1]
+ " "
+ arr[area[i].Value][2]);
}
}
static public void Main ()
{
List<List< int > > arr = new List<List< int > >(){
new List< int >(){ 5, 3, 7 },
new List< int >(){ 15, 20, 4 },
new List< int >(){ 4, 9, 6 },
new List< int >(){ 8, 4, 5 }
};
int N = arr.Count;
rearrangeTriangle(arr, N);
}
}
|
Javascript
<script>
function rearrangeTriangle(
arr, N)
{
let area = [];
for (let i = 0; i < N; i++) {
let a = (arr[i][0]
+ arr[i][1]
+ arr[i][2])
/ 2.0;
let Area = Math.sqrt(Math.abs(a * (a - arr[i][0])
* (a - arr[i][1])
* (a - arr[i][2])));
area.push({ first: parseInt(Area), second: parseInt(i) });
}
area.sort( function (a, b) {
return a.first - b.first;
})
for (let i = 0; i < area.length; i++) {
document.write(arr[area[i].second][0]
+ " "
+ arr[area[i].second][1]
+ " "
+ arr[area[i].second][2]
+ '<br>'
)
}
}
let arr = [
[5, 3, 7], [15, 20, 4], [4, 9, 6], [8, 4, 5]
];
let N = arr.length;
rearrangeTriangle(arr, N);
</script>
|
Output:
5 3 7
8 4 5
4 9 6
15 20 4
Time Complexity: O(N*log N)
Auxiliary Space: O(N)
Space Optimized Approach: The above approach can also be optimized in terms of space, the idea is to use the comparator function to sort the given array in increasing order of area. Below is the comparator function that is used:
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
float findArea(vector< int >& arr)
{
float a = (arr[0]
+ arr[1]
+ arr[2])
/ 2.0;
float Area = sqrt ( abs (a * (a - arr[0])
* (a - arr[1])
* (a - arr[2])));
return Area;
}
bool cmp(vector< int >& A, vector< int >& B)
{
return findArea(A) <= findArea(B);
}
void rearrangeTriangle(
vector<vector< int > > arr, int N)
{
sort(arr.begin(), arr.end(), cmp);
for ( int i = 0; i < N; i++) {
cout << arr[i][0] << " " << arr[i][1] << " "
<< arr[i][2] << '\n' ;
}
}
int main()
{
vector<vector< int > > arr = {
{ 5, 3, 7 }, { 15, 20, 4 }, { 4, 9, 6 }, { 8, 4, 5 }
};
int N = arr.size();
rearrangeTriangle(arr, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static double findArea( int [] arr)
{
double a = (arr[ 0 ] + arr[ 1 ] + arr[ 2 ]) / 2.0 ;
double area = Math.sqrt(
Math.abs(a * (a - arr[ 0 ]) * (a - arr[ 1 ])
* (a - arr[ 2 ])));
return area;
}
static int [][] rearrangeTriangle( int [][] arr)
{
Arrays.sort(arr,
(a, b)
-> Double.compare(findArea(a),
findArea(b)));
return arr;
}
public static void main(String[] args)
{
int [][] arr = { { 5 , 3 , 7 },
{ 15 , 20 , 4 },
{ 4 , 9 , 6 },
{ 8 , 4 , 5 } };
int [][] result = rearrangeTriangle(arr);
for ( int i = 0 ; i < result.length; i++) {
System.out.println(result[i][ 0 ] + " "
+ result[i][ 1 ] + " "
+ result[i][ 2 ]);
}
}
}
|
Python3
import math
def findArea(arr):
a = (arr[ 0 ] + arr[ 1 ] + arr[ 2 ]) / 2.0
Area = math.sqrt( abs (a * (a - arr[ 0 ]) * (a - arr[ 1 ]) * (a - arr[ 2 ])))
return Area
def rearrangeTriangle(arr , N):
arr.sort(key = lambda x: (findArea(x)))
for i in range ( 0 ,N):
print (arr[i][ 0 ], arr[i][ 1 ], arr[i][ 2 ])
if __name__ = = "__main__" :
arr = [[ 5 , 3 , 7 ], [ 15 , 20 , 4 ], [ 4 , 9 , 6 ], [ 8 , 4 , 5 ]]
N = len (arr)
rearrangeTriangle(arr, N)
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
class GFG {
static float FindArea(List< int > arr) {
float a = (arr[0] + arr[1] + arr[2]) / 2.0f;
float Area = ( float )Math.Sqrt(Math.Abs(a * (a - arr[0]) * (a - arr[1]) *
(a - arr[2])));
return Area;
}
static int Compare(List< int > A, List< int > B) {
float areaA = FindArea(A);
float areaB = FindArea(B);
if (areaA < areaB) {
return -1;
} else if (areaA > areaB) {
return 1;
} else {
return 0;
}
}
static void RearrangeTriangle(List<List< int >> arr, int N) {
arr.Sort(Compare);
for ( int i = 0; i < N; i++) {
Console.Write( "{0} {1} {2}" , arr[i][0], arr[i][1], arr[i][2]+ "\n" );
}
}
static void Main() {
List<List< int >> arr = new List<List< int >> {
new List< int > { 5, 3, 7 },
new List< int > { 15, 20, 4 },
new List< int > { 4, 9, 6 },
new List< int > { 8, 4, 5 }
};
int N = arr.Count();
RearrangeTriangle(arr, N);
}
}
|
Javascript
<script>
function findArea(arr)
{
let a = (arr[0] + arr[1] + arr[2]) / 2.0;
let Area = Math.sqrt(Math.abs(a * (a - arr[0]) * (a - arr[1])* (a - arr[2])));
return Area;
}
function cmp(A, B)
{
return findArea(A) - findArea(B);
}
function rearrangeTriangle(arr, N)
{
arr.sort( function (a, b) {
return cmp(a,b);
})
for (let i = 0; i < N; i++) {
document.write(arr[i][0]
+ " "
+ arr[i][1]
+ " "
+ arr[i][2]
+ '<br>'
)
}
}
let arr = [
[5, 3, 7], [15, 20, 4], [4, 9, 6], [8, 4, 5]
];
let N = arr.length;
rearrangeTriangle(arr, N);
</script>
|
Output:
5 3 7
8 4 5
4 9 6
15 20 4
Time Complexity: O(N*log N)
Auxiliary Space: O(1)
Last Updated :
30 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...