Merge pull request kodecocodes#400 from aarkalyk/master

Egg Drop Dynamic Problem

Author: kelvinlauKL

Egg Drop Problem/EggDrop.playground/Contents.swift

@@ -0,0 +1,9 @@
+ //: Playground - noun: a place where people can play
+
+import Cocoa
+
+eggDrop(numberOfEggs: 2, numberOfFloors: 2) //expected answer: 2
+eggDrop(numberOfEggs: 2, numberOfFloors: 4) //expected answer: 3
+eggDrop(numberOfEggs: 2, numberOfFloors: 6) //expected answer: 3
+eggDrop(numberOfEggs: 5, numberOfFloors: 5) //expected answer: 2
+eggDrop(numberOfEggs: 5, numberOfFloors: 20) //expected answer: 4

Egg Drop Problem/EggDrop.playground/Sources/EggDrop.swift

@@ -0,0 +1,39 @@
+public func eggDrop(numberOfEggs: Int, numberOfFloors: Int) -> Int {
+    if numberOfEggs == 0 || numberOfFloors == 0{ //edge case: When either number of eggs or number of floors is 0, answer is 0
+        return 0
+    }
+    if numberOfEggs == 1 || numberOfFloors == 1{ //edge case: When either number of eggs or number of floors is 1, answer is 1
+        return 1
+    }
+    
+    var eggFloor = [[Int]](repeating: [Int](repeating: 0, count: numberOfFloors+1), count: numberOfEggs+1) //egg(rows) floor(cols) array to store the solutions
+    var attempts: Int = 0
+    
+    for var floorNumber in (0..<(numberOfFloors+1)){
+        eggFloor[1][floorNumber] = floorNumber      //base case: if there's only one egg, it takes 'numberOfFloors' attempts
+    }
+    eggFloor[2][1] = 1 //base case: if there are two eggs and one floor, it takes one attempt
+    
+    for var eggNumber in (2..<(numberOfEggs+1)){
+        for var floorNumber in (2..<(numberOfFloors+1)){
+            eggFloor[eggNumber][floorNumber] = Int.max   //setting the final result a high number to find out minimum
+            for var visitingFloor in (1..<(floorNumber+1)){
+                //there are two cases
+                //case 1: egg breaks. meaning we'll have one less egg, and we'll have to go downstairs -> visitingFloor-1
+                //case 2: egg doesn't break. meaning we'll still have 'eggs' number of eggs, and we'll go upstairs -> floorNumber-visitingFloor
+                attempts = 1 + max(eggFloor[eggNumber-1][visitingFloor-1], eggFloor[eggNumber][floorNumber-visitingFloor])//we add one taking into account the attempt we're taking at the moment
+                
+                if attempts < eggFloor[eggNumber][floorNumber]{ //finding the min
+                    eggFloor[eggNumber][floorNumber] = attempts;
+                }
+            }
+        }
+    }
+    
+    return eggFloor[numberOfEggs][numberOfFloors]
+}
+
+//Helper function to find max of two integers
+public func max(_ x1: Int, _ x2: Int) -> Int{
+    return x1 > x2 ? x1 : x2
+}

Egg Drop Problem/EggDrop.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='macos'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Egg Drop Problem/EggDrop.swift

@@ -0,0 +1,39 @@
+public func eggDrop(numberOfEggs: Int, numberOfFloors: Int) -> Int {
+    if numberOfEggs == 0 || numberOfFloors == 0{ //edge case: When either number of eggs or number of floors is 0, answer is 0
+        return 0
+    }
+    if numberOfEggs == 1 || numberOfFloors == 1{ //edge case: When either number of eggs or number of floors is 1, answer is 1
+        return 1
+    }
+    
+    var eggFloor = [[Int]](repeating: [Int](repeating: 0, count: numberOfFloors+1), count: numberOfEggs+1) //egg(rows) floor(cols) array to store the solutions
+    var attempts: Int = 0
+    
+    for var floorNumber in (0..<(numberOfFloors+1)){
+        eggFloor[1][floorNumber] = floorNumber      //base case: if there's only one egg, it takes 'numberOfFloors' attempts
+    }
+    eggFloor[2][1] = 1 //base case: if there are two eggs and one floor, it takes one attempt
+    
+    for var eggNumber in (2..<(numberOfEggs+1)){
+        for var floorNumber in (2..<(numberOfFloors+1)){
+            eggFloor[eggNumber][floorNumber] = Int.max   //setting the final result a high number to find out minimum
+            for var visitingFloor in (1..<(floorNumber+1)){
+                //there are two cases
+                //case 1: egg breaks. meaning we'll have one less egg, and we'll have to go downstairs -> visitingFloor-1
+                //case 2: egg doesn't break. meaning we'll still have 'eggs' number of eggs, and we'll go upstairs -> floorNumber-visitingFloor
+                attempts = 1 + max(eggFloor[eggNumber-1][visitingFloor-1], eggFloor[eggNumber][floorNumber-visitingFloor])//we add one taking into account the attempt we're taking at the moment
+                
+                if attempts < eggFloor[eggNumber][floorNumber]{ //finding the min
+                    eggFloor[eggNumber][floorNumber] = attempts;
+                }
+            }
+        }
+    }
+    
+    return eggFloor[numberOfEggs][numberOfFloors]
+}
+
+//Helper function to find max of two integers
+public func max(_ x1: Int, _ x2: Int) -> Int{
+    return x1 > x2 ? x1 : x2
+}

Egg Drop Problem/README.markdown

@@ -0,0 +1,64 @@
+# Egg Drop Dynamic Problem
+
+## Problem Description 
+
+Given some number of floors and some number of eggs, what is the minimum number of attempts it will take to find out from which floor egg will break.
+
+Suppose that we wish to know which stories in a 36-story building are safe to drop eggs from, and which will cause the eggs to break on landing. We make a few assumptions:
+
+- An egg that survives a fall can be used again.
+- A broken egg must be discarded.
+- The effect of a fall is the same for all eggs.
+- If an egg breaks when dropped, then it would break if dropped from a higher floor.
+- If an egg survives a fall then it would survive a shorter fall.
+
+If only one egg is available and we wish to be sure of obtaining the right result, the experiment can be carried out in only one way. Drop the egg from the first-floor window; if it survives, drop it from the second floor window. Continue upward until it breaks. In the worst case, this method may require 36 droppings. Suppose 2 eggs are available. What is the least number of egg-droppings that is guaranteed to work in all cases?
+The problem is not actually to find the critical floor, but merely to decide floors from which eggs should be dropped so that total number of trials are minimized.
+
+## Solution
+- eggNumber -> Number of eggs at the moment
+- floorNumber -> Floor number at the moment
+- visitingFloor -> Floor being visited at the moment
+- attempts -> Minimum number of attempts it will take to find out from which floor egg will break
+
+We store all the solutions in a 2D array. Where rows represents number of eggs and columns represent number of floors. 
+
+First, we set base cases:
+1) If there's only one egg, it takes as many attempts as number of floors
+2) If there are two eggs and one floor, it takes one attempt
+
+```swift
+for var floorNumber in (0..<(numberOfFloors+1)){
+eggFloor[1][floorNumber] = floorNumber      //base case 1: if there's only one egg, it takes 'numberOfFloors' attempts
+}
+
+eggFloor[2][1] = 1 //base case 2: if there are two eggs and one floor, it takes one attempt
+```
+
+When we drop an egg from a floor 'floorNumber', there can be two cases (1) The egg breaks (2) The egg doesn’t break.
+
+1) If the egg breaks after dropping from 'visitingFloorth' floor, then we only need to check for floors lower than 'visitingFloor' with remaining eggs; so the problem reduces to 'visitingFloor'-1 floors and 'eggNumber'-1 eggs.
+2) If the egg doesn’t break after dropping from the 'visitingFloorth' floor, then we only need to check for floors higher than 'visitingFloor'; so the problem reduces to floors-'visitingFloor' floors and 'eggNumber' eggs.
+
+Since we need to minimize the number of trials in worst case, we take the maximum of two cases. We consider the max of above two cases for every floor and choose the floor which yields minimum number of trials.
+
+We find the answer based on the base cases and previously found answers as follows. 
+```swift
+attempts = 1 + max(eggFloor[eggNumber-1][floors-1], eggFloor[eggNumber][floorNumber-floors])//we add one taking into account the attempt we're taking at the moment
+
+if attempts < eggFloor[eggNumber][floorNumber]{ //finding the min
+    eggFloor[eggNumber][floorNumber] = attempts;
+}
+```
+## Example
+Let's assume we have 2 eggs and 2 floors.
+1) We drop one egg from the first floor. If it breaks, then we get the answer. If it doesn't we'll have 2 eggs and 1 floors to work with.
+    attempts = 1 + maximum of 0(got the answer) and eggFloor[2][1] (base case 2 which gives us 1)
+    attempts = 1 + 1 = 2
+2) We drop one egg from the second floor. If it breaks, we'll have 1 egg and 1 floors to work with. If it doesn't, we'll get the answer.
+    attempts = 1 + maximum of eggFloor[1][1](base case 1 which gives us 1) and 0(got the answer)
+    attempts = 1 + 1 = 2
+3) Finding the minimum of 2 and 2 gives us 2, so the answer is 2. 
+   2 is the minimum number of attempts it will take to find out from which floor egg will break.
+
+