How Fast Can You Skip To Your Favorite Song?

Setup

library(tidyverse)
## -- Attaching packages ------------------- tidyverse 1.3.0 --
## v ggplot2 3.2.1     v purrr   0.3.3
## v tibble  2.1.3     v dplyr   0.8.3
## v tidyr   1.0.0     v stringr 1.4.0
## v readr   1.3.1     v forcats 0.4.0
## -- Conflicts ---------------------- tidyverse_conflicts() --
## x dplyr::filter() masks stats::filter()
## x dplyr::lag()    masks stats::lag()

next_track = function(i){
  if(i == 100) {
    return (1)
  } else {
  return(i+1)
  }
}

random_track = function(){
  return(round(runif(n = 1, min = 1, max = 100)))
}

Find the expected number of button presses if you use 21 as the cutoff for “Next” vs “Random”

There’s a decent amount going on in this next code chunk:

tests_to_repeat = 1000

long_term = NULL
    
    for (i in 1:tests_to_repeat) {
      
      # Initialize starting variables
      
      track_position = random_track()
      button_presses = 0
      
      while (track_position != 42) {
        if  (track_position <= 41 &  track_position >= 21) {
          button_presses = button_presses + 1
          track_position = next_track(track_position)
        } else {
          button_presses = button_presses + 1
          track_position = random_track()
        }
      }
      
      long_term = c(long_term, button_presses)
    }

We’re going to run 1,000 simulations of this, and we’re going to use long_term to track the number of botton presses over the long term.

Inside the for-loop, we will record the track position (starting with a random track) and the number of button presses.

The while-loop runs until we get to track 42. If we’re between 41 and 21 (inclusively), then we hit the “Next” button. If we’re outside of that range, then we take our chances with “Random” and repeat as necessary.

This plot shows the results of our simulations.

plot(long_term, xlab = "Simulation Index", ylab = "Button Presses")
abline(h = mean(long_term))

mean(long_term)
## [1] 14.045

So it takes just over 14 button presses, on average, to get to 42 if your strategy is to “Random” into the range of 21 to 41, and then hit “Next.”

Is 21 the best cutoff?

So we could brute-force the simulations and go one-by-one increasing the cutoff until we get increasing means, or we can loop through the iterations. The only thing is, this type of thing can take a little while, so I decided to leverage my computers multiple cores.

Create clusters

The way these packages handle parallel computing is to create clusters that can initiate an R script. Each cluster then uses a core to run the code. This is the standard way to initialize and register the number of clusters. I’m going to create three clusters to use three of four cores, so hopefully, my laptop will still be useable while this runs.

cl<-makeCluster(3) # change the 2 to the number of CPU cores you want to use
registerDoSNOW(cl)

Foreach loop

Instead of a for-loop, we’re going to write a foreach-loop. Here’s where I read about the basics of foreach https://www.r-bloggers.com/parallel-r-loops-for-windows-and-linux/.

foreach usually results in a list, but we can get it to output a dataframe by adding .combine = 'rbind'. %dopar% is the parallel version of %do%, and the only thing different is that it requires preregistered clusters.

I shouldn’t brush aside that I’m actually recording means instead of all the tests. However, means are consistent, so the mean button presses for a strategy converges on the same number as the mean of test means. So tests_to_repeat is the same as above, and means_to_capture is the number of times I’m going to repeat the code above.

# Initialize starting variables
      
tests_to_repeat = 1000
means_to_capture = 1000

mean_tests = foreach(j=1:41, .combine = 'rbind') %dopar% {
  
  means = NULL
  
  for (k in 1:means_to_capture) {
    
    long_term = NULL
    
    for (i in 1:tests_to_repeat) {
      
      track_position = random_track()
      button_presses = 0
      
      while (track_position != 42) {
        if  (track_position <= 41 &  track_position >= j) {
          button_presses = button_presses + 1
          track_position = next_track(track_position)
        } else {
          button_presses = button_presses + 1
          track_position = random_track()
        }
      }
      
      long_term = c(long_term, button_presses)
    }

    means = vctrs::vec_rbind(means, tibble::tibble(test_iter = k,
                                                   low_cutoff = j,
                                                   mean_steps = mean(long_term)))

  }
  
  means
  
}

Instead of using return(variable), foreach-loops just need you to type the variable name you want to return.

Stop clusters

Now we’ll close our clusters. Eventually, the clusters close after some period of inactivity, but it’s best practice to stop them in the code.

stopCluster(cl)