I tried to simplify the solution for this easy LC problem but I guess this could’ve been the simplest I can get to. Not a beautiful code but this’ll do for now.

class Solution {
fun numRookCaptures(board: Array<CharArray>): Int {
var rookPos: Pair<Int, Int>? = null

for(index in 0 until board.size){
for(subIndex in 0 until board.size){
if(board[subIndex][index] == 'R'){
rookPos = Pair(subIndex, index)
break
}else if(board[index][subIndex] == 'R'){
rookPos = Pair(index, subIndex)
break
}
}

if(rookPos != null) break
}

val currentX = rookPos!!.second
val currentY = rookPos!!.first

var directions = intArrayOf(currentX - 1, currentY - 1, currentX + 1, currentY + 1)
var state = booleanArrayOf(true, true, true, true)

var pCount = 0

while(state[0] || state[1] || state[2] || state[3]){

(0..1).forEach { if(directions[it] < 0) state[it] = false }
(2..3).forEach { if(directions[it] > board.size - 1) state[it] = false }

// check left
pCount += check(state, 0, board, directions[0], currentY, directions, 0, false)

// check top
pCount += check(state, 1, board, currentX, directions[1], directions, 1, false)

// check right
pCount += check(state, 2, board, directions[2], currentY, directions, 2, true)

// check down
pCount += check(state, 3, board, currentX, directions[3], directions, 3, true)

}

return pCount
}

fun check(state: BooleanArray, stateIndex: Int,
board: Array<CharArray>,
boardX: Int,
boardY: Int, direction: IntArray,
directionIndex: Int, increment: Boolean) : Int{
var output = 0

if(state[stateIndex]) {
if(board[boardY][boardX] == 'p'){
state[stateIndex] = false
output++
}else if(board[boardY][boardX] == 'B'){
state[stateIndex] = false
}else{
if(increment) direction[directionIndex]++ else direction[directionIndex]--
}
}

return output
}
}


The first two loops will try to find the location of our Rook. Since this is an N*N matrix, we can simultaneously find our Rook from both horizontal and vertical directions. Once we found our Rook, then we simultaneously traverse in all directions and look for pawns. If we hit a bishop, a pawn or reached the edge of the board then we stop finding for that particular direction. Everytime we hit a pawn, we increment a counter which will be our final output.

Runtime: 128 ms, faster than 90.91% of Kotlin online submissions for Available Captures for Rook.
Memory Usage: 31.7 MB, less than 100.00% of Kotlin online submissions for Available Captures for Rook.