Setup

Lets generate some helper functions. I figure I need to create random turns based on the available diretions and then repeat the process 10 times. I quickly documented these helpers.

library(dplyr)
options(stringsAsFactors = FALSE)

# Generate valid turn options
# Requires a character argument
# returns a character vector
turn_options <- function(direction){
  
  if(!direction %in% c("North", "East", "South", "West")){
    message("Invalid Direction.  Try 'North', 'South', 'East' or 'West'")
  } else {
  if(direction == "North"){options <- c("West", "North", "East")}
  if(direction == "East"){options <- c("North", "East", "South")}
  if(direction == "South"){options <- c("East", "South", "West")}
  if(direction == "West"){options <- c("South", "West", "North")}
  return(options)
  }
}

# Take a direction and  make a random turn
# Requires a character input
# Returns a character (direction you are heading)
turn_random <- function(direction) {
  turn.options <- turn_options(direction)
  result <- sample(turn.options, 1)
  return(result)
    
}

# Randomly turn ten times and see where you end up
# Dont love while loop, but hey its quick
turn_10_times <- function(initial.direction = "North"){
  
  turn.result <- turn_random(initial.direction)
  count <- 1
  while(count < 10){
    turn.result <- turn_random(turn.result)
    count <- count + 1
  }
  return(turn.result)
}

Now that we have some helpers, lets generate some simulations. First, we’ll start by simply generating results, adn then seeing the perecnt change of driving North.

trial.count <- 100000
sim <- tibble::tibble(
  trial = 1:trial.count,
  outcome = base::replicate(trial.count, turn_10_times())
) 
sim$outcome %>% janitor::tabyl() %>% janitor::adorn_pct_formatting()
##      .     n percent
##   East 24977   25.0%
##  North 24949   24.9%
##  South 24938   24.9%
##   West 25136   25.1%
result <- sim %>% 
  summarise(chance.north = sum(ifelse(outcome == "North", 1, 0)) / n())

Looks like there is a 0.25% chance of still heading north.

New Helper Functions

This was done quickly, and I spent less time documenting my code. There is LOADS of room for improvement here.

# Genenrate actual path of simulation
# Lots of quick code at the end to create data format I wanted
turn_10_times_path <- function(initial.direction = "North"){
  path <- tibble::tibble(
    start  = "start",  
    turn1  = turn_random(initial.direction),
    turn2  = turn_random(turn1),
    turn3  = turn_random(turn2),
    turn4  = turn_random(turn3),
    turn5  = turn_random(turn4),
    turn6  = turn_random(turn5),
    turn7  = turn_random(turn6),
    turn8  = turn_random(turn7),
    turn9  = turn_random(turn8),
    turn10 = turn_random(turn9),
  ) %>% 
    t() %>% 
    as.data.frame() %>%
    tibble::rownames_to_column() %>% 
    setNames(c("Turn", "Path")) 
  return(path)
}

add_x_coords <- function(dataset, num.turns){
  result.vector <- c(0)
  x <- 0
  for(row in 2:num.turns){
    direction <- dataset$Path[row]
    if(direction == "East"){x <- x + 1}
    if(direction == "West"){x <- x - 1}
    result.vector <- append(result.vector, x)
  }
  dataset <- dataset %>% 
    mutate(x = result.vector)
  return(dataset)
}

add_y_coords <- function(dataset, num.turns){
  result.vector <- c(0)
  y <- 0
  for(row in 2:num.turns){
    direction <- dataset$Path[row]
    if(direction == "North"){y <- y + 1}
    if(direction == "South"){y <- y - 1}
    result.vector <- append(result.vector, y)
  }
  dataset <- dataset %>% 
    mutate(y = result.vector)
  return(dataset)
}

generate_one_scenario <- function(number.turns = 10, trial.input = 1){
  dat <- turn_10_times_path() %>% 
    add_x_coords(num.turns = number.turns+1) %>% 
    add_y_coords(num.turns = number.turns+1) %>% 
    mutate(trial = trial.input) %>% 
    select(trial, everything())
  return(dat)
}

generate_many_trials <- function(trial.count) {
  df.out <- generate_one_scenario()
  trial <- 1
  for(trials in 1:(trial.count-1)){
    trial <- trial + 1
    result.df <- generate_one_scenario(trial.input = trial)
    df.out <- rbind(df.out, result.df)
  }
  return(df.out)
}

library(ggplot2)
trial.count <- 1000
sim <- generate_many_trials(trial.count)
sim %>% 
  ggplot(aes(x, y, group = trial, color = trial)) + 
  geom_path(alpha= 0.05) +
  geom_point(aes(x,y), 
             data = sim %>% 
               filter(Turn == "turn10") %>% 
               add_count(x,y),
             alpha = 0.02,
             color="red") +
  geom_point(aes(x = 0, y =0), color = "darkgreen", size = 4.5) +
  theme_minimal() +
  xlim(-10, 10) +
  ylim(-10, 10) +
  labs(title = "Path taken for each trial",
       subtitle = "Green dot represents starting point, red dots ending point."
       ) +
  theme(legend.position = "none") 

There we go! It might be interesting to see the path from each trip, but for now I just have the start and ending points. It’s rough, but glad to have actually ‘written’ a blog post again.