Update

Author: ndb796

4/1.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// N을 입력받기
+int n;
+string plans;
+int x = 1, y = 1;
+
+// L, R, U, D에 따른 이동 방향 
+int dx[4] = {0, 0, -1, 1};
+int dy[4] = {-1, 1, 0, 0};
+char moveTypes[4] = {'L', 'R', 'U', 'D'};
+
+int main(void) {
+    cin >> n;
+    cin.ignore(); // 버퍼 비우기 
+    getline(cin, plans);
+    // 이동 계획을 하나씩 확인
+    for (int i = 0; i < plans.size(); i++) {
+        char plan = plans[i];
+        // 이동 후 좌표 구하기 
+        int nx = -1, ny = -1;
+        for (int j = 0; j < 4; j++) {
+            if (plan == moveTypes[j]) {
+                nx = x + dx[j];
+                ny = y + dy[j];
+            }
+        }
+        // 공간을 벗어나는 경우 무시 
+        if (nx < 1 || ny < 1 || nx > n || ny > n) continue;
+        // 이동 수행 
+        x = nx;
+        y = ny;
+    }
+    cout << x << ' ' << y << '\n';
+    return 0;
+}

4/1.java

@@ -0,0 +1,40 @@
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // N을 입력받기
+        int n = sc.nextInt();
+        sc.nextLine(); // 버퍼 비우기
+        String[] plans = sc.nextLine().split(" ");
+        int x = 1, y = 1;
+
+        // L, R, U, D에 따른 이동 방향 
+        int[] dx = {0, 0, -1, 1};
+        int[] dy = {-1, 1, 0, 0};
+        char[] moveTypes = {'L', 'R', 'U', 'D'};
+
+        // 이동 계획을 하나씩 확인
+        for (int i = 0; i < plans.length; i++) {
+            char plan = plans[i].charAt(0);
+            // 이동 후 좌표 구하기 
+            int nx = -1, ny = -1;
+            for (int j = 0; j < 4; j++) {
+                if (plan == moveTypes[j]) {
+                    nx = x + dx[j];
+                    ny = y + dy[j];
+                }
+            }
+            // 공간을 벗어나는 경우 무시 
+            if (nx < 1 || ny < 1 || nx > n || ny > n) continue;
+            // 이동 수행 
+            x = nx;
+            y = ny;
+        }
+
+        System.out.println(x + " " + y);
+    }
+
+}

4/2.cpp

@@ -0,0 +1,27 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int h, cnt;
+
+// 특정한 시각 안에 '3'이 포함되어 있는지의 여부
+bool check(int h, int m, int s) {
+    if (h % 10 == 3 || m / 10 == 3 || m % 10 == 3 || s / 10 == 3 || s % 10 == 3)
+        return true;
+    return false;
+}
+
+int main(void) {
+    // H를 입력받기 
+    cin >> h;
+    for (int i = 0; i <= h; i++) {
+        for (int j = 0; j < 60; j++) {
+            for (int k = 0; k < 60; k++) {
+                // 매 시각 안에 '3'이 포함되어 있다면 카운트 증가
+                if (check(i, j, k)) cnt++;
+            }
+        }
+    }
+    cout << cnt << '\n';
+    return 0;
+}

4/2.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+public class Main {
+
+    // 특정한 시각 안에 '3'이 포함되어 있는지의 여부
+    public static boolean check(int h, int m, int s) {
+        if (h % 10 == 3 || m / 10 == 3 || m % 10 == 3 || s / 10 == 3 || s % 10 == 3)
+            return true;
+        return false;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // H를 입력받기 
+        int h = sc.nextInt();
+        int cnt = 0;
+
+        for (int i = 0; i <= h; i++) {
+            for (int j = 0; j < 60; j++) {
+                for (int k = 0; k < 60; k++) {
+                    // 매 시각 안에 '3'이 포함되어 있다면 카운트 증가
+                    if (check(i, j, k)) cnt++;
+                }
+            }
+        }
+
+        System.out.println(cnt);
+    }
+
+}

4/3.cpp

@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+string inputData;
+
+// 나이트가 이동할 수 있는 8가지 방향 정의
+int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};
+int dy[] = {-1, -2, -2, -1, 1, 2, 2, 1};
+
+int main(void) {
+    // 현재 나이트의 위치 입력받기
+    cin >> inputData;
+    int row = inputData[1] - '0';
+    int column = inputData[0] - 'a';
+
+    // 8가지 방향에 대하여 각 위치로 이동이 가능한지 확인
+    int result = 0;
+    for (int i = 0; i < 8; i++) {
+        // 이동하고자 하는 위치 확인
+        int nextRow = row + dx[i];
+        int nextColumn = column + dy[i];
+        // 해당 위치로 이동이 가능하다면 카운트 증가
+        if (nextRow >= 1 && nextRow <= 8 && nextColumn >= 1 && nextColumn <= 8) {
+            result += 1;
+        }
+    }
+
+    cout << result << '\n';
+    return 0;
+}

4/3.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // 현재 나이트의 위치 입력받기
+        String inputData = sc.nextLine();
+        int row = inputData.charAt(1) - '0';
+        int column = inputData.charAt(0) - 'a';
+
+        // 나이트가 이동할 수 있는 8가지 방향 정의
+        int[] dx = {-2, -1, 1, 2, 2, 1, -1, -2};
+        int[] dy = {-1, -2, -2, -1, 1, 2, 2, 1};
+
+        // 8가지 방향에 대하여 각 위치로 이동이 가능한지 확인
+        int result = 0;
+        for (int i = 0; i < 8; i++) {
+            // 이동하고자 하는 위치 확인
+            int nextRow = row + dx[i];
+            int nextColumn = column + dy[i];
+            // 해당 위치로 이동이 가능하다면 카운트 증가
+            if (nextRow >= 1 && nextRow <= 8 && nextColumn >= 1 && nextColumn <= 8) {
+                result += 1;
+            }
+        }
+
+        System.out.println(result);
+    }
+
+}

4/4.cpp

@@ -0,0 +1,72 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int n, m, x, y, direction;
+// 방문한 위치를 저장하기 위한 맵을 생성하여 0으로 초기화
+int d[50][50];
+// 전체 맵 정보
+int arr[50][50];
+
+// 북, 동, 남, 서 방향 정의
+int dx[] = {-1, 0, 1, 0};
+int dy[] = {0, 1, 0, -1};
+
+// 왼쪽으로 회전
+void turn_left() {
+    direction -= 1;
+    if (direction == -1) direction = 3;
+}
+
+int main(void) {
+    // N, M을 공백을 기준으로 구분하여 입력받기
+    cin >> n >> m;
+    // 현재 캐릭터의 X 좌표, Y 좌표, 방향을 입력받기
+    cin >> x >> y >> direction;
+    d[x][y] = 1; // 현재 좌표 방문 처리
+
+    // 전체 맵 정보를 입력 받기
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            int x;
+            cin >> x;
+            arr[i][j] = x;
+        }
+    }
+
+    // 시뮬레이션 시작
+    int cnt = 1;
+    int turn_time = 0;
+    while (true) {
+        // 왼쪽으로 회전
+        turn_left();
+        int nx = x + dx[direction];
+        int ny = y + dy[direction];
+        // 회전한 이후 정면에 가보지 않은 칸이 존재하는 경우 이동
+        if (d[nx][ny] == 0 && arr[nx][ny] == 0) {
+            d[nx][ny] = 1;
+            x = nx;
+            y = ny;
+            cnt += 1;
+            turn_time = 0;
+            continue;
+        }
+        // 회전한 이후 정면에 가보지 않은 칸이 없거나 바다인 경우
+        else turn_time += 1;
+        // 네 방향 모두 갈 수 없는 경우
+        if (turn_time == 4) {
+            nx = x - dx[direction];
+            ny = y - dy[direction];
+            // 뒤로 갈 수 있다면 이동하기
+            if (arr[nx][ny] == 0) {
+                x = nx;
+                y = ny;
+            }
+            // 뒤가 바다로 막혀있는 경우
+            else break;
+            turn_time = 0;
+        }
+    }
+
+    cout << cnt << '\n';
+}

4/4.java

@@ -0,0 +1,78 @@
+import java.util.*;
+
+public class Main {
+
+    public static int n, m, x, y, direction;
+    // 방문한 위치를 저장하기 위한 맵을 생성하여 0으로 초기화
+    public static int[][] d = new int[50][50];
+    // 전체 맵 정보
+    public static int[][] arr = new int [50][50];
+
+    // 북, 동, 남, 서 방향 정의
+    public static int dx[] = {-1, 0, 1, 0};
+    public static int dy[] = {0, 1, 0, -1};
+
+    // 왼쪽으로 회전
+    public static void turn_left() {
+        direction -= 1;
+        if (direction == -1) direction = 3;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        // N, M을 공백을 기준으로 구분하여 입력받기
+        n = sc.nextInt();
+        m = sc.nextInt();
+        
+        // 현재 캐릭터의 X 좌표, Y 좌표, 방향을 입력받기
+        x = sc.nextInt();
+        y = sc.nextInt();
+        direction = sc.nextInt();
+        d[x][y] = 1; // 현재 좌표 방문 처리
+
+        // 전체 맵 정보를 입력 받기
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                arr[i][j] = sc.nextInt();
+            }
+        }
+
+        // 시뮬레이션 시작
+        int cnt = 1;
+        int turn_time = 0;
+        while (true) {
+            // 왼쪽으로 회전
+            turn_left();
+            int nx = x + dx[direction];
+            int ny = y + dy[direction];
+            // 회전한 이후 정면에 가보지 않은 칸이 존재하는 경우 이동
+            if (d[nx][ny] == 0 && arr[nx][ny] == 0) {
+                d[nx][ny] = 1;
+                x = nx;
+                y = ny;
+                cnt += 1;
+                turn_time = 0;
+                continue;
+            }
+            // 회전한 이후 정면에 가보지 않은 칸이 없거나 바다인 경우
+            else turn_time += 1;
+            // 네 방향 모두 갈 수 없는 경우
+            if (turn_time == 4) {
+                nx = x - dx[direction];
+                ny = y - dy[direction];
+                // 뒤로 갈 수 있다면 이동하기
+                if (arr[nx][ny] == 0) {
+                    x = nx;
+                    y = ny;
+                }
+                // 뒤가 바다로 막혀있는 경우
+                else break;
+                turn_time = 0;
+            }
+        }
+
+        System.out.println(cnt);
+    }
+
+}