Egg Drop With 2 Eggs and N Floors - Practice Coding Problems

Egg Drop With 2 Eggs and N Floors - Problem

Imagine you're a quality assurance engineer testing the durability of smartphone screens. You have exactly 2 identical test phones and access to an n-story building with floors labeled from 1 to n.

There exists a critical floor f (where 0 ≤ f ≤ n) such that:

📱 Any phone dropped from floor f or below will survive and can be reused
💥 Any phone dropped from floor above f will break and become unusable

Your mission: Find the exact value of f using the minimum number of drops possible. You must guarantee finding f with certainty, regardless of what the actual value turns out to be.

Input: An integer n representing the number of floors
Output: The minimum number of moves needed to determine f with certainty

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: 2

💡 Note: Drop from floor 1. If it breaks, f=0 (1 drop used). If it survives, drop from floor 2. If it breaks, f=1. If it survives, f=2. Maximum drops needed: 2.

example_2.py — Medium Case

$ Input: n = 6

› Output: 3

💡 Note: Optimal strategy: Drop from floor 3 first. If breaks: test floors 1,2 sequentially (3 total). If survives: drop from floor 5. If breaks: test floor 4 (3 total). If survives: test floor 6 (3 total).

example_3.py — Larger Case

$ Input: n = 14

› Output: 4

💡 Note: With 4 drops, we can handle 4×5/2 = 10 floors minimum, but need strategy: drop at 4,7,9,10... The triangular pattern 4+3+2+1 = 10, but we need to be more careful for 14 floors.

Constraints

1 ≤ n ≤ 1000
You have exactly 2 identical eggs
Floor f can be 0 (eggs break when dropped from any floor) to n (eggs never break)

Visualization

Tap to expand

Understanding the Visualization

Choose Optimal First Drop

Start at floor m where m*(m+1)/2 covers all n floors

Handle Egg Break Case

If first egg breaks, test remaining floors sequentially with second egg

Handle Egg Survive Case

If first egg survives, continue with same strategy on remaining floors

Triangular Pattern

The intervals decrease: m, m-1, m-2, ... forming triangular numbers

Key Takeaway

🎯 Key Insight: The optimal strategy uses triangular numbers m×(m+1)/2 to ensure we can handle n floors in exactly m drops, minimizing the worst-case scenario through strategic interval placement.

Asked in

G Google 23 ⊞ Microsoft 18 a Amazon 15 f Meta 12

The optimal solution uses mathematical insight to recognize that with m drops, we can test at most m×(m+1)/2 floors using a triangular pattern strategy. The answer is the smallest m where this formula ≥ n, achievable in O(√n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Dynamic Programming	O(n²)	O(n)	Try every possible first drop and recursively solve subproblems
Mathematical Formula (Optimal)	O(√n)	O(1)	Use mathematical insight to find optimal solution in O(1) time

Brute Force Dynamic Programming — Algorithm Steps

Create a 2D DP table where dp[eggs][floors] represents minimum drops needed
For each state (eggs, floors), try dropping from every possible floor k
Calculate worst case: max(dp[eggs-1][k-1], dp[eggs][floors-k]) + 1
Take minimum across all possible first drops

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Cases

With 1 egg, we need i drops for i floors (sequential testing)

Try All First Drops

For each floor count, try dropping from every possible floor

Calculate Worst Case

Consider both scenarios: egg breaks vs egg survives

Take Minimum

Choose the first drop that minimizes the worst-case drops

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int min(int a, int b) {
    return (a < b) ? a : b;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int twoEggDrop(int n) {
    // dp[i] = min drops needed with 1 egg for i floors
    // dp2[i] = min drops needed with 2 eggs for i floors
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    int* dp2 = (int*)malloc((n + 1) * sizeof(int));
    
    dp[0] = dp2[0] = 0;
    
    // With 1 egg, we must try floors sequentially
    for (int i = 1; i <= n; i++) {
        dp[i] = i;
    }
    
    // With 2 eggs, try all possible first drops
    for (int i = 1; i <= n; i++) {
        dp2[i] = INT_MAX;
        for (int k = 1; k <= i; k++) {
            // If egg breaks at floor k: dp[k-1] + 1
            // If egg doesn't break: dp2[i-k] + 1
            int worstCase = max(dp[k - 1], dp2[i - k]) + 1;
            dp2[i] = min(dp2[i], worstCase);
        }
    }
    
    int result = dp2[n];
    free(dp);
    free(dp2);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", twoEggDrop(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n floors, we try n possible first drops

⚠ Quadratic Growth

Space Complexity

O(n)

DP table with 2 rows (for 1 and 2 eggs) and n columns

⚡ Linearithmic Space

47.0K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler