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 formedExplanation:

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 formedExplanation:

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 formedExplanation:

Rearrange given array as { 1.0/5.0, 1.0/10.0, 1.0/15.0, 1.0/20.0 }, forms a Harmonic Progression.

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

**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.

Check if the difference between the consecutive elements of the sorted array are same or not. If Yes then given array element forms an__For Arithmetic Progression__:**Arithmetic 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__For Geometric Progression__:**Geometric 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__For Harmonic Progression__:**Harmonic Progression**.

Below is the implementation of the above approach:

## C++

`// C++ program to check if a given`

`// array form AP, GP or HP`

`#include <bits/stdc++.h>`

`using`

`namespace`

`std;`

`// Returns true if arr[0..n-1]`

`// can form AP`

`bool`

`checkIsAP(`

`double`

`arr[], `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == 1)`

`return`

`true`

`;`

`// Sort array`

`sort(arr, arr + n);`

`// After sorting, difference`

`// between consecutive elements`

`// must be same.`

`double`

`d = arr[1] - arr[0];`

`// Traverse the given array and`

`// check if the difference`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`int`

`i = 2; i < n; i++) {`

`if`

`(arr[i] - arr[i - 1] != d) {`

`return`

`false`

`;`

`}`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form GP`

`bool`

`checkIsGP(`

`double`

`arr[], `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == 1)`

`return`

`true`

`;`

`// Sort array`

`sort(arr, arr + n);`

`// After sorting, common ratio`

`// between consecutive elements`

`// must be same.`

`double`

`r = arr[1] / arr[0];`

`// Traverse the given array and`

`// check if the common ratio`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`int`

`i = 2; i < n; i++) {`

`if`

`(arr[i] / arr[i - 1] != r)`

`return`

`false`

`;`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form HP`

`bool`

`checkIsHP(`

`double`

`arr[], `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == 1) {`

`return`

`true`

`;`

`}`

`double`

`rec[n];`

`// Find reciprocal of arr[]`

`for`

`(`

`int`

`i = 0; i < n; i++) {`

`rec[i] = ((1 / arr[i]));`

`}`

`// After finding reciprocal, check if`

`// the reciprocal is in A. P.`

`// To check for A.P.`

`if`

`(checkIsAP(rec, n))`

`return`

`true`

`;`

`else`

`return`

`false`

`;`

`}`

`// Driver's Code`

`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;`

`// Function to check AP`

`if`

`(checkIsAP(arr, n)) {`

`cout << `

`"Yes, An AP can be formed"`

`<< endl;`

`flag = 1;`

`}`

`// Function to check GP`

`if`

`(checkIsGP(arr, n)) {`

`cout << `

`"Yes, A GP can be formed"`

`<< endl;`

`flag = 1;`

`}`

`// Function to check HP`

`if`

`(checkIsHP(arr, n)) {`

`cout << `

`"Yes, A HP can be formed"`

`<< endl;`

`flag = 1;`

`}`

`else`

`if`

`(flag == 0) {`

`cout << `

`"No"`

`;`

`}`

`return`

`0;`

`}`

## Java

`// Java program to check if a given`

`// array form AP, GP or HP`

`import`

`java.util.*;`

`class`

`GFG{`

`// Returns true if arr[0..n-1]`

`// can form AP`

`static`

`boolean`

`checkIsAP(`

`double`

`arr[], `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == `

`1`

`)`

`return`

`true`

`;`

`// Sort array`

`Arrays.sort(arr);`

`// After sorting, difference`

`// between consecutive elements`

`// must be same.`

`double`

`d = arr[`

`1`

`] - arr[`

`0`

`];`

`// Traverse the given array and`

`// check if the difference`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`int`

`i = `

`2`

`; i < n; i++) {`

`if`

`(arr[i] - arr[i - `

`1`

`] != d) {`

`return`

`false`

`;`

`}`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form GP`

`static`

`boolean`

`checkIsGP(`

`double`

`arr[], `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == `

`1`

`)`

`return`

`true`

`;`

`// Sort array`

`Arrays.sort(arr);`

`// After sorting, common ratio`

`// between consecutive elements`

`// must be same.`

`double`

`r = arr[`

`1`

`] / arr[`

`0`

`];`

`// Traverse the given array and`

`// check if the common ratio`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`int`

`i = `

`2`

`; i < n; i++) {`

`if`

`(arr[i] / arr[i - `

`1`

`] != r)`

`return`

`false`

`;`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form HP`

`static`

`boolean`

`checkIsHP(`

`double`

`arr[], `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == `

`1`

`) {`

`return`

`true`

`;`

`}`

`double`

`[]rec = `

`new`

`double`

`[n];`

`// Find reciprocal of arr[]`

`for`

`(`

`int`

`i = `

`0`

`; i < n; i++) {`

`rec[i] = ((`

`1`

`/ arr[i]));`

`}`

`// After finding reciprocal, check if`

`// the reciprocal is in A. P.`

`// To check for A.P.`

`if`

`(checkIsAP(rec, n))`

`return`

`true`

`;`

`else`

`return`

`false`

`;`

`}`

`// Driver's Code`

`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`

`;`

`// Function to check AP`

`if`

`(checkIsAP(arr, n)) {`

`System.out.print(`

`"Yes, An AP can be formed"`

`+`

`"\n"`

`);`

`flag = `

`1`

`;`

`}`

`// Function to check GP`

`if`

`(checkIsGP(arr, n)) {`

`System.out.print(`

`"Yes, A GP can be formed"`

`+`

`"\n"`

`);`

`flag = `

`1`

`;`

`}`

`// Function to check HP`

`if`

`(checkIsHP(arr, n)) {`

`System.out.print(`

`"Yes, A HP can be formed"`

`+`

`"\n"`

`);`

`flag = `

`1`

`;`

`}`

`else`

`if`

`(flag == `

`0`

`) {`

`System.out.print(`

`"No"`

`);`

`}`

`}`

`}`

`// This code is contributed by PrinciRaj1992`

## Python3

`# Python3 program to check if a`

`# given array form AP, GP or HP`

`# Returns true if arr[0..n-1]`

`# can form AP`

`def`

`checkIsAP(arr, n):`

`# Base Case`

`if`

`(n `

`=`

`=`

`1`

`):`

`return`

`True`

`# Sort array`

`arr.sort();`

`# After sorting, difference`

`# between consecutive elements`

`# must be same.`

`d `

`=`

`arr[`

`1`

`] `

`-`

`arr[`

`0`

`]`

`# Traverse the given array and`

`# check if the difference`

`# between ith element and (i-1)th`

`# element is same or not`

`for`

`i `

`in`

`range`

`(`

`2`

`, n):`

`if`

`(arr[i] `

`-`

`arr[i `

`-`

`1`

`] !`

`=`

`d):`

`return`

`False`

`return`

`True`

`# Returns true if arr[0..n-1]`

`# can form GP`

`def`

`checkIsGP(arr, n):`

`# Base Case`

`if`

`(n `

`=`

`=`

`1`

`):`

`return`

`True`

`# Sort array`

`arr.sort()`

`# After sorting, common ratio`

`# between consecutive elements`

`# must be same.`

`r `

`=`

`arr[`

`1`

`] `

`/`

`arr[`

`0`

`]`

`# Traverse the given array and`

`# check if the common ratio`

`# between ith element and (i-1)th`

`# element is same or not`

`for`

`i `

`in`

`range`

`(`

`2`

`, n):`

`if`

`(arr[i] `

`/`

`arr[i `

`-`

`1`

`] !`

`=`

`r):`

`return`

`False`

`return`

`True`

`# Returns true if arr[0..n-1]`

`# can form HP`

`def`

`checkIsHP(arr, n):`

`# Base Case`

`if`

`(n `

`=`

`=`

`1`

`):`

`return`

`True`

`rec `

`=`

`[]`

`# Find reciprocal of arr[]`

`for`

`i `

`in`

`range`

`(`

`0`

`, n):`

`rec.append((`

`1`

`/`

`arr[i]))`

`# After finding reciprocal, check`

`# if the reciprocal is in A. P.`

`# To check for A.P.`

`if`

`(checkIsAP(rec, n)):`

`return`

`True`

`else`

`:`

`return`

`False`

`# Driver Code`

`arr `

`=`

`[ `

`1.0`

`/`

`5.0`

`, `

`1.0`

`/`

`10.0`

`,`

`1.0`

`/`

`15.0`

`, `

`1.0`

`/`

`20.0`

`]`

`n `

`=`

`len`

`(arr)`

`flag `

`=`

`0`

`# Function to check AP`

`if`

`(checkIsAP(arr, n)):`

`print`

`(`

`"Yes, An AP can be formed"`

`, end `

`=`

`'\n'`

`)`

`flag `

`=`

`1`

`# Function to check GP`

`if`

`(checkIsGP(arr, n)):`

`print`

`(`

`"Yes, A GP can be formed"`

`, end `

`=`

`'\n'`

`)`

`flag `

`=`

`1`

`# Function to check HP`

`if`

`(checkIsHP(arr, n)):`

`print`

`(`

`"Yes, A HP can be formed"`

`, end `

`=`

`'\n'`

`)`

`flag `

`=`

`1`

`elif`

`(flag `

`=`

`=`

`0`

`):`

`print`

`(`

`"No"`

`, end `

`=`

`'\n'`

`)`

`# This code is contributed by Pratik`

## C#

`// C# program to check if a given`

`// array form AP, GP or HP`

`using`

`System;`

`class`

`GFG{`

`// Returns true if arr[0..n-1]`

`// can form AP`

`static`

`bool`

`checkIsAP(`

`double`

`[]arr, `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == 1)`

`return`

`true`

`;`

`// Sort array`

`Array.Sort(arr);`

`// After sorting, difference`

`// between consecutive elements`

`// must be same.`

`double`

`d = arr[1] - arr[0];`

`// Traverse the given array and`

`// check if the difference`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`int`

`i = 2; i < n; i++) {`

`if`

`(arr[i] - arr[i - 1] != d) {`

`return`

`false`

`;`

`}`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form GP`

`static`

`bool`

`checkIsGP(`

`double`

`[]arr, `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == 1)`

`return`

`true`

`;`

`// Sort array`

`Array.Sort(arr);`

`// After sorting, common ratio`

`// between consecutive elements`

`// must be same.`

`double`

`r = arr[1] / arr[0];`

`// Traverse the given array and`

`// check if the common ratio`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`int`

`i = 2; i < n; i++) {`

`if`

`(arr[i] / arr[i - 1] != r)`

`return`

`false`

`;`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form HP`

`static`

`bool`

`checkIsHP(`

`double`

`[]arr, `

`int`

`n)`

`{`

`// Base Case`

`if`

`(n == 1) {`

`return`

`true`

`;`

`}`

`double`

`[]rec = `

`new`

`double`

`[n];`

`// Find reciprocal of []arr`

`for`

`(`

`int`

`i = 0; i < n; i++) {`

`rec[i] = ((1 / arr[i]));`

`}`

`// After finding reciprocal, check if`

`// the reciprocal is in A. P.`

`// To check for A.P.`

`if`

`(checkIsAP(rec, n))`

`return`

`true`

`;`

`else`

`return`

`false`

`;`

`}`

`// Driver's Code`

`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;`

`// Function to check AP`

`if`

`(checkIsAP(arr, n)) {`

`Console.Write(`

`"Yes, An AP can be formed"`

`+`

`"\n"`

`);`

`flag = 1;`

`}`

`// Function to check GP`

`if`

`(checkIsGP(arr, n)) {`

`Console.Write(`

`"Yes, A GP can be formed"`

`+`

`"\n"`

`);`

`flag = 1;`

`}`

`// Function to check HP`

`if`

`(checkIsHP(arr, n)) {`

`Console.Write(`

`"Yes, A HP can be formed"`

`+`

`"\n"`

`);`

`flag = 1;`

`}`

`else`

`if`

`(flag == 0) {`

`Console.Write(`

`"No"`

`);`

`}`

`}`

`}`

`// This code is contributed by PrinciRaj1992`

## Javascript

`<script>`

`// Javascript program to check if a given`

`// array form AP, GP or HP`

`// Returns true if arr[0..n-1]`

`// can form AP`

`function`

`checkIsAP(arr, n)`

`{`

`// Base Case`

`if`

`(n == 1)`

`return`

`true`

`;`

`// Sort array`

`arr.sort(`

`function`

`(a,b){`

`return`

`a-b;});`

`// After sorting, difference`

`// between consecutive elements`

`// must be same.`

`var`

`d = arr[1] - arr[0];`

`// Traverse the given array and`

`// check if the difference`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`var`

`i = 2; i < n; i++) {`

`if`

`(arr[i] - arr[i - 1] != d) {`

`return`

`false`

`;`

`}`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form GP`

`function`

`checkIsGP(arr, n)`

`{`

`// Base Case`

`if`

`(n == 1)`

`return`

`true`

`;`

`// Sort array`

`arr.sort();`

`// After sorting, common ratio`

`// between consecutive elements`

`// must be same.`

`var`

`r = arr[1] / arr[0];`

`// Traverse the given array and`

`// check if the common ratio`

`// between ith element and (i-1)th`

`// element is same or not`

`for`

`(`

`var`

`i = 2; i < n; i++) {`

`if`

`(arr[i] / arr[i - 1] != r)`

`return`

`false`

`;`

`}`

`return`

`true`

`;`

`}`

`// Returns true if arr[0..n-1]`

`// can form HP`

`function`

`checkIsHP(arr, n)`

`{`

`// Base Case`

`if`

`(n == 1) {`

`return`

`true`

`;`

`}`

`var`

`rec = Array(n).fill(0);`

`// Find reciprocal of arr[]`

`for`

`(`

`var`

`i = 0; i < n; i++) {`

`rec[i] = ((1 / arr[i]));`

`}`

`// After finding reciprocal, check if`

`// the reciprocal is in A. P.`

`// To check for A.P.`

`if`

`(checkIsAP(rec, n))`

`return`

`true`

`;`

`else`

`return`

`false`

`;`

`}`

`// Driver's Code`

`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;`

`// Function to check AP`

`if`

`(checkIsAP(arr, n)) {`

`document.write(`

`"Yes, An AP can be formed"`

`);`

`flag = 1;`

`}`

`// Function to check GP`

`if`

`(checkIsGP(arr, n)) {`

`document.write(`

`"Yes, A GP can be formed"`

`);`

`flag = 1;`

`}`

`// Function to check HP`

`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)

My Personal Notes *arrow_drop_up*

Last Updated : 29 Nov, 2021

Like Article

Save Article

## FAQs

### How do you know if an array is AP or GP? ›

For arithmetic progression, **subtract each element from previous element; their difference should be equal; for geometric, divide each element by the previous element, the ratio should stay the same**.

**How do you check if an array is in AP? ›**

Solution Approach. To check whether the current array is in arithmetic progression, simply **sort the array and check for all the consecutive differences in the given array**.

**What is AP vs GP vs HP? ›**

**AP,GP and HP represents the series' average or mean**. The letters AM, GM, and HM stand for Arithmetic Mean, Geometric Mean, and Harmonic Mean, respectively. Arithmetic Progression (AP), Geometric Progression (GP), and Harmonic Progression (HP) mean AM, GM, and HM, respectively.

**What is the relationship between AP HP and GP? ›**

The relation between AP, GP, and HP is, **G P 2 = A P × H P**.

**Can you tell a sequence which is both in AP and GP? ›**

Hence, **a constant sequence** is the only sequence which is both AP and GP.

**How do you check if a type is in an array? ›**

**isArray() method** is used to check if an object is an array. The Array. isArray() method returns true if an object is an array, otherwise returns false . Note: For an array, the typeof operator returns an object.

**How do you check if values in array are in order? ›**

**Iterative approach**

- If the length of the array is zero or one, then the array is sorted.
- Start looping from the first element.
- Compare every two elements. a. ...
- The loop will eventually come to the end of the array when all the array elements are in sorted order.

**How do you check an array is array or object? ›**

**The isArray() method** returns true if an object is an array, otherwise false .

**How do you check if an index exists in an array? ›**

PHP: Checks if the given key or index exists in an array

The **array_key_exists() function** is used to check whether a specified key is present in an array or not. The function returns TRUE if the given key is set in the array. The key can be any value possible for an array index.

**How do you find the common difference between AP and GP? ›**

The general form of an Arithmetic Progression is a, a + d, a + 2d, a + 3d and so on. Thus nth term of an AP series is T_{n} = a + (n - 1) d, where T_{n} = n^{th} term and a = first term. Here **d = common difference = T _{n} - T_{n}_{-}_{1}**. The sum of n terms is also equal to the formula where l is the last term.

### Are equal numbers always in AP GP and HP? ›

(A) **Equal numbers are always in A.P., G.P. and H.P.** (B) If a, b, c be in H.P., then a 2 2 2 will be in AP. (C) If G, and G, are two geometric means and A is the arithmetic mean inserted between two positive numbers, then the value of G G, + is 2A.

**What is AP and GP with examples? ›**

Answers. Arithmetic Progression (AP) is a sequence of numbers in order in which the difference of any two consecutive numbers is a constant value. geometric progression: A sequence of numbers in which each number is multiplied by the same factor to obtain the next number in the sequence.

**What is the difference between the harmonic series and a general P series? ›**

𝑝-series is a family of series where the terms are of the form 1/(nᵖ) for some value of 𝑝. **The Harmonic series is the special case where 𝑝=1**. These series are very interesting and useful.

**What is the relation between harmonic progression and geometric progression? ›**

Similarly, a geometric progression is one where any two consecutive terms are related by the common ratio. A harmonic progression is such a sequence where the reciprocals of all the terms of the progression are in an arithmetic progression.

**Is AP always greater than GP? ›**

Since even in real numbers the Sum of GP is less than that of AP, then **it cannot be greater than AP in a sequence where domain is integers**.

**How do you check whether given sequence is AP or not? ›**

We will find whether the sequence is an A.P. A series is said to be in AP **if the common difference between the consecutive terms are the same**. Therefore, we will first find the common difference between the consecutive terms. Common Difference is given by the formula $d = {t_{n + 1}} - {t_n}$.

**How do you verify that given sequence is an AP? ›**

To verify that the given sequence is an arithmetic progression by **paper cutting and pasting method**. Arithmetic Progression. A sequence is known as an arithmetic progression (sequence) if the difference between the term and its predecessor always remains constant.

**How to determine whether each sequence could be geometric or arithmetic? ›**

**If the sequence has a common difference, it's arithmetic**. If it's got a common ratio, you can bet it's geometric.

**How do you check if an array contains an object or string? ›**

**# Check if an Array Contains an Object with Array.**

**findIndex()**

- Use the Array. findIndex() method to iterate over the array.
- Check if each object contains a property with the specified value.
- The findIndex() method will return the index of the object in the array, or -1 if the object isn't in the array.

**How do you check if a character array contains a character in it? ›**

**Using List contains() method**. We can use Arrays class to get the list representation of the array. Then use the contains() method to check if the array contains the value.

### How do you check if an array to characters is empty? ›

Algorithm. Step 1 − Declare and initialize an integer array. Step 2 − Get the length of the array. Step 3 − **If length is equal to 0 then array is empty otherwise not**.

**How do you check if array is sorted or not without using any in built function? ›**

**Approach used below is as follows to solve the problem −**

- Take an array arr[] as an input and initialize n with the size of an array.
- Check if we reached the starting of an array, return true.
- Check if the previous element of an array is not smaller than the next element, return false.
- Decrement n and goto step 2.

**Do arrays have to be ordered? ›**

**Arrays are ordered collections**. i have encountered situations where the order was not preserved (in other languages), therefore the question.

**How do you check if an array has all values to true? ›**

The every() method executes a function for each array element. **The every() method returns true if the function returns true for all elements**. The every() method returns false if the function returns false for one element.

**How do you check if an array has an object with a value? ›**

**Using the array.**

**includes() method**, and if the array contains the object with the same key and values, it returns true.

**How do you check if an array of arrays has value? ›**

Method 1: **Using the include() method to check an array**:

The includes() method will return true if the JS array contains values or elements. If not, it will return false. The method will return output in a simple boolean value as includes() method is excellent for checking whether the value exists or not.

**How do you check if an array is empty or object? ›**

**Use Object.**

Object. keys will return an array, which contains the property names of the object. If the length of the array is 0 , then we know that the object is empty.

**How to check if an element exists at an index in ArrayList? ›**

**ArrayList.** **contains() method** can be used to check if an element exists in an ArrayList or not. This method has a single parameter i.e. the element whose presence in the ArrayList is tested. Also it returns true if the element is present in the ArrayList and false if the element is not present.

**How do you check if an object exists in an ArrayList? ›**

To check if ArrayList contains a specific object or element, **use ArrayList.** **contains() method**. You can call contains() method on the ArrayList, with the element passed as argument to the method. contains() method returns true if the object is present in the list, else the method returns false.

**How to find the common difference of an AP if the two terms are given? ›**

A common difference is the difference between consecutive numbers in an arithematic sequence. To find it, simply **subtract the first term from the second term, or the second from the third**, or so on... See how each time we are adding 8 to get to the next term? This means our common difference is 8.

### How to find common difference in AP with first and last term? ›

Therefore, you can say that the formula to find the common difference of an arithmetic sequence is: **d = a(n) - a(n - 1)**, where a(n) is the last term in the sequence, and a(n - 1) is the previous term in the sequence.

**How do you find the common difference in harmonic progression? ›**

The Arithmetic Progression for the given H.P is A.P = ⅙, ¼, ⅓, …. Here T2-T1 = T3-T2 = 1/12, so **1/12 is the common difference**. Therefore, the fifth term of the Arithmetic Progression is 1/2. The nth term of a Harmonic Progression is the reciprocal of the nth term in the corresponding Arithmetic Progression.

**What is the list of formula for AP and GP? ›**

General Form of AP | a, a + d, a + 2d, a + 3d, . . . |
---|---|

The nth term of AP | a_{n} = a + (n – 1) × d |

Sum of n terms in AP | S = n/2[2a + (n − 1) × d] |

Sum of all terms in a finite AP with the last term as 'l' | n/2(a + l) |

**Can harmonic mean equal geometric mean? ›**

The Pythagorean Means conform to a strict ordinal relationship. Due to their respective equations: **the harmonic mean is always smaller than the geometric mean**, which is always smaller than the arithmetic mean.

**What is an example of HP? ›**

In harmonic progression, any term in the sequence is considered as the harmonic means of its two neighbours. For example, the sequence **a, b, c, d**, …is considered as an arithmetic progression; the harmonic progression can be written as 1/a, 1/b, 1/c, 1/d, …

**What are some examples of GP? ›**

For example, **2, 4, 8, 16, 32, 64**, … is a GP, where the common ratio is 2. Similarly, Consider a series 1, 1/2, 1/4, 1/8, 1/16, … In the given examples, the ratio is a constant.

**What is an example of sequence in GP? ›**

This progression is also known as a geometric sequence of numbers that follow a pattern. Also, learn arithmetic progression here. The common ratio multiplied here to each term to get the next term is a non-zero number. An example of a Geometric sequence is **2, 4, 8, 16, 32, 64**, …, where the common ratio is 2.

**Is harmonic and Fibonacci the same? ›**

**Harmonic trading relies on Fibonacci numbers**, which are used to create technical indicators. The Fibonacci sequence of numbers, starting with zero and one, is created by adding the previous two numbers: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, etc.

**What is arithmetic vs geometric vs harmonic progression? ›**

**The arithmetic mean is appropriate if the values have the same units, whereas the geometric mean is appropriate if the values have differing units**. The harmonic mean is appropriate if the data values are ratios of two variables with different measures, called rates.

**What is the difference between arithmetic geometric and harmonic sequence? ›**

In an arithmetic sequence, there is a common difference between two subsequent terms. In a geometric sequence, there is a common ratio between consecutive terms. In a harmonic sequence, the reciprocals of its terms are in an arithmetic sequence.

### Can a sequence be both arithmetic and geometric and harmonic? ›

Is it possible for a sequence to be both arithmetic and geometric? **Yes**, because we found an example above: 5, 5, 5, 5,.... where c is a constant will be arithmetic with d = 0 and geometric with r = 1.

**What is the rule for harmonic progression? ›**

Harmonic Progression (HP): The series of numbers where the reciprocals of the terms are in Arithmetic Progression, is called a Harmonic Progression. If three numbers a, b and c are in HP, then 1 a + 1 c = 2 b .

**What is the difference between harmonic progression and chord progression? ›**

HARMONIC PROGRESSION (also known as CHORD PROGRESSION) is the logical movement from one chord to another to create the structural foundation and movement of a work in Western Classical Music.

**What is the relationship between AP GP and HP? ›**

The relation between AP, GP, and HP is, **G P 2 = A P × H P**. **Q**. Q.

**What happens to AP when AP is maximum? ›**

When AP is maximum, **MP is equal to AP**.

**How do you check if array is associative or not? ›**

To check if an array is associative or sequential in PHP, you can **use the array_keys() function and compare the resulting array of keys with the original array**. If the keys of the array are a continuous sequence of integers starting from 0, then the array is sequential. Otherwise, it is associative.

**How do you recognize arithmetic and geometric progressions? ›**

In an arithmetic progression, each successive term is obtained by adding the common difference to its preceding term. In a geometric progression, each successive term is obtained by multiplying the common ratio to its preceding term.

**How do you determine whether a sequence is arithmetic or geometric code? ›**

**An arithmetic sequence has a constant difference between each consecutive pair of terms**. This is similar to the linear functions that have the form y=mx+b. A geometric sequence has a constant ratio between each pair of consecutive terms. This would create the effect of a constant multiplier.

**How do you check if everything in an array is the same? ›**

In order to check whether every value of your records/array is equal to each other or not, you can use this function. **allEqual() function returns true if the all records of a collection are equal and false otherwise**. let's look at the syntax… const allEqual = arr => arr.

**How do you check if all values in an array are different? ›**

**Check if all array elements are unique**

- Create a new Set from the mapped values to keep only unique occurrences.
- Use Array. prototype. length and Set. prototype. size to compare the length of the unique values to the original array.

### How do you recognize an arithmetic sequence and find the nth term? ›

To find the nth term, first calculate the common difference, d . Next multiply each term number of the sequence (n = 1, 2, 3, …) by the common difference. Then add or subtract a number from the new sequence to achieve a copy of the sequence given in the question.

**What is the difference between harmonic progression and geometric progression? ›**

Similarly, a geometric progression is one where any two consecutive terms are related by the common ratio. A harmonic progression is such a sequence where the reciprocals of all the terms of the progression are in an arithmetic progression.

**How do you identify the arithmetic sequence explain why or why not? ›**

How to Identify An Arithmetic Sequence? **If the difference between every two consecutive terms of a sequence is the same then it is an arithmetic sequence**. For example, 3, 8, 13, 18 ... is arithmetic because the consecutive terms have a fixed difference. 18-13 = 5 and so on.

**How will you determine a geometric sequence and geometric series? ›**

A geometric sequence is a sequence where the ratio r between successive terms is constant. The general term of a geometric sequence can be written in terms of its first term a1, common ratio r, and index n as follows: an=a1rn−1. **A geometric series is the sum of the terms of a geometric sequence**.