Find the missing number in Geometric Progression (original) (raw)

Last Updated : 31 Oct, 2022

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

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.

Implementation:

C++ `

// C++ program to find missing number in // geometric progression #include <bits/stdc++.h> 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[0] * (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[0], 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[0]); 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[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() 
{
    int []arr = {2, 4, 8, 32};
    int n = arr.Length;
    
    Console.Write(findMissing(arr, n));
}

}

// This code is contributed by nitin mittal.

PHP

JavaScript

`

Time Complexity: O(logn)

Auxiliary Space: O(logn)

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