[코딩테스트] Java - 시뮬레이션

시뮬레이션

- 시뮬레이션: 문제에서 주어진 상황을 이해하고 이를 코드로 구현하는 과정. 구현에 중점

 

(시뮬레이션 풀이법)

- 하나의 문제를 여러개로 분리

- 예외처리시 독립함수로 구현

 

(시뮬레이션 주요 기법)

- 행렬 연산: 덧셈, 뺄셈, 곱셈

- 전치행렬

- 좌표 연산: 2차원 행렬 사용. 방향 벡터(offset 사용)

- 대칭연산: 좌우대칭, 상하대칭

- 회전연산(90도): 시계방향, 반시계방향

 

예제

(배열 뒤집기)

- 좌우 뒤집기: A[i][j] = A[i][(N-1)-j]

- 상하 뒤집기: A[i][j] = A[(N-1)-i][j]

 

- 입력: arr(2차원 배열)

- 출력: 2차원 배열

class Solution {
    private static int[][] solution(int[][] arr, int n) {
        int[][] answer;
        
        for (int i = 0; i < n; ++i) {
            answer = flip(arr);
        }
        return answer;
    }
    
    private static int[][]flip(int[][] arr) {
        int n = arr.length;
        int[][] flipArray = new int[n][n];
        
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                flipArray[i][j] = arr[i][n - 1 - j];
            }
        }
        return flipArray;
    }
}

(배열 90도 회전하기)

- 시계 방향: A[i][j] = A[(N-1)-j][i]

- 반시계 방향: A[(N-1)-j][i] = A[i][j]

 

- 입력: arr(2차원 배열), n(회전 횟수)

- 출력: 2차원 배열

class Solution {
    private static void solution(int[][] arr, int n) {
        int[][] answer;
        
        for (int i = 0; i < n; ++i) {
            answer = rotate(arr);
        }
        
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                System.out.printf("%d ", answer[i][j]);
            }
            System.out.println();
        }
        return ;
    }
    
    private static int[][]rotateArray(int[][] arr) {
        int n = arr.length;
        int[][] roatedArray = new int[n][n];
        
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                rotatedArray[j][n - i - 1] = arr[i][j];
            }
        }
        return rotatedArray;
    }
}

(두 행렬 곱하기)

- C[i][j] = A[i][k] * B[k][j]

 

- 입력: matrix1(2차원 행렬), matrix2(2차원 행렬)

- 출력: 2차원 행렬

class Solution {
    private static void solution(int[][] matrix1, int[][] matrix2) {
        int[][] answer = multiplyMatrices(matrix1, matrix2);
        
        for (int i = 0; i < answer.length; ++i) {
            for (int j = 0; j < answer[0].length; ++j) {
                System.out.printf("%d ", answer[i][j]);
            }
            System.out.println()
        }
        return ;
    }


    private static int[][] multiplyMatrices(int[][] matrix1, int[][] matrix2) {
        int[][] multiplied = new int[matrix1.length][matrix2[0].length];
        
        for (int i = 0; i < matrix1.length; ++i) {
            for (int j = 0; j < matrix2[0].length; ++j) {
                for (int k = 0; k < matrix2.length; ++k) {
                    multiplied[i][j] = matrix1[i][k] * matrix2[k][j];
                }
            }
        }
        return multiplied;
    }
}

(전치행렬 만들기)

- C[i][j] = A[j][i]

 

- 입력: matrix(2차원 배열)

- 출력: 2차원 배열

class Solution {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}};
        int[][] answer = transposedMatrix(matrix);
        
        for (int i = 0; i < matrix.length; ++i) {
            for (int j = 0; j < matrix[0].length; ++j) {
                System.out.print("%d ", answer[i][j]);
            }
            System.out.println();
        }
    }
    
    private static int[][] transposeMatrix(int[][] matrix) {
        int[][] transposedMatrix = new int[matrix.length][matrix[0].length];
        
        for (int i = 0; i < matrix.length; ++i) {
            for (int j = 0; j < matrix[0].length; ++j) {
                transposedMatrix[i][j] = matrix[j][i];
            }
        }
        return transposedMatrix;
    }
}

(달팽이 수열 만들기)

- 달팽이 수열: 1부터 시작하여 시계 방향으로 나선형으로 채우는 수열

 

- 입력: n(nxn 배열의 크기)

- 출력: 달팽이 수열로 채워진 nxn 행렬

class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = nextInt();
        
        int[][] snailArray = new int[n][n];
        int num = 1;
        
        int startRow = 0;
        int endRow = n - 1;
        int startCol = 0;
        int endCol = n - 1;
        
        
    
    }
    
    pri
}