Day11-Seating_System

EmptySeats <- read.table("day11.csv")
EmptySeats <- as.vector(EmptySeats[,1])

SeatMap <- matrix(data = NA, nrow = length(EmptySeats)+2, ncol = nchar(EmptySeats[1])+2)

for (i in 1:(nrow(SeatMap)-2)) {    # Keeps 1st and last line NA.
    SeatMap[i+1,] <- c(NA, unlist(strsplit(EmptySeats[i], "")), NA)
}

SeatMap <- apply(SeatMap, c(1,2), function(x) x <- ifelse(x=="L", 0, NA))

ChangeState <- function (data) {
    
    ROWS <- nrow(data)
    COLS <- ncol(data)
    
    SeatState <- matrix(NA, ROWS, COLS)
    
    for (j in 2:(COLS-1)) {
        for (i in 2:(ROWS-1)) {
            SumNeighbors <- sum(c(data[i,j-1], data[i,j+1], data[i-1,j], data[i+1,j],
                                  data[i-1,j-1], data[i-1,j+1],
                                  data[i+1,j-1], data[i+1,j+1]), na.rm = TRUE)
            if(is.na(data[i,j])) {
                SeatState[i,j] <- NA
            } else {
            if((data[i,j] == 0) & SumNeighbors == 0) {
                SeatState[i,j] <- 1
            } else {
            if((data[i,j] == 1) & SumNeighbors >= 4) {
                SeatState[i,j] <- 0
            } else {
                SeatState[i,j] <- data[i,j]
              }}}
    }}
    
    return (SeatState)
}


# PART 1: How Many Seats are Occupied in equilibrium?
StateA <- ChangeState(SeatMap)
StateB <- ChangeState(StateA)
counter <- 0
while (!identical(StateB, StateA) & counter < 100) {
    StateB <- ChangeState(StateA)
    counter <- counter +1
    if(identical(StateB, StateA)) { 
        break 
    }  else {
            StateA <- ChangeState(StateB)
            counter <- counter +1
    }    }

sum(ChangeState(StateB), na.rm = TRUE)

# PART 2: New Rules, same question!

SeatVision <- function(data, i, j) {
# Returns what is seen at the (i, j) position, in each of the 8 directions

    Fr <- data[(i-1):1, j] # look front
    Bk <- data[(i+1):nrow(data), j] # look back
    Lf <- data[i, (j-1):1] # look left
    Rt <- data[i, (j+1):ncol(data)] # look right
    
    MaxVals <- c(min(nrow(data)-i,ncol(data)-j), min(i-1,j-1), 
                 min(i-1,ncol(data)-j), min(nrow(data)-i,j-1))
    MaxMaxV <- max(c(length(Fr), length(Bk), length(Lf), length(Rt), MaxVals))
    
    VisionFull <- matrix(NA, nrow = MaxMaxV, ncol = 8)
    for (k in 1:length(Fr)) { VisionFull[k,1] <- Fr[k]}
    for (k in 1:length(Bk)) { VisionFull[k,2] <- Bk[k]}
    for (k in 1:length(Lf)) { VisionFull[k,3] <- Lf[k]}
    for (k in 1:length(Rt)) { VisionFull[k,4] <- Rt[k]}
    
    for(k in 1:MaxVals[1]) { VisionFull[k,5] <- data[(i+k),(j+k)] } # back right
    for(k in 1:MaxVals[2]) { VisionFull[k,6] <- data[(i-k),(j-k)] } # front left
    for(k in 1:MaxVals[3]) { VisionFull[k,7] <- data[(i-k),(j+k)] } # front right
    for(k in 1:MaxVals[4]) { VisionFull[k,8] <- data[(i+k),(j-k)] } # back left    
    
    return (VisionFull) # where there is no seat/floor anymore, considers floor
}

NewChangeState <- function (data) {
    ROWS <- nrow(data)
    COLS <- ncol(data)
    
    SeatState <- matrix(NA, ROWS, COLS)
    
    for (j in 2:(COLS-1)) {
        for (i in 2:(ROWS-1)) {
            
            if(is.na(data[i,j])) {
                SeatState[i,j] <- NA
            } else {            
            
            VisibleSeats <- SeatVision(data, i, j)
            
            ActualSeatVision <- apply(VisibleSeats, 2, function(x) { # Returns what is seen
                k = 1                                                # on each direction:
                while(is.na(x[k])& k < nrow(VisibleSeats)){ k = k+1 }# Floor (NA), empty(0),
                x[k] })                                              # occupied(1)
            
            SumVisible <- sum(ActualSeatVision, na.rm = TRUE)
            
                if((data[i,j] == 0) & SumVisible == 0) {
                    SeatState[i,j] <- 1
                } else {
                    if((data[i,j] == 1) & SumVisible >= 5) {
                        SeatState[i,j] <- 0
                    } else {
                        SeatState[i,j] <- data[i,j]
                    }}}
        }}
    
   return (SeatState)
}

NewStateA <- NewChangeState(SeatMap)
NewStateB <- NewChangeState(NewStateA)
counter <- 0
while (!identical(NewStateB, NewStateA) & counter < 100) {
    NewStateB <- NewChangeState(NewStateA)
    counter <- counter +1
    if(identical(NewStateB, NewStateA)) { 
        break 
    }  else {
        NewStateA <- NewChangeState(NewStateB)
        counter <- counter +1
    }    }

sum(NewChangeState(NewStateB), na.rm = TRUE)