[프로그래머스_Kotlin] 공원 산책

프로그래머스

 

문제

• 지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.
  
  • ["방향 거리", "방향 거리" … ]
• 예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.
  
  • 주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.
  • 주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.
• 위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다.
• 공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다.

• 공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

 

제한사항

• 3 ≤ park의 길이 ≤ 50
  
  • 3 ≤ park[i]의 길이 ≤ 50
    
    • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
      
      • S : 시작 지점
      • O : 이동 가능한 통로
      • X : 장애물
  • park는 직사각형 모양입니다.
• 1 ≤ routes의 길이 ≤ 50
  
  • routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
  • 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
  • routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
    
    • op는 다음 네 가지중 하나로 이루어져 있습니다.
      
      • N : 북쪽으로 주어진 칸만큼 이동합니다.
      • S : 남쪽으로 주어진 칸만큼 이동합니다.
      • W : 서쪽으로 주어진 칸만큼 이동합니다.
      • E : 동쪽으로 주어진 칸만큼 이동합니다.
    • 1 ≤ n ≤ 9

 

입출력 예

 

 

 

풀이

class Solution {
    fun solution(park: Array<String>, routes: Array<String>): IntArray {
        var answer: IntArray = intArrayOf(0, 0)

        // 시작위치
        park.forEachIndexed { i, s ->
            s.forEachIndexed { j, _ ->
                if (park[i][j] == 'S') {
                    answer = intArrayOf(i, j)
                }
            }
        }

        val direction = hashMapOf<String, IntArray>(
            "E" to intArrayOf(0, 1),
            "W" to intArrayOf(0, -1),
            "S" to intArrayOf(1, 0),
            "N" to intArrayOf(-1, 0)
        )

        routes.forEach { str ->
            //방향, 이동횟수 저장
            val way = direction[str.split(" ")[0]] //E
            val cnt = str.split(" ")[1].toInt() //2
            var x = answer[0]
            var y = answer[1]

            for (j in 1..cnt) {
                x += way?.get(0) ?: 0
                y += way?.get(1) ?: 0

                if (x < 0 || y < 0 || x >= park.size || y >= park[0].length || park[x][y] == 'X') {
                    x = answer[0]
                    y = answer[1]
                    break
                }
            }
            answer[0] = x
            answer[1] = y
        }
        return answer
    }
}

 

해석

// todo 공원크기
// todo 장애물

// todo 시작점 저장
// todo 동서남북 저장 <String-intArray>

//todo routes  나누기 (E 2)

위에 처럼 나눠서 풀어야겠다고 생각했다.

 

        // 시작위치
        park.forEachIndexed { i, s ->
            s.forEachIndexed { j, _ ->
                if (park[i][j] == 'S') {
                    answer = intArrayOf(i, j)
                }
            }
        }

 forEach 연습겸 for문을 사용하지 않았다. Kotlin In Action에서도 for문과 크게 차이가 없다고 해서 사용해봤다.

처음 값의 위치를 answer에 저장한다.

 

val direction = hashMapOf<String, IntArray>(
	"E" to intArrayOf(0, 1),
	"W" to intArrayOf(0, -1),
	"S" to intArrayOf(1, 0),
	"N" to intArrayOf(-1, 0)
)

 routes에 나온 값을 처음 시작 값에 더하면서 풀 생각이여서 동서남북으로 이동하는 값을 저장했다.

 

routes.forEach { str ->
	//방향, 이동횟수 저장
	val way = direction[str.split(" ")[0]] //E
	val cnt = str.split(" ")[1].toInt() //2

 routes의 값을 받는다. way는 방향 알파벳을 받고 cnt는 반복 횟수를 받는다.

 

            var x = answer[0]
            var y = answer[1]

            for (j in 1..cnt) {
                x += way?.get(0) ?: 0
                y += way?.get(1) ?: 0
                if (x < 0 || y < 0 || x >= park.size || y >= park[0].length || park[x][y] == 'X') {
                    x = answer[0]
                    y = answer[1]
                    break
                }
            }
            answer[0] = x
            answer[1] = y

 반복하는걸 설명하자면 x,y에 처음에 시작점을 받고 반복횟수만큼 for문을 돌리면서 x,y에 방향에 대한 값을 받는데

만약 x,y가 공원의 크기를 벗어나거나 'X'(장애물)인 경우 for문을 돌리기 전의 값을 저장해서 break문으로 내보내서 반복문을 종료하고 맞다면 그대로 진행해서 answer값에 저장하도록 하였다.

이것을 routes의 size만큼 반복한다.

 

return answer

 

다른 사람의 풀이

(Jay Kim님)

class Solution {
    private fun findStart(park: Array<String>): MutableList<Int> {
        for (i in park.indices)
            for (j in park[i].indices)
                if (park[i][j] == 'S')
                    return mutableListOf(i, j)
        return mutableListOf(0, 0)
    }

    fun solution(park: Array<String>, routes: Array<String>): IntArray {
        val directions = mapOf('E' to (0 to 1), 'W' to (0 to -1), 'N' to (-1 to 0), 'S' to (1 to 0))
        return routes.map { it[0] to it.drop(2).toInt() }
                .fold(findStart(park)) { pos, (direction, distance) ->
                    val prevPos = pos.toMutableList()
                    val nextPos = pos.toMutableList()
                    repeat(distance) {
                        nextPos[0] += directions[direction]!!.first
                        nextPos[1] += directions[direction]!!.second
                        if (!(0 <= nextPos[0] && nextPos[0] < park.size && 0 <= nextPos[1] && nextPos[1] < park[0].length && park[nextPos[0]][nextPos[1]] != 'X')) 
                            return@fold prevPos
                    }
                    return@fold nextPos
                }.toIntArray()
    }
}