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

 

https://school.programmers.co.kr/learn/courses/30/lessons/172928

프로그래머스

 

 

 

시도 

import java.util.*;

class Solution {
    
    public int[] solution(String[] park, String[] routes) {
        
        int row_len = park.length;
        int col_len = park[0].length();
        
        //park 1차원 배열 2차원 배열로 변환
        char park_two[][] = new char[row_len][col_len];
        
        for(int i=0; i<park.length; i++) {
            for(int j=0; j<park[i].length(); j++) {
                park_two[i][j] = park[i].charAt(j);
            }
        }
        
        //시작 지점 찾기 
        int start_row = 0;
        int start_col = 0;
        for(int i=0; i<park_two.length; i++) {
            for(int j=0; j<park_two[i].length; j++) {
                if(park_two[i][j] =='S') {
                    start_row = i;
                    start_col = j;
                }
            }
        }
        
        
        //명령어 실행 
        for(int i=0; i<routes.length; i++) {
            char op = routes[i].charAt(0);
            int n = Integer.parseInt(routes[i].substring(2).trim()); // 명령어에서 거리를 추출
            
            if(op == 'N') {
                for(int j = 1; j <= n; j++) {
                    if(start_row - 1 >= 0 && park_two[start_row - 1][start_col] == 'O') {
                        park_two[start_row][start_col] = 'O'; // 이동 전 위치를 통로로 표시
                        start_row -= 1; // 이동
                        park_two[start_row][start_col] = 'S'; // 이동 후 위치를 출발지로 설정
                    } else {
                        break; // 범위를 벗어나거나 벽이 있는 경우 이동 중단
                    }
                }
            } else if(op == 'S') {
                for(int j = 1; j <= n; j++) {
                    if(start_row + 1 < row_len && park_two[start_row + 1][start_col] == 'O') {
                        park_two[start_row][start_col] = 'O'; // 이동 전 위치를 통로로 표시
                        start_row += 1; // 이동
                        park_two[start_row][start_col] = 'S'; // 이동 후 위치를 출발지로 설정
                    } else {
                        break; // 범위를 벗어나거나 벽이 있는 경우 이동 중단
                    }
                }
            } else if(op=='W') {
                for(int j = 1; j <= n; j++) {
                    if(start_col - 1 >= 0 && park_two[start_row][start_col - 1] == 'O') {
                        park_two[start_row][start_col] = 'O'; // 이동 전 위치를 통로로 표시
                        start_col -= 1; // 이동
                        park_two[start_row][start_col] = 'S'; // 이동 후 위치를 출발지로 설정
                    } else {
                        break; // 범위를 벗어나거나 벽이 있는 경우 이동 중단
                    }
                }
            } else if(op=='E') {
                for(int j = 1; j <= n; j++) {
                    if(start_col + 1 < col_len && park_two[start_row][start_col + 1] == 'O') {
                        park_two[start_row][start_col] = 'O'; // 이동 전 위치를 통로로 표시
                        start_col += 1; // 이동
                        park_two[start_row][start_col] = 'S'; // 이동 후 위치를 출발지로 설정
                    } else {
                        break; // 범위를 벗어나거나 벽이 있는 경우 이동 중단
                    }
                }
            }
        }
        
        return new int[]{start_row, start_col};
        
    }
}

 

 

 

 

프로그래머스 - 공원 산책(Java, 자바) (tistory.com)

프로그래머스 - 공원 산책(Java, 자바)

 

 

정답 

 

import java.util.*;

class Solution {
    public static char grid[][];
    public static HashMap<String, int[]> dir;
    public static int[] answer;
    
    public static void move(String op, int step)
    {
        int x = answer[1];
        int y = answer[0];
        
        for(int i=0; i<step; i++)
        {
            int d[] = dir.get(op);
            x+=d[1];
            y+=d[0];
            
            if(x>=0 && y>=0 && x<grid[0].length&& y<grid.length)
            {
                if(grid[y][x] == 'X')
                {
                    return;
                }
            }
            else
            {
                return;
            }
        }
        
        answer[0] = y;
        answer[1] = x;
    }
    
    public int[] solution(String[] park, String[] routes) {
        answer = new int[2];
        int height = park.length;
        int width = park[0].length();
        
        //park 배열 2차원 배열로 변경하고 시작 위치 찾기 
        grid = new char[height][width];
        
        for(int i=0; i<height; i++)
        {
            for(int j=0; j<width; j++)
            {
                grid[i][j] = park[i].charAt(j);
                if(grid[i][j] == 'S')
                {
                    answer[0] = i;
                    answer[1] = j;
                }
            }
        }
        
        //이동 방향 
        dir = new HashMap<>();
        dir.put("E", new int[]{0,1});
        dir.put("W", new int[]{0,-1});
        dir.put("S", new int[]{1,0});
        dir.put("N", new int[]{-1,0});
        
        for(String route : routes)
        {
            String op = route.split(" ")[0];
            int step = Integer.parseInt(route.split(" ")[1]);
            move(op,step);
        }
        
        return answer;
    }
}

 

 

 

다른 사람의 풀이 

 

import java.util.*;

class Solution {
    public int[] solution(String[] park, String[] routes) {
        int m = park.length;
        int n = park[0].length();
        int curX = 0;
        int curY = 0;

        char[][] grid = new char[m][n];


        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                grid[i][j] = park[i].charAt(j);
                if (grid[i][j] == 'S') {
                    curX = i;
                    curY = j;
                }
            }
        }


        int[] dx = { -1, 1, 0, 0 };
        int[] dy = { 0, 0, -1, 1 };
        
        // 이동 방향을 문자에서 숫자로 매핑하는 맵을 생성합니다.
        HashMap<Character, Integer> map = new HashMap<>();
        map.put('N', 0);
        map.put('S', 1);
        map.put('W', 2);
        map.put('E', 3);

        // 주어진 이동 명령에 따라 이동합니다.
        for (String command : routes) {
            // 이동 방향과 거리를 추출합니다.
            char op = command.charAt(0);
            int move = command.charAt(2) - '0';

            // 이동 후 위치를 계산합니다.
            int nextX = curX;
            int nextY = curY;
            boolean isOK = true;
            for (int i = 0; i < move; i++) {
                nextX += dx[map.get(op)];
                nextY += dy[map.get(op)];

                // 이동한 위치가 주차장을 벗어나거나 장애물에 막혔는지 확인합니다.
                if (nextX < 0 || nextY < 0 || nextX >= m || nextY >= n || grid[nextX][nextY] == 'X') {
                    isOK = false;
                    break;
                }
            }

            // 이동이 가능하다면 현재 위치를 업데이트합니다.
            if (isOK) {
                curX = nextX;
                curY = nextY;
            }
        }

        // 최종 위치를 반환합니다.
        return new int[] { curX, curY };
    }
}