Questions about R Programming

Question

I want to know how to write the R code for these:

Consider a game of throwing 2 fair dice at the same time. You win $6 if the total of these 2 dice is greater than or equal to 10; or you lose $1 if the total is less than 10. You start with $50 in your pocket and you stop gambling if you lose all your money or you have $100 or more in your pocket. The following points will guide through the simulation of this game step by step: 

1. Use the digits "1234" as the initial seed, generate 2000 random numbers that mimic the throw of a fair dice as save them to d. 
2. Transform d into a 1000x2 matrix and compute the row total as t. 
3. Compute a reward vector w from t; that is, w=-1 if t<10 or w=6 if t>=10. 
4. Compute a vector x representing the money in your pocket. Plot x with type=”l” and add two horizontal lines at y=0 and y=100. 
5. Write R commands to find out the first time that x=0 or x>=100 respectively.

Answer 1

This simulation models a "gambler's ruin" problem. It uses vectorized operations, which are much faster and more efficient in R than using loops.

1. Set Seed and Generate Dice Rolls

First, you must set the "seed" for the random number generator. This is essential for reproducibility. Using the same seed (1234) ensures that any person who runs this code will get the exact same "random" numbers.

Next, you generate the 2000 dice rolls. We use the sample() function.

1. 1:6 is the set of possible outcomes.
2. 2000 is the number of throws we need.
3. replace = TRUE is critical. It means R "puts the die back" after each roll, so all numbers remain equally likely.

2. Create Matrix and Compute Totals

The vector d is a simple list of 2000 numbers. The problem requires 1000 games, with 2 dice per game. We must transform d into a 1000-row, 2-column matrix. R fills matrices by column by default. The first 1000 rolls will be Die 1 (column 1). The next 1000 rolls will be Die 2 (column 2).

We then use rowSums() to get the total for each game (row). The result t is a vector with 1000 elements.

3. Compute Reward Vector

Now we create a reward vector w. This vector must map the totals in t to the game's outcome.

1. If t >= 10, the reward w is 6.
2. If t < 10, the reward w is -1.

We use the ifelse() function. This is a fast, vectorized conditional test. It checks every element in t and builds the w vector accordingly.

4. Compute and Plot Pocket Money

This is the most important step. We must track the money in the gambler's pocket. This is a cumulative sum of the rewards.

The gambler starts with $50. The vector x must show this starting state, followed by the state after each game.

1. cumsum(w) creates a vector of the net winnings after each game.
2. We add 50 to this vector to get the total money in the pocket.
3. We use c(50, ...) to prepend the $50 starting value. This represents the state at "Game 0".
4. The final vector x will have 1001 elements: the starting state, plus the 1000 post-game states.
5. We then plot x using type = "l" for a line graph. Finally, abline() adds horizontal lines (h) for the stop conditions, using a dashed line type (lty = 2).

5. Find the Stopping Times

1. The simulation runs for 1000 games. Now we find the first time the gambler would have stopped.
2. We use the which() function. which() returns the index of all elements that meet a condition.
3. which(x == 0) finds all indices where x is 0.
4. which(x >= 100) finds all indices where x is 100 or more.
5. We only want the first time, so we select the first result with [1]. If the condition never occurs, which() returns an empty vector and [1] will result in NA (Not Available).
6. Important: Our x vector has 1001 elements. x[1] is the starting money (Game 0). x[2] is the money after Game 1. Therefore, the Game Number is the Index - 1.