Check if elements of array can be arranged in AP, GP or HP
Last Updated :
29 Nov, 2021
Given an array arr[] of N integers. The task is to check whether by arranging the elements of the array, is it possible to generate an Arithmetic Progression, Geometric Progression or Harmonic Progression. If possible print “Yes”, with the type of Progression or Else print “No”.
Examples:
Input: arr[] = {2, 16, 4, 8}
Output: Yes, A GP can be formed
Explanation:
Rearrange given array as {2, 4, 8, 16}, forms a Geometric Progression with common ratio 2.
Input: arr[] = {15, 10, 15, 5}
Output: Yes, An AP can be formed
Explanation:
Rearrange given array as {5, 10, 15, 20}, forms Arithmetic Progression with common difference 5.
Input: arr[] = { 1.0/10.0, 1.0/5.0, 1.0/15.0, 1.0/20.0 }
Output: Yes, A HP can be formed
Explanation:
Rearrange given array as { 1.0/5.0, 1.0/10.0, 1.0/15.0, 1.0/20.0 }, forms a Harmonic Progression.
Approach: The idea is to observe that elements in any of the three progressions A.P., G.P. or H.P. are somewhat related to sorted order. So, we need to first sort the given array.
- For Arithmetic Progression: Check if the difference between the consecutive elements of the sorted array are same or not. If Yes then given array element forms an Arithmetic Progression.
- For Geometric Progression: Check if the ratio of the consecutive elements of the sorted array are same or not. If Yes then given array element forms a Geometric Progression.
- For Harmonic Progression: Check if the difference between the reciprocal of all the consecutive elements of the sorted array are same or not. If Yes then given array element forms a Harmonic Progression.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool checkIsAP( double arr[], int n)
{
if (n == 1)
return true ;
sort(arr, arr + n);
double d = arr[1] - arr[0];
for ( int i = 2; i < n; i++) {
if (arr[i] - arr[i - 1] != d) {
return false ;
}
}
return true ;
}
bool checkIsGP( double arr[], int n)
{
if (n == 1)
return true ;
sort(arr, arr + n);
double r = arr[1] / arr[0];
for ( int i = 2; i < n; i++) {
if (arr[i] / arr[i - 1] != r)
return false ;
}
return true ;
}
bool checkIsHP( double arr[], int n)
{
if (n == 1) {
return true ;
}
double rec[n];
for ( int i = 0; i < n; i++) {
rec[i] = ((1 / arr[i]));
}
if (checkIsAP(rec, n))
return true ;
else
return false ;
}
int main()
{
double arr[] = { 1.0 / 5.0, 1.0 / 10.0,
1.0 / 15.0, 1.0 / 20.0 };
int n = sizeof (arr) / sizeof (arr[0]);
int flag = 0;
if (checkIsAP(arr, n)) {
cout << "Yes, An AP can be formed"
<< endl;
flag = 1;
}
if (checkIsGP(arr, n)) {
cout << "Yes, A GP can be formed"
<< endl;
flag = 1;
}
if (checkIsHP(arr, n)) {
cout << "Yes, A HP can be formed"
<< endl;
flag = 1;
}
else if (flag == 0) {
cout << "No" ;
}
return 0;
}
|
Java
import java.util.*;
class GFG{
static boolean checkIsAP( double arr[], int n)
{
if (n == 1 )
return true ;
Arrays.sort(arr);
double d = arr[ 1 ] - arr[ 0 ];
for ( int i = 2 ; i < n; i++) {
if (arr[i] - arr[i - 1 ] != d) {
return false ;
}
}
return true ;
}
static boolean checkIsGP( double arr[], int n)
{
if (n == 1 )
return true ;
Arrays.sort(arr);
double r = arr[ 1 ] / arr[ 0 ];
for ( int i = 2 ; i < n; i++) {
if (arr[i] / arr[i - 1 ] != r)
return false ;
}
return true ;
}
static boolean checkIsHP( double arr[], int n)
{
if (n == 1 ) {
return true ;
}
double []rec = new double [n];
for ( int i = 0 ; i < n; i++) {
rec[i] = (( 1 / arr[i]));
}
if (checkIsAP(rec, n))
return true ;
else
return false ;
}
public static void main(String[] args)
{
double arr[] = { 1.0 / 5.0 , 1.0 / 10.0 ,
1.0 / 15.0 , 1.0 / 20.0 };
int n = arr.length;
int flag = 0 ;
if (checkIsAP(arr, n)) {
System.out.print( "Yes, An AP can be formed"
+ "\n" );
flag = 1 ;
}
if (checkIsGP(arr, n)) {
System.out.print( "Yes, A GP can be formed"
+ "\n" );
flag = 1 ;
}
if (checkIsHP(arr, n)) {
System.out.print( "Yes, A HP can be formed"
+ "\n" );
flag = 1 ;
}
else if (flag == 0 ) {
System.out.print( "No" );
}
}
}
|
Python3
def checkIsAP(arr, n):
if (n = = 1 ):
return True
arr.sort();
d = arr[ 1 ] - arr[ 0 ]
for i in range ( 2 , n):
if (arr[i] - arr[i - 1 ] ! = d):
return False
return True
def checkIsGP(arr, n):
if (n = = 1 ):
return True
arr.sort()
r = arr[ 1 ] / arr[ 0 ]
for i in range ( 2 , n):
if (arr[i] / arr[i - 1 ] ! = r):
return False
return True
def checkIsHP(arr, n):
if (n = = 1 ):
return True
rec = []
for i in range ( 0 , n):
rec.append(( 1 / arr[i]))
if (checkIsAP(rec, n)):
return True
else :
return False
arr = [ 1.0 / 5.0 , 1.0 / 10.0 ,
1.0 / 15.0 , 1.0 / 20.0 ]
n = len (arr)
flag = 0
if (checkIsAP(arr, n)):
print ( "Yes, An AP can be formed" , end = '\n' )
flag = 1
if (checkIsGP(arr, n)):
print ( "Yes, A GP can be formed" , end = '\n' )
flag = 1
if (checkIsHP(arr, n)):
print ( "Yes, A HP can be formed" , end = '\n' )
flag = 1
elif (flag = = 0 ):
print ( "No" , end = '\n' )
|
C#
using System;
class GFG{
static bool checkIsAP( double []arr, int n)
{
if (n == 1)
return true ;
Array.Sort(arr);
double d = arr[1] - arr[0];
for ( int i = 2; i < n; i++) {
if (arr[i] - arr[i - 1] != d) {
return false ;
}
}
return true ;
}
static bool checkIsGP( double []arr, int n)
{
if (n == 1)
return true ;
Array.Sort(arr);
double r = arr[1] / arr[0];
for ( int i = 2; i < n; i++) {
if (arr[i] / arr[i - 1] != r)
return false ;
}
return true ;
}
static bool checkIsHP( double []arr, int n)
{
if (n == 1) {
return true ;
}
double []rec = new double [n];
for ( int i = 0; i < n; i++) {
rec[i] = ((1 / arr[i]));
}
if (checkIsAP(rec, n))
return true ;
else
return false ;
}
public static void Main(String[] args)
{
double []arr = { 1.0 / 5.0, 1.0 / 10.0,
1.0 / 15.0, 1.0 / 20.0 };
int n = arr.Length;
int flag = 0;
if (checkIsAP(arr, n)) {
Console.Write( "Yes, An AP can be formed"
+ "\n" );
flag = 1;
}
if (checkIsGP(arr, n)) {
Console.Write( "Yes, A GP can be formed"
+ "\n" );
flag = 1;
}
if (checkIsHP(arr, n)) {
Console.Write( "Yes, A HP can be formed"
+ "\n" );
flag = 1;
}
else if (flag == 0) {
Console.Write( "No" );
}
}
}
|
Javascript
<script>
function checkIsAP(arr, n)
{
if (n == 1)
return true ;
arr.sort( function (a,b){ return a-b;});
var d = arr[1] - arr[0];
for ( var i = 2; i < n; i++) {
if (arr[i] - arr[i - 1] != d) {
return false ;
}
}
return true ;
}
function checkIsGP(arr, n)
{
if (n == 1)
return true ;
arr.sort();
var r = arr[1] / arr[0];
for ( var i = 2; i < n; i++) {
if (arr[i] / arr[i - 1] != r)
return false ;
}
return true ;
}
function checkIsHP(arr, n)
{
if (n == 1) {
return true ;
}
var rec = Array(n).fill(0);
for ( var i = 0; i < n; i++) {
rec[i] = ((1 / arr[i]));
}
if (checkIsAP(rec, n))
return true ;
else
return false ;
}
var arr = [ 1.0 / 5.0, 1.0 / 10.0,
1.0 / 15.0, 1.0 / 20.0 ];
var n = arr.length;
var flag = 0;
if (checkIsAP(arr, n)) {
document.write( "Yes, An AP can be formed" );
flag = 1;
}
if (checkIsGP(arr, n)) {
document.write( "Yes, A GP can be formed" );
flag = 1;
}
if (checkIsHP(arr, n)) {
document.write( "Yes, A HP can be formed" );
flag = 1;
}
else if (flag == 0) {
document.write( "No" );
}
</script>
|
Output:
Yes, A HP can be formed
Time Complexity: O(N*log N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...