Can you solve this thing that i was asked in php interview? [closed]

Answer 1

Doesn't really test your php knowledge but definitely tests your problems solving skills. I'd say it is a pretty reasonable question to ask at an interview.

function returnCounts($jump,$slip,$height,$walls)
{
   $count = 0;

   while(true)
   {
      $count++;
      $height -= $jump;
      if ($height <= 0)
      {
          return $walls * $count;
      }
      else
      {
          $height += $slip;
      }
   }
}

I haven't tested this, but something like this should work

Answer 2

It's analytic algorithmic task.
Pseudo code :

prisonBreak(x,y,z,t):
  loop t times:           // number of walls
    set x,y,z again for next iteration  //here or at the end.
    while(can jump):      // can jump = x<z where z is adjusted after each jump
      z=jump              // adjust remaining distance after jump.
      countJumps++        // increment jump count.

Answer 3

With some basic algebra you can eliminate the need for any loops:

function findJumps($jump_height, $slip, $wall_height, $walls) {
    return $walls * ($jump_height > $wall_height) ? 1 : ceil(($wall_height - $slip) / ($jump_height - $slip));
}

Explanation:

For every jump the prisoner makes he gains $jump_height but loses $slip in elevation, so his change in elevation can be represented as $jump_height - $slip. To find how many jumps per wall simply divide the wall height by the change in elevation $wall_height / ($jump_height - $slip). Since it's possible that the result of this isn't even, we have to round up with ceil() (Ex. if you jumped 2 feet and the wall was 3 feet high, you'd need to take two jumps to completely clear the wall). The simply multiply this by the number of walls he has to scale.

Answer 4

I would guess they wanted you to figure out that there is a way to do this without writing a loop to "simulate" the prisoner's escape.

Obviously if there were no "slip" it would be trivial --

return ceil($wallheight / $jumpheight) * $walls;

The slip seems to throw a wrench into this equation, but when you consider edge cases it becomes apparent that it can be easily dealt with. What happens if he jumps 5 but slips 4? Suppose a wall height of 10. Jump to 5, slip to 1. Jump to 6, slip to 2. Jump to 7, slip to 3. Jump to 8, slip to 4. Jump to 9, slip to 5. Jump and escape.

So, we can simply remove the jump height from the wall, and then divide the rest by the difference between his jump and his slip (rounding up). Don't forget (as I did!) to add that "last jump" back in!

function count_jumps($jumpheight, $slipheight, $wallheight, $walls) {
    if($jumpheight > $wallheight) return $walls;
    else return (ceil(($wallheight - $jumpheight) / ($jumpheight - $slipheight)) + 1) * $walls;
}

Edit: Fixed.

Edit 2: Note that this function could possibly produce errors or negative results, but they will all be in situations where the return value would be infinite or undefined (slip >= jump). In an interview situation, you should ask your interviewer how they would want those cases handled.

Answer 5

All of the current answers seem to neglect input checking, as some are susceptible to infinite loops.

To prevent this, do some error checking before you attempt to process the input. Here are the two versions I could come up with, the first uses a straightforward loop implementation, the second uses math.

Note: There may still be bugs, I haven't tested them 100%.

function escape( $max_height, $slip, $wall_height, $num_walls)
{
     // Check for infinite loop
     if( ($max_height - $slip) <= 0)
     {
         // Return a value to let caller know an error has occurred
         return -1;
     }
     $jumps = 0;
     while( $num_walls > 0)
     {
         $current_height = 0;
         do
         {
              $current_height += $max_height;
              $jumps++;
         } while( ($wall_height - $current_height) >= 0);
         $num_walls--;
     }
     $jumps = ($wall_height % $max_height == 0) ? ($jumps - 1) : $jumps;
     return $jumps;
}

And now, without loops:

function escape2( $max_height, $slip, $wall_height, $num_walls) 
{
    // Check for valid input
    if( ($max_height - $slip) <= 0)
    {
         return -1;
    }
    if( $wall_height <= 0)
    {
        return 0;
    }
    $jumps = ceil( abs( $wall_height - ($max_height - $slip)));
    return ($jumps == 0) ? $num_walls : ($jumps * $num_walls);
}

Test them out, send me some bug reports. :)