Related Articles
Find the missing number in Geometric Progression
• Difficulty Level : Medium
• Last Updated : 24 Dec, 2018

Given an array that represents elements of geometric progression in order. One element is missing in the progression, find the missing number. It may be assumed that one term is always missing and the missing term is not first or last of series.

Examples:

```Input : arr[] = {1, 3 , 27, 81}
Output : 9

Input : arr[] = {4, 16, 64, 1024};
Output : 256
```

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

A Simple Solution is to linearly traverse the array and find the missing number. Time complexity of this solution is O(n).

An efficient solution to solve this problem in O(Log n) time using Binary Search. The idea is to go to the middle element. Check if the ratio of middle and next to middle is equal to common ratio or not, if not then the missing element lies between mid and mid+1. If the middle element is equal to n/2th term in Geometric Series (Let n be the number of elements in input array), then missing element lies in right half. Else element lies in left half.

## C++

 `// C++ program to find missing number in``// geometric progression``#include ``using` `namespace` `std;`` ` `// It returns INT_MAX in case of error``int` `findMissingRec(``int` `arr[], ``int` `low,``                   ``int` `high, ``int` `ratio)``{``    ``if` `(low >= high)``        ``return` `INT_MAX;``    ``int` `mid = low + (high - low)/2;`` ` `    ``// If element next to mid is missing``    ``if` `(arr[mid+1]/arr[mid] != ratio)``        ``return` `(arr[mid] * ratio);`` ` `    ``// If element previous to mid is missing``    ``if` `((mid > 0) && (arr[mid]/arr[mid-1]) != ratio)``        ``return` `(arr[mid-1] * ratio);`` ` `    ``// If missing element is in right half``    ``if` `(arr[mid] == arr * (``pow``(ratio, mid)) )``        ``return` `findMissingRec(arr, mid+1, high, ratio);`` ` `    ``return` `findMissingRec(arr, low, mid-1, ratio);``}`` ` `// Find ration and calls findMissingRec``int` `findMissing(``int` `arr[], ``int` `n)``{``    ``// Finding ration assuming that the missing term is``    ``// not first or last term of series.``    ``int` `ratio = (``float``) ``pow``(arr[n-1]/arr, 1.0/n);`` ` `    ``return` `findMissingRec(arr, 0, n-1, ratio);``}`` ` `// Driver code``int` `main(``void``)``{``    ``int` `arr[] = {2, 4, 8, 32};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``cout << findMissing(arr, n);``    ``return` `0;``}`

## Java

 `// JAVA Code for Find the missing number``// in Geometric Progression``class` `GFG {``      ` `    ``// It returns INT_MAX in case of error``    ``public` `static` `int` `findMissingRec(``int` `arr[], ``int` `low,``                       ``int` `high, ``int` `ratio)``    ``{``        ``if` `(low >= high)``            ``return` `Integer.MAX_VALUE;``        ``int` `mid = low + (high - low)/``2``;``      ` `        ``// If element next to mid is missing``        ``if` `(arr[mid+``1``]/arr[mid] != ratio)``            ``return` `(arr[mid] * ratio);``      ` `        ``// If element previous to mid is missing``        ``if` `((mid > ``0``) && (arr[mid]/arr[mid-``1``]) != ratio)``            ``return` `(arr[mid-``1``] * ratio);``      ` `        ``// If missing element is in right half``        ``if` `(arr[mid] == arr[``0``] * (Math.pow(ratio, mid)) )``            ``return` `findMissingRec(arr, mid+``1``, high, ratio);``      ` `        ``return` `findMissingRec(arr, low, mid-``1``, ratio);``    ``}``      ` `    ``// Find ration and calls findMissingRec``    ``public` `static` `int` `findMissing(``int` `arr[], ``int` `n)``    ``{``        ``// Finding ration assuming that the missing``        ``// term is not first or last term of series.``        ``int` `ratio =(``int``) Math.pow(arr[n-``1``]/arr[``0``], ``1.0``/n);``      ` `        ``return` `findMissingRec(arr, ``0``, n-``1``, ratio);``    ``}    ``     ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``int` `arr[] = {``2``, ``4``, ``8``, ``32``};``        ``int` `n = arr.length;``         ` `        ``System.out.print(findMissing(arr, n));``    ``}``  ``}``// This code is contributed by Arnav Kr. Mandal.`

## Python3

 `# Python3 program to find missing ``# number in geometric progression`` ` `# It returns INT_MAX in case of error``def` `findMissingRec(arr, low, high, ratio):`` ` `    ``if` `(low >``=` `high):``        ``return` `2147483647``    ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2`` ` `    ``# If element next to mid is missing``    ``if` `(arr[mid ``+` `1``] ``/``/` `arr[mid] !``=` `ratio):``        ``return` `(arr[mid] ``*` `ratio)`` ` `    ``# If element previous to mid is missing``    ``if` `((mid > ``0``) ``and` `(arr[mid] ``/` `arr[mid``-``1``]) !``=` `ratio):``        ``return` `(arr[mid ``-` `1``] ``*` `ratio)`` ` `    ``# If missing element is in right half``    ``if` `(arr[mid] ``=``=` `arr[``0``] ``*` `(``pow``(ratio, mid)) ):``        ``return` `findMissingRec(arr, mid``+``1``, high, ratio)`` ` `    ``return` `findMissingRec(arr, low, mid``-``1``, ratio)`` ` ` ` `# Find ration and calls findMissingRec``def` `findMissing(arr, n):``  ` `    ``# Finding ration assuming that ``    ``# the missing term is not first``    ``# or last term of series.``    ``ratio ``=` `int``(``pow``(arr[n``-``1``] ``/` `arr[``0``], ``1.0` `/` `n))`` ` `    ``return` `findMissingRec(arr, ``0``, n``-``1``, ratio)`` ` `# Driver code``arr ``=` `[``2``, ``4``, ``8``, ``32``]``n ``=` `len``(arr)``print``(findMissing(arr, n))`` ` `# This code is contributed by Anant Agarwal.`

## C#

 `// C# Code for Find the missing number``// in Geometric Progression``using` `System;`` ` `class` `GFG {``     ` `    ``// It returns INT_MAX in case of error``    ``public` `static` `int` `findMissingRec(``int` `[]arr, ``int` `low,``                                    ``int` `high, ``int` `ratio)``    ``{``        ``if` `(low >= high)``            ``return` `int``.MaxValue;``             ` `        ``int` `mid = low + (high - low)/2;``     ` `        ``// If element next to mid is missing``        ``if` `(arr[mid+1]/arr[mid] != ratio)``            ``return` `(arr[mid] * ratio);``     ` `        ``// If element previous to mid is missing``        ``if` `((mid > 0) && (arr[mid]/arr[mid-1]) != ratio)``            ``return` `(arr[mid-1] * ratio);``     ` `        ``// If missing element is in right half``        ``if` `(arr[mid] == arr * (Math.Pow(ratio, mid)) )``            ``return` `findMissingRec(arr, mid+1, high, ratio);``     ` `        ``return` `findMissingRec(arr, low, mid-1, ratio);``    ``}``     ` `    ``// Find ration and calls findMissingRec``    ``public` `static` `int` `findMissing(``int` `[]arr, ``int` `n)``    ``{``         ` `        ``// Finding ration assuming that the missing``        ``// term is not first or last term of series.``        ``int` `ratio =(``int``) Math.Pow(arr[n-1]/arr, 1.0/n);``     ` `        ``return` `findMissingRec(arr, 0, n-1, ratio);``    ``} ``     ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `Main() ``    ``{``        ``int` `[]arr = {2, 4, 8, 32};``        ``int` `n = arr.Length;``         ` `        ``Console.Write(findMissing(arr, n));``    ``}``}`` ` `// This code is contributed by nitin mittal.`

## PHP

 `= ``\$high``)``        ``return` `PHP_INT_MAX;``    ``\$mid` `= ``\$low` `+ ``intval``((``\$high` `- ``\$low``) / 2);`` ` `    ``// If element next to mid is missing``    ``if` `(``\$arr``[``\$mid``+1]/``\$arr``[``\$mid``] != ``\$ratio``)``        ``return` `(``\$arr``[``\$mid``] * ``\$ratio``);`` ` `    ``// If element previous to mid is missing``    ``if` `((``\$mid` `> 0) && (``\$arr``[``\$mid``] /``                       ``\$arr``[``\$mid` `- 1]) != ``\$ratio``)``        ``return` `(``\$arr``[``\$mid` `- 1] * ``\$ratio``);`` ` `    ``// If missing element is in right half``    ``if` `(``\$arr``[``\$mid``] == ``\$arr`` * (pow(``\$ratio``, ``\$mid``)))``        ``return` `findMissingRec(``\$arr``, ``\$mid` `+ 1,``                              ``\$high``, ``\$ratio``);`` ` `    ``return` `findMissingRec(``\$arr``, ``\$low``, ``                          ``\$mid` `- 1, ``\$ratio``);``}`` ` `// Find ration and calls findMissingRec``function` `findMissing(&``\$arr``, ``\$n``)``{``    ``// Finding ration assuming that the missing ``    ``// term is not first or last term of series.``    ``\$ratio` `= (float) pow(``\$arr``[``\$n` `- 1] / ``                         ``\$arr``, 1.0 / ``\$n``);`` ` `    ``return` `findMissingRec(``\$arr``, 0, ``\$n` `- 1, ``\$ratio``);``}`` ` `// Driver code``\$arr` `= ``array``(2, 4, 8, 32);``\$n` `= sizeof(``\$arr``);``echo` `findMissing(``\$arr``, ``\$n``);`` ` `// This code is contributed by ita_c``?>`

Output:
```16
```

Note : Drawback withs this solution are : For larger values or for bigger array, it may cause overflow and/or may take more time to computer powers.

This article is contributed by Yasin Zafar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up