Lesson 3

Welcome! This lesson involves a thrilling task that combines basic operations with array manipulation in Java. We will be implementing a **"Move Until Obstacle"** game using an integer array. Visualize yourself as a game developer, and get ready to delve into the exciting world of problem-solving!

In the "Move Until Obstacle" game, the player begins at the start of a linear `ArrayList`

of integers. The number at each position indicates how many steps a player can move to the right. An obstacle number is one upon which the player cannot land. The goal is to move as far to the right as possible until either an obstacle stops the player or the player reaches the end of the `ArrayList`

.

Your function, `public static int solution(ArrayList<Integer> numbers, int obstacle)`

, should tally and return the number of moves needed to reach the end of the `ArrayList`

without encountering an obstacle. If the player encounters an obstacle, the function should return the index at which this obstacle lies.

For example, if the function receives the input: `numbers = new ArrayList<>(Arrays.asList(2, 3, 3, 4, 2, 4))`

and `obstacle = 4`

, it should return `5`

. This is because the player starts at the 0th index, takes 2 steps as indicated by the number at the 0th index (landing on the 2nd index), and then takes 3 more steps as indicated by the number at the 2nd index to land on the 5th index, which is the obstacle `4`

.

If the function receives the following input: `numbers = new ArrayList<>(Arrays.asList(4, 1, 2, 2, 4, 2, 2))`

and `obstacle = 2`

, the output should be `2`

. The player starts at the 0th index, takes 4 steps, lands on the 4th index, then takes 4 more steps, which brings the player outside the `ArrayList`

, so the total number of steps the player takes is `2`

.

Our first step is to ensure we have variables to track the player, i.e., their current position and the moves they've taken so far. We'll name them `position`

and `moves`

, initializing both to `0`

:

Java`1public static int solution(ArrayList<Integer> numbers, int obstacle) { 2 int position = 0; 3 int moves = 0;`

Next, we'll use a while loop to iterate over the `ArrayList`

. It continues as long as `position`

is less than the size of the `ArrayList`

`numbers`

, which we obtain using `numbers.size()`

:

Java`1public static int solution(ArrayList<Integer> numbers, int obstacle) { 2 int position = 0; 3 int moves = 0; 4 while (position < numbers.size()) {`

During each iteration, we need to check whether the player has encountered an obstacle. If so, we should return the `position`

at which this obstacle is located:

Java`1public static int solution(ArrayList<Integer> numbers, int obstacle) { 2 int position = 0; 3 int moves = 0; 4 while (position < numbers.size()) { 5 if (numbers.get(position) == obstacle) { 6 return position; 7 }`

If the current number is not an obstacle, the player proceeds. The number of steps taken corresponds to the value at the current `position`

. We add this to `position`

and increment `moves`

:

Java`1public static int solution(ArrayList<Integer> numbers, int obstacle) { 2 int position = 0; 3 int moves = 0; 4 while (position < numbers.size()) { 5 if (numbers.get(position) == obstacle) { 6 return position; 7 } 8 moves++; 9 position += numbers.get(position); 10 }`

Once the loop ends, the player either has reached the end of the `ArrayList`

or has encountered an obstacle. If the player managed to navigate the entirety of the `ArrayList`

without encountering an obstacle, we want to return the total number of `moves`

:

The complete function looks like this:

Java`1import java.util.ArrayList; 2import java.util.Arrays; 3 4public class MoveUntilObstacleGame { 5 public static int solution(ArrayList<Integer> numbers, int obstacle) { 6 int position = 0; 7 int moves = 0; 8 9 while (position < numbers.size()) { 10 // Check for obstacle at the current position 11 if (numbers.get(position) == obstacle) { 12 return position; // Return the index of the obstacle 13 } 14 // Increment moves and update position 15 moves++; 16 position += numbers.get(position); // Move to the next position 17 } 18 19 // If loop ends without obstacles, return total moves taken 20 return moves; 21 } 22 23 public static void main(String[] args) { 24 System.out.println(solution(new ArrayList<>(Arrays.asList(2, 3, 3, 4, 2, 4)), 4)); 25 } 26}`

Congratulations on successfully implementing the "Move Until Obstacle" game using Java! You've navigated the challenges of this task by applying basic `ArrayList`

manipulation concepts and operations with numbers in Java. Celebrate your achievements, but don't stop there! Up next, we have practice sessions filled with similar exercises to reinforce your understanding and skills. So, gear up and let's keep moving!