Eggs dropping puzzle (Binomial Coefficient and Binary Search Solution)

Given n eggs and k floors, find the minimum number of trials needed in worst case to find the floor below which all floors are safe. A floor is safe if dropping an egg from it does not break the egg. Please see n eggs and k floors. for complete statements

Input : n = 2, k = 10
Output : 4
We first try from 4-th floor. Two cases arise,
(1) If egg breaks, we have one egg left so we
    need three more trials.
(2) If egg does not break, we try next from 7-th
    floor. Again two cases arise.
We can notice that if we choose 4th floor as first
floor, 7-th as next floor and 9 as next of next floor,
we never exceed more than 4 trials.

Input : n = 2. k = 100
Output : 14

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

We have discussed the problem for 2 eggs and k floors. We have also discussed a dynamic programming solution to find the solution. The dynamic programming solution is based on below recursive nature of the problem. Let us look at the discussed recursive formula from a different perspective.

How many floors we can cover with x trials?
When we drop an egg, two cases arise.

If egg breaks, then we are left with x-1 trials and n-1 eggs.
If egg does not break, then we are left with x-1 trials and n eggs

Let maxFloors(x, n) be the maximum number of floors 
that we can cover with x trials and n eggs. From above 
two cases, we can write.

maxFloors(x, n) = maxFloors(x-1, n-1) + maxFloors(x-1, n) + 1
For all x >= 1 and n >= 1

Base cases : 
We can't cover any floor with 0 trials or 0 eggs
maxFloors(0, n) = 0
maxFloors(x, 0) = 0

Since we need to cover k floors, 
maxFloors(x, n) >= k           ----------(1)

The above recurrence simplifies to following,
Refer this for proof.

maxFloors(x, n) = &Sum;^xC_i
                  1 <= i <= n   ----------(2)
Here C represents Binomial Coefficient.

From above two equations, we can say.
&Sum;^xC_j  >= k
1 <= i <= n
Basically we need to find minimum value of x
that satisfies above inequality. We can find
such x using Binary Search.

C++

// C++ program to find minimum  
// number of trials in worst case.  
#include <bits/stdc++.h>  
  
using namespace std;  
  
// Find sum of binomial coefficients xCi  
// (where i varies from 1 to n).  
int binomialCoeff(int x, int n)  
{  
    int sum = 0, term = 1;  
    for (int i = 1; i <= n; ++i) {  
        term *= x - i + 1;  
        term /= i;  
        sum += term;  
    }  
    return sum;  
}  
  
// Do binary search to find minimum  
// number of trials in worst case.  
int minTrials(int n, int k)  
{  
    // Initialize low and high as 1st  
    // and last floors  
    int low = 1, high = k;  
  
    // Do binary search, for every mid,  
    // find sum of binomial coefficients and  
    // check if the sum is greater than k or not.  
    while (low < high) {  
        int mid = (low + high) / 2;  
        if (binomialCoeff(mid, n) < k)  
            low = mid + 1;  
        else
            high = mid;  
    }  
  
    return low;  
}  
  
/* Drier program to test above function*/
int main()  
{  
    cout << minTrials(2, 10);  
    return 0;  
}  

Java

// Java program to find minimum  
// number of trials in worst case. 
class Geeks { 
  
// Find sum of binomial coefficients xCi 
// (where i varies from 1 to n). If the sum 
// becomes more than K 
static int binomialCoeff(int x, int n, int k) 
{ 
    int sum = 0, term = 1; 
    for (int i = 1; i <= n && sum < k; ++i) { 
        term *= x - i + 1; 
        term /= i; 
        sum += term; 
    } 
    return sum; 
} 
  
// Do binary search to find minimum  
// number of trials in worst case. 
static int minTrials(int n, int k) 
{ 
    // Initialize low and high as 1st  
    //and last floors 
    int low = 1, high = k; 
  
    // Do binary search, for every mid,  
    // find sum of binomial coefficients and  
    // check if the sum is greater than k or not. 
    while (low < high) { 
        int mid = (low + high) / 2; 
        if (binomialCoeff(mid, n, k) < k) 
            low = mid + 1; 
        else
            high = mid; 
    } 
  
    return low; 
} 
  
/* Driver program to test above function*/
public static void main(String args[]) 
{ 
    System.out.println(minTrials(2, 10)); 
} 
} 
  
// This code is contributed by ankita_saini 

Python3

# Python3 program to find minimum  
# number of trials in worst case. 
  
# Find sum of binomial coefficients  
# xCi (where i varies from 1 to n).  
# If the sum becomes more than K 
def binomialCoeff(x, n, k): 
  
    sum = 0; 
    term = 1; 
    i = 1; 
    while(i <= n and sum < k):  
        term *= x - i + 1; 
        term /= i; 
        sum += term; 
        i += 1; 
    return sum; 
  
# Do binary search to find minimum  
# number of trials in worst case. 
def minTrials(n, k): 
  
    # Initialize low and high as  
    # 1st and last floors 
    low = 1; 
    high = k; 
  
    # Do binary search, for every  
    # mid, find sum of binomial  
    # coefficients and check if  
    # the sum is greater than k or not. 
    while (low < high): 
  
        mid = (low + high) / 2; 
        if (binomialCoeff(mid, n, k) < k): 
            low = mid + 1; 
        else: 
            high = mid; 
  
    return int(low); 
  
# Driver Code 
print(minTrials(2, 10)); 
  
# This code is contributed  
# by mits 

C#

// C# program to find minimum  
// number of trials in worst case. 
using System; 
  
class GFG  
{ 
  
// Find sum of binomial coefficients 
// xCi (where i varies from 1 to n).  
// If the sum becomes more than K 
static int binomialCoeff(int x,  
                         int n, int k) 
{ 
    int sum = 0, term = 1; 
    for (int i = 1;  
             i <= n && sum < k; ++i)  
    { 
        term *= x - i + 1; 
        term /= i; 
        sum += term; 
    } 
    return sum; 
} 
  
// Do binary search to find minimum  
// number of trials in worst case. 
static int minTrials(int n, int k) 
{ 
    // Initialize low and high 
    // as 1st and last floors 
    int low = 1, high = k; 
  
    // Do binary search, for every  
    // mid, find sum of binomial  
    // coefficients and check if the 
    // sum is greater than k or not. 
    while (low < high)  
    { 
        int mid = (low + high) / 2; 
        if (binomialCoeff(mid, n, k) < k) 
            low = mid + 1; 
        else
            high = mid; 
    } 
  
    return low; 
} 
  
// Driver Code 
public static void Main() 
{ 
    Console.WriteLine(minTrials(2, 10)); 
} 
} 
  
// This code is contributed 
// by Akanksha Rai(Abby_akku) 

PHP

<?php 
// PHP program to find minimum  
// number of trials in worst case. 
  
// Find sum of binomial coefficients  
// xCi (where i varies from 1 to n).  
// If the sum becomes more than K 
function binomialCoeff($x, $n, $k) 
{ 
    $sum = 0; $term = 1; 
    for ($i = 1; $i <= $n &&  
         $sum < $k; ++$i)  
    { 
        $term *= $x - $i + 1; 
        $term /= $i; 
        $sum += $term; 
    } 
    return $sum; 
} 
  
// Do binary search to find minimum  
// number of trials in worst case. 
function minTrials($n, $k) 
{ 
    // Initialize low and high as  
    // 1st and last floors 
    $low = 1; $high = $k; 
  
    // Do binary search, for every  
    // mid, find sum of binomial  
    // coefficients and check if  
    // the sum is greater than k or not. 
    while ($low < $high)  
    { 
        $mid = ($low + $high) / 2; 
        if (binomialCoeff($mid, $n, $k) < $k) 
            $low = $mid + 1; 
        else
            $high = $mid; 
    } 
  
    return (int)$low; 
} 
  
// Driver Code 
echo minTrials(2, 10); 
  
// This code is contributed  
// by Akanksha Rai(Abby_akku) 
?> 

Output:

Time Complexity : O(n Log k)

My Personal Notes

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

C++

Java

Python3

C#

PHP

Recommended Posts: