Implement a Flappy Bird Jump Agent
Company: Coinbase
Role: Software Engineer
Category: Coding & Algorithms
Interview Round: Technical Screen
Implement a function `should_jump(state) -> bool` for a simplified Flappy Bird game.
The bird has a fixed horizontal position `bird_x` and a vertical position `bird_y`. Smaller `y` means the bird is higher on the screen. The current game state contains:
- `bird_y`: current vertical position
- `bird_v`: current vertical velocity
- `bird_x`: current horizontal position
- `screen_height`: height of the screen
- `next_pipe`: an object with:
- `x`: left edge of the next pipe
- `width`: pipe width
- `gap_top`: top boundary of the gap
- `gap_bottom`: bottom boundary of the gap
Game physics:
- If the bird jumps on the current frame, its velocity becomes `-8`.
- Gravity is `+1` per frame.
- Each frame updates in this order:
1. `y += v`
2. `v += 1`
- The pipe moves left by `1` unit per frame.
- The bird dies if it goes outside the screen bounds or hits a pipe.
- A collision with the pipe happens when the bird's `x` lies within the pipe's horizontal range and the bird's `y` is not strictly inside the gap `(gap_top, gap_bottom)`.
Return `true` if the bird should jump on the current frame, or `false` otherwise.
Your policy should be deterministic and should prioritize survival, especially when the bird is close to the ground or approaching the next pipe at an unsafe height.
Quick Answer: This question evaluates discrete-time physics simulation, real-time decision-making under constraints, collision detection, and deterministic control-policy design that prioritizes survival.
Write a function `solution(state) -> bool` for a simplified Flappy Bird game. The return value should say whether the bird should jump on the current frame.
To make the behavior fully testable, use this exact deterministic policy:
1. Simulate the future twice: once with no jump now, and once with a jump now.
2. In the jump simulation, set the bird's velocity to `-8` before the first simulated frame.
3. Each simulated frame updates in this order: `y += v`, then `v += 1`, then the next pipe moves left by `1`.
4. After those updates, the bird dies if:
- `y < 0` or `y >= screen_height`, or
- the bird is inside the pipe's horizontal range and its `y` is not strictly inside the gap.
5. Treat the pipe's horizontal range as half-open: `[pipe_x, pipe_x + width)`.
6. Stop a simulation as soon as the bird dies or the bird has passed the pipe, meaning `pipe_x + width <= bird_x`.
7. Choose `True` if jumping survives for more simulated frames than not jumping.
8. If both choices survive for the same number of frames, choose the action whose bird gets closer to the center of the gap during any overlapping frame. Use the minimum value of `abs(y - gap_center)` over all frames where the bird horizontally overlaps the pipe.
9. If the two choices are still tied, return `False`.
This policy prioritizes survival while still making a deterministic choice when both actions look equally safe.