# JavaScript Challenge - Egg Dropper

This community-built FAQ covers the “Egg Dropper” code challenge in JavaScript. You can find that challenge here, or pick any challenge you like from our list.

## Top Discussions on the JavaScript challenge Egg Dropper

There are currently no frequently asked questions or top answers associated with this challenge – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this challenge. Ask a question or post a solution by clicking reply () below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this challenge, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

## Join the Discussion. Help a fellow learner on their journey.

You can also find further discussion and get answers to your questions over in Language Help.

Agree with a comment or answer? Like () to up-vote the contribution!

Need broader help or resources? Head to Language Help and Tips and Resources. If you are wanting feedback or inspiration for a project, check out Projects.

Looking for motivation to keep learning? Join our wider discussions in Community

Found a bug? Report it online, or post in Bug Reporting

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

I’ve tried to approach this challange with binary search alghoritm, but then I realised when the egg breaks on 50th floor we have 49 more possible floors, so I needed some other way around.
So after some reading on the net, because I wasn’t quite sure how to do it, I’ve managed to write this simple solution for this challange: explanation

function eggDrop(n, d = 1){ // Write your code here if (n <= 0) { return d-1; } else if (n => 1) { return eggDrop(n-d, ++d); } } console.log(eggDrop(2)); // Leave this here so we can test your code module.exports = eggDrop;
3 Likes

For 2 eggs.

``````function eggDrop(n){
return Math.round(Math.sqrt(n / 2) * 2);
}
``````
1 Like

Works for any positive integer, negative integers, 1, and 0, and even responds with -1 if ‘n’ is not provided:

``````const eggDrop = (n = -1, drops = 0, floor = 0) => {
if (floor >= n) return drops
drops++
floor += drops
return eggDrop(n, drops, floor)
}
``````
2 Likes
``````function eggDrop(n){
return Math.floor(Math.sqrt(n/2) * 2)
}
console.log(eggDrop(n)) // logs 14
``````

The floored square root of 50 multiplied by 2 gives us the the number of floors to omit for the first drop of the first egg.

1. egg

1. drop: 14th floor → doesn’t break +13 drops left between 14th floor and 27th floor if egg breaks at 27th floor
2. drop: 27th floor → doesn’t break +12
3. drop 39th floor → doesn’t break + 11
4. drop: 50th floor → doesn’t break +10
5. drop: 60th floor → doesn’t break +9
6. drop 69th floor → doesn’t break +8
7. drop 77th floor → doesn’t break +7
8. drop 84th floor → doesn’t break +6
9. drop 90th floor → doesn’t break +5
10. drop 95th floor → doesn’t break +4
11. drop 99th floor → breaks

2. egg
12. drop 96th floor → doesn’t break
13. drop 97th floor → doesn’t break
14. drop 98th floor → doesn’t break ( `f===99` )
14. drop 98th floor → breaks ( `f===98` )

2 Likes

Solution with a plus.

function eggDrop(n){ // Write your code here return bld(n); } // Binary Search function bs(n) { // First egg drop is from the middle // And then depending on the result // It's brute force for the rest return Math.ceil(n / 2); } // Divide a Little, Conquer a Bit function dlcb(n) { // The egg is dropped in decimal floors of n // And if the egg breaks in any of those 10 // The worst case scenario would be between // that last egg drop and the previous decimals // until the previous egg drop return n > 9 ? 10 + (Math.floor(n * .09)) : n; } // Balancing Linear Drops function bld(n) { // Similar to the previous one, divide and conquer // Except it starts from it's square root and // goes up by that square root - 1 on each drop // If the egg breaks then you basically sum twice // that square root that was consistent all over // because of the iteration of square root - 1 on // each drop. That's how you get 14 drops // out of 100 floors as worst case scenario return Math.round(Math.sqrt(n*2)); } console.log(eggDrop(100)); // Leave this here so we can test your code module.exports = eggDrop;

My code is
function eggDrop(n) {
// Base case: if there is only 1 floor, no need to drop the egg
if (n === 1) {
return 1;
}

// Base case: if there are only 2 floors, only 1 drop is needed
if (n === 2) {
return 2;
}

// Create a 2D array to store the results of subproblems
const dp = Array.from({ length: n + 1 }, () => new Array(3).fill(0));

// Fill in the base cases
for (let i = 0; i <= n; i++) {
dp[i][1] = i;
}

// Fill in the remaining array using dynamic programming
for (let i = 1; i <= n; i++) {
for (let j = 2; j <= 2; j++) {
dp[i][j] = Infinity;

``````  // Drop the egg from each floor and choose the minimum number of drops
for (let k = 1; k <= i; k++) {
const maxDrops = 1 + Math.max(dp[k - 1][j - 1], dp[i - k][j]);
dp[i][j] = Math.min(dp[i][j], maxDrops);
}
}
``````

}

// The minimum number of drops required is stored in dp[n][2]
return dp[n][2];
}

console.log(eggDrop(100));

// Leave this here so we can test your code
module.exports = eggDrop;

1 Like
``````const m = new Map();

function eggDrop(n, e = 2){
if (e === 1) {
return n;
}
if (n === 0) {
return 0;
}
if (n === 1) {
return 1;
}
if (m.has(n)) {
return m.get(n);
}
let minimum = n;
for (let i=1; i<=n; i++) {
minimum = Math.min(minimum,
1 + Math.max(eggDrop(n-i, 2), eggDrop(i-1, 1))
)
}
m.set(n, minimum);
return minimum;
}

console.log(eggDrop(100));

// Leave this here so we can test your code
module.exports = eggDrop;
``````