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.

Ask or answer a question about this exercise by clicking reply () below!
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!

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;

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;

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;