• https://www.acmicpc.net/problem/1259

풀이

문자열 문제이다. 문자열을 파싱한 후 양쪽의 Index를 옮겨가며 서로 같은지를 확인하면 된다. 확인했는데 숫자가 같지 않으면 팰린드롬수가 아니다. for문을 통해 index를 옮겨갈텐데, 여기서는 문자열 길이 / 2까지만 비교해주면 된다. 예를 들어, 문자열(131)의 길이가 홀수 3 이라면, 3/2 = 1 번만 문자열을 비교해주면 된다. 가운데 자리 수는 어떤 것이 오던지 팰린드롬수이므로 문자열(1331)의 길이가 짝수 4라면, 4/2 = 2번 문자열을 비교해주어야 한다. (1=1, 3=3)

코드

package boj.class2.팰린드롬수_1259;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        final String PATH = "src/test/java/boj/class2/팰린드롬수_1259/input.txt";
        System.setIn(new FileInputStream(PATH));
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            String str = stringTokenizer.nextToken();
            if ("0".equals(str)) break;
            int size = str.length();
            boolean isPalindrome = true;
            for (int i = 0; i < (size / 2); i++) {
                if (str.charAt(i) != str.charAt(size - i - 1)) {
                    isPalindrome = false;
                    break;
                }
            }
            System.out.println(isPalindrome ? "yes" : "no");
        }
    }

}

채점결과

문제 출처

https://www.acmicpc.net/problem/494928a93cce0db8/image.png)

풀이

• 스택 문제로 괄호의 Push / Pop 여부만 잘 체크해주면 쉽게 풀 수 있다.
• 처음 괄호 시작 시 ')' or ']'가 들어올 경우에는 균형잡힌 괄호가 아니므로 "no"를 출력한다.

코드

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = null;
        String str = null;
        while (true) {
            Stack<Character> stack = new Stack();
            boolean fail = false;
            str = bufferedReader.readLine();
            if (".".equals(str)) break;
            stringTokenizer = new StringTokenizer(str);
            while (stringTokenizer.hasMoreTokens() && !fail) {
                char[] wordToCharsArray = stringTokenizer.nextToken().toCharArray();
                for (int i = 0; i < wordToCharsArray.length; i++) {
                    if (stack.isEmpty() && wordToCharsArray[i] == ')' || stack.isEmpty() && wordToCharsArray[i] == ']') {
                        fail = true;
                        break;
                    }
                    switch (wordToCharsArray[i]) {
                        case '(':
                            stack.push('(');
                            break;
                        case ')':
                            if (stack.peek() == '(') {
                                stack.pop();
                            } else {
                                stack.push(')');
                            }
                            break;
                        case '[':
                            stack.push('[');
                            break;
                        case ']':
                            if (stack.peek() == '[') {
                                stack.pop();
                            } else {
                                stack.push(']');
                            }
                            break;
                    }
                }
            }
            if (fail) {
                System.out.println("no");
                continue;
            } else if (stack.isEmpty()) {
                System.out.println("yes");
            } else {
                System.out.println("no");
            }
        }
    }
}

채점 결과

https://www.acmicpc.net/problem/11866

풀이

• K의 배수일 때 Queue에서 poll()
• K의 배수가 아닐 경우 Queue에서 poll() 후 다시 Queue에 add()

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int K = Integer.parseInt(stringTokenizer.nextToken());
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 1; i <= N; i++) {
            queue.add(i);
        }
        List<Integer> answerList = new ArrayList<>();
        int count = 0;
        while (!queue.isEmpty()) {
            count++;
            if (count % K != 0) {
                int number = queue.poll();
                queue.add(number);
            } else {
                answerList.add(queue.poll());
            }
        }
        StringBuilder stringBuilder = new StringBuilder();
        for (int value : answerList) {
            if (stringBuilder.length() > 0) {
                stringBuilder.append(", ");
            }
            stringBuilder.append(value);
        }
        System.out.println("<" + stringBuilder + ">");

    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/2108

풀이

• 없음 (단순한 구현 문제)

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int[] arr = new int[N];
        int[] countArray = new int[8001];
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            arr[i] = Integer.parseInt(stringTokenizer.nextToken());
            countArray[arr[i] + 4000]++;
        }
        Arrays.sort(arr);
        // 1. 산술 평균
        System.out.println(Math.round(Arrays.stream(arr).average().getAsDouble()));
        // 2. 중앙 값
        System.out.println(arr[N / 2]);
        // 3. 최빈 값
        int max = 0;
        for (int i = 0; i < 8001; i++) {
            if (countArray[i] >= max) {
                max = countArray[i];
            }
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 8001; i++) {
            if (countArray[i] == max) {
                list.add(i - 4000);
            }
        }
        System.out.println(list.size() == 1 ? list.get(0) : list.stream().sorted().collect(Collectors.toList()).get(1));
        // 4. 범위
        System.out.println(arr[arr.length - 1] - arr[0]);
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/11050

풀이

• 문제를 풀기 전 이항계수가 무엇인지 알아야한다.
• 이항 계수의 공식은 다음과 같다
• Factorial을 구할지만 알면 쉽게 풀 수 있는 문제이다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    static int[] dp;
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int K = Integer.parseInt(stringTokenizer.nextToken());
        dp = new int[N + 1];
        dp[0] = 1;
        dp[1] = 1;
        System.out.println(factorial(N) / (factorial(N - K) * factorial(K)));
    }

    static int factorial(int n) {
        if (dp[n] != 0) {
            return dp[n];
        }
        return dp[n] = n * factorial(n - 1);
    }
}

채점 결과

https://www.acmicpc.net/problem/2164

풀이

1. 덱(Deque)에 데이터를 차례대로 넣는다. [1, 2, 3, 4, 5, 6]
2. 덱의 Top에 있는 1을 먼저 뽑아낸다. deque.poll()
3. 그 다음 Top의 2를 뽑아 가장 뒤로 보낸다.
4. 위의 로직을 deque의 크기가 1이 아닐 경우 반복한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i = 1; i <= N; i++) {
            deque.addLast(i);
        }
        while (deque.size() != 1) {
            deque.poll();
            int value = deque.poll();
            deque.addLast(value);
        }
        System.out.println(deque.peek());
    }
}

채점 결과

https://www.acmicpc.net/problem/1966

풀이

• 우선순위 큐와 큐를 사용하여 풀 수 있는 문제이다.
• 큐에 index와 우선순위를 넣는다. 그리고 우선순위 큐에는 우선순위의 값만 넣는다.
• 큐를 poll() 하면서 우선순위 큐의 peek() 값과 비교하여 일치하는지를 확인한다.
• 만약 일치한다면 큐에서 뽑은 데이터의 index가 M과 맞는지를 비교 후 값을 출력한다. 그렇지 않다면 다시 큐에 add() 한다.

코드

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    private static class Data {
        int number;
        int order;

        public Data(int number, int order) {
            this.number = number;
            this.order = order;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int T = Integer.parseInt(stringTokenizer.nextToken());
        while (T-- > 0) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            int N = Integer.parseInt(stringTokenizer.nextToken());
            int M = Integer.parseInt(stringTokenizer.nextToken());
            Queue<Data> queue = new LinkedList<>();
            PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((o1, o2) -> o2 - o1);
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            for (int i = 0; i < N; i++) {
                int value = Integer.parseInt(stringTokenizer.nextToken());
                queue.add(new Data(i, value));
                priorityQueue.add(value);
            }
            int count = 0;
            while (!queue.isEmpty()) {
                Data data = queue.poll();
                if (priorityQueue.peek() == data.order) {
                    priorityQueue.poll();
                    count++;
                    if (data.number == M) {
                        System.out.println(count);
                    }
                } else {
                    queue.add(data);
                }
            }
        }
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/10866

개념

Deque 란?

덱(Deque)은 어떤 쪽으로 입력하고 어떤 쪽으로 출력하냐에 따라 스택으로 사용할 수 있고 큐로 사용할 수 있다. 특히 한쪽으로만 입력 가능하도록 설정한 덱을 스크롤(Scroll)이라고 하며, 한쪽으로만 출력 가능하도록 설정한 덱을 셸프(Shelf)라고 한다.

풀이

• Deque 문제이며 자바의 Deque 라이브러리를 이용해 쉽게 풀 수 있다.
• Deque에 대한 개념은 찾아보는 것을 추천한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            String command = stringTokenizer.nextToken();
            int value = 0;
            switch (command) {
                case "push_front":
                    value = Integer.parseInt(stringTokenizer.nextToken());
                    deque.addFirst(value);
                    break;
                case "push_back":
                    value = Integer.parseInt(stringTokenizer.nextToken());
                    deque.addLast(value);
                    break;
                case "pop_front":
                    if (deque.isEmpty()) System.out.println(-1);
                    else System.out.println(deque.pollFirst());
                    break;
                case "pop_back":
                    if (deque.isEmpty()) System.out.println(-1);
                    else System.out.println(deque.pollLast());
                    break;
                case "size":
                    System.out.println(deque.size());
                    break;
                case "empty":
                    if (deque.isEmpty()) System.out.println(1);
                    else System.out.println(0);
                    break;
                case "front":
                    if (deque.isEmpty()) System.out.println(-1);
                    else System.out.println(deque.getFirst());
                    break;
                case "back":
                    if (deque.isEmpty()) System.out.println(-1);
                    else System.out.println(deque.getLast());
                    break;
            }
        }
    }
}

채점 결과

https://www.acmicpc.net/problem/2805

풀이

• 이전에 풀었던 랜선 자르기 문제와 동일하게 풀 수 있다. https://velog.io/@jm_25/%EB%B0%B1%EC%A4%801654-%EB%9E%9C%EC%84%A0-%EC%9E%90%EB%A5%B4%EA%B8%B0-JAVA
• 차이점이라면 랜선 자르기는 잘라진 갯수를 카운트 했는데, 나무 자르기의 경우 자르고 남은 부분을 더해야 한다.
• 입력의 크기가 크게 주어지므로 long으로 선언 해야한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int M = Integer.parseInt(stringTokenizer.nextToken());

        long max = Long.MIN_VALUE;
        long[] arr = new long[N];
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(stringTokenizer.nextToken());
            if (max < arr[i]) {
                max = arr[i];
            }
        }

        long min = 0;
        System.out.println(upperBound(N, M, max, arr, min));

    }

    private static long upperBound(int N, int M, long max, long[] arr, long min) {
        while (min < max) {
            long mid = (min + max) / 2;
            long length = 0;
            for (int i = 0; i < N; i++) {
                if (arr[i] - mid > 0) {
                    length += (arr[i] - mid);
                }
            }

            if (length < M) {
                max = mid;
            } else {
                min = mid + 1;
            }
        }

        return min - 1;
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/1654

풀이

• 10816번 숫자카드2 문제와 동일한 이분 탐색 문제이다. 여기서 다른 점은 숫자카드2에서는 key를 찾기 위해 index를 이분탐색하였지만, 이번에는 길이를 기준으로 이분 탐색을 진행한다.
• count가 M을 넘어가는 upperBound의 값을 찾아 -1을 해주면 N개를 만들 수 있는 랜선의 최대 길이를 나타낼 수 있다.
• 여기서 중요한 점은 랜선의 길이는 자연수이므로 mid가 0이 되지 않도록 max 값을 +1 해주어야 한다.

코드

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int M = Integer.parseInt(stringTokenizer.nextToken());

        long max = Long.MIN_VALUE;
        int[] arr = new int[N];
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            arr[i] = Integer.parseInt(stringTokenizer.nextToken());
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        max++;
        System.out.println(upperBound(N, M, max, arr));
    }

    private static long upperBound(int N, int M, long max, int[] arr) {
        long min = 0;
        while (min < max) {
            long mid = (min + max) / 2;
            int count = 0;
            for (int i = 0; i < N; i++) {
                count += (arr[i] / mid);
            }
            if (count < M) {
                max = mid;
            } else {
                min = mid + 1;
            }
        }

        return min - 1;
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/10816

풀이

• 이분 탐색으로 풀 수 있는 문제이지만, 처음 보는 유형이였다.
• upper bound와 lower bound를 이용해 찾으려는 Key 값의 최소 시작 index와 최대 끝 index를 찾아서 풀 수 있는 문제이다.
• https://st-lab.tistory.com/267 의 풀이를 참고하여 풀었다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int[] arr = new int[N];
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.valueOf(stringTokenizer.nextToken());
        }
        Arrays.sort(arr);

        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int M = Integer.parseInt(stringTokenizer.nextToken());
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < M; i++) {
            int key = Integer.parseInt(stringTokenizer.nextToken());
            stringBuilder.append(upperBound(arr, key) - lowerBound(arr, key)).append(" ");
        }
        System.out.println(stringBuilder);
    }

    public static int lowerBound(int[] arr, int key) {
        int lo = 0;
        int hi = arr.length;

        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key <= arr[mid]) {
                hi = mid;
            } else {
                lo = mid + 1;
            }
        }

        return lo;
    }

    public static int upperBound(int[] arr, int key) {
        int lo = 0;
        int hi = arr.length;

        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key < arr[mid]) {
                hi = mid;
            } else {
                lo = mid + 1;
            }
        }

        return lo;
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/10815

풀이

• 이분탐색을 이용하여 풀 수 있는 문제이다.
• 카운트 정렬로 풀 수도 있겠지만, 이분 탐색으로 분류된 문제이다.
• Arrays.binarySearch()을 통해 쉽게 풀 수 있다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int[] arr = new int[N];
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.valueOf(stringTokenizer.nextToken());
        }
        Arrays.sort(arr);
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int M = Integer.parseInt(stringTokenizer.nextToken());
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < M; i++) {
            if (Arrays.binarySearch(arr, Integer.parseInt(stringTokenizer.nextToken())) >= 0) {
                stringBuilder.append(1).append(" ");
            } else {
                stringBuilder.append(0).append(" ");
            }
        }
        System.out.println(stringBuilder);
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/7568

풀이

• 주어진 N의 크기가 크지 않으므로 브루트포스 알고리즘을 통해 해결할 수 있다.
• 주어진 몸무게/키를 순서대로 모두 비교한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Main {
    public static class Member {
        int weight;
        int height;

        public Member(int weight, int height) {
            this.weight = weight;
            this.height = height;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());

        List<Member> members = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            members.add(new Member(Integer.parseInt(stringTokenizer.nextToken()), Integer.parseInt(stringTokenizer.nextToken())));
        }

        int[] result = new int[N];
        for (int i = 0; i < members.size(); i++) {
            solution(members, i, N, result);
        }
        for (int rank : result) {
            System.out.println(rank + 1);
        }
    }

    private static void solution(List<Member> members, int i, int N, int[] result) {
        for (int j = 0; j < N; j++) {
            if (i == j) continue;
            if (members.get(i).weight < members.get(j).weight && members.get(i).height < members.get(j).height) {
                result[i]++;
            }
        }
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/1436

풀이

• 666부터 숫자를 증가시켜 "666"을 포함하는 경우를 찾으면 된다.
• 브루트포스 알고리즘

코드

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int number = 666;
        int count = 0;
        while (count < N) {
            if (String.valueOf(number).contains("666")) {
                count++;
            }
            number++;
        }
        System.out.println(--number);
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/1874

풀이

• 스택 문제이다.
• 입력 받은 값이 top 보다 클 경우 스택에 Push를 해준다. 이 때 '+'는 StringBuilder를 통해 append 해준다.
• 만약 스택의 top이 입력 받은 값과 다르다면 구현할 수 없는 수열이다. "NO"를 return 한다.
• 입력 받은 값이 top 보다 작거나 같을 경우는 Pop을 해주면 된다. 이 때 '-'는 StringBuilder를 통해 append 한다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());

        Stack<Integer> stack = new Stack<>();
        StringBuilder stringBuilder = new StringBuilder();
        int top = 0;
        int N = Integer.parseInt(stringTokenizer.nextToken());
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            int value = Integer.parseInt(stringTokenizer.nextToken());
            if (value > top) {
                for (int j = top + 1; j <= value; j++) {
                    stack.push(j);
                    stringBuilder.append("+").append("\n");
                }
                top = value;
            } else if (stack.peek() != value) {
                System.out.println("NO");
                return;
            }
            stack.pop();
            stringBuilder.append("-").append("\n");
        }
        System.out.println(stringBuilder);
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/11651

풀이

• 기존에 풀었던 11650 좌표 정렬하기와 동일한 유형의 문제이다.
• 기존 코드의 비교 방식에서 x, y 만 변경해주면 된다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Main {
    public static class Coordinate {
        int x;
        int y;

        public Coordinate(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        List<Coordinate> coordinateList = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            coordinateList.add(new Coordinate(Integer.parseInt(stringTokenizer.nextToken()), Integer.parseInt(stringTokenizer.nextToken())));
        }
        Collections.sort(coordinateList, (o1, o2) -> {
            if (o1.y == o2.y) {
                return o1.x - o2.x;
            } else {
                return o1.y - o2.y;
            }
        });
        for (Coordinate coordinate : coordinateList) {
            System.out.println(coordinate.x + " " + coordinate.y);
        }
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/4153

풀이

• 피타고라스만 알고 있다면 쉽게 풀 수 있다.
• 처음에 주어진 수 6 8 10이 순서대로 입력으로 주어질 줄 알았는데, 10 8 6으로 주어질 수도 있어서 max 값을 찾아주어야하는 문제이다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = null;
        while (true) {
            int[] array = new int[3];
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            array[0] = Integer.parseInt(stringTokenizer.nextToken());
            array[1] = Integer.parseInt(stringTokenizer.nextToken());
            array[2] = Integer.parseInt(stringTokenizer.nextToken());
            Arrays.sort(array);
            if (array[0] == 0 && array[1] == 0 && array[2] == 0) break;
            if (Math.pow(array[2], 2) == (Math.pow(array[0], 2) + Math.pow(array[1], 2))) {
                System.out.println("right");
            } else {
                System.out.println("wrong");
            }
        }
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/10773

풀이

• 그대로 구현하였으나, 문제의 요구사항으로는 스택을 사용하는게 적절한 것 같다.
• 문제에서 제시한 힌트대로 구현하면 쉽게 풀 수 있다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        List<Integer> list = new ArrayList<>();
        int N = Integer.parseInt(stringTokenizer.nextToken());
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            int value = Integer.parseInt(stringTokenizer.nextToken());
            if (value == 0){
                list.remove(list.size() - 1);
            } else{
                list.add(value);
            }
        }
        int sum = 0;
        for (Integer value : list) {
            sum += value;
        }
        System.out.println(sum);
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/10814

풀이

• List로 데이터를 저장한 후, Collections.sort()를 이용하면 쉽게 풀 수 있는 문제이다.

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static class Member {
        int age;
        String name;

        public Member(int age, String name) {
            this.age = age;
            this.name = name;
        }
    }
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        List<Member> list = new ArrayList<>();
        int N = Integer.parseInt(stringTokenizer.nextToken());
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            list.add(new Member(Integer.parseInt(stringTokenizer.nextToken()), stringTokenizer.nextToken()));
        }
        Collections.sort(list, new Comparator<Member>() {
            @Override
            public int compare(Member o1, Member o2) {
                return o1.age - o2.age;
            }
        });
        for (Member member: list) {
            System.out.println(member.age + " " + member.name);
        }
    }
}

채점 결과

문제 출처

https://www.acmicpc.net/problem/1018

풀이

• 'W'로 먼저 시작하는 체스판과 'B'로 먼저 시작하는 체스판을 미리 만들고 입력받은 체스판과 비교해서 최솟값을 구하면 되는 문제이다.
• 체스판을 만들 때는 flag를 잘 활용한다.
• 중요한 부분은 이중 for문을 선언할 때 index를 잘 체크해주어야 한다. x는 x+9 <= N 까지 증가할 수 있고, y는 y+9 <= M 까지 증가할 수 있다. (N, M이 8보다 큰 경우 체스판을 움직이면서 체크하기 위함)

코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        int N = Integer.parseInt(stringTokenizer.nextToken());
        int M = Integer.parseInt(stringTokenizer.nextToken());
        char[][] board = new char[N][M];
        for (int i = 0; i < N; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
            String row = stringTokenizer.nextToken();
            for (int j = 0; j < M; j++) {
                char[] rowToCharArray = row.toCharArray();
                board[i][j] = rowToCharArray[j];
            }
        }
        char[][] whiteBoard = new char[8][8];
        char[][] blackBoard = new char[8][8];
        int flag = 1;
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                whiteBoard[i][j] = flag == 1 ? 'W' : 'B';
                flag *= -1;
                blackBoard[i][j] = flag == 1 ? 'W' : 'B';
            }
            flag *= -1;
        }

        int answer = Integer.MAX_VALUE;
        int x = 0, y = 0;
        while (true) {
            int whiteResult = 0;
            int blackResult = 0;
            for (int i = x; i < x + 8; i++) {
                for (int j = y; j < y + 8; j++) {
                    if (board[i][j] != whiteBoard[i - x][j - y]) {
                        whiteResult++;
                    }
                    if (board[i][j] != blackBoard[i - x][j - y]) {
                        blackResult++;
                    }
                }
            }
            int resultMinValue = Math.min(whiteResult, blackResult);
            answer = Math.min(answer, resultMinValue);
            if ((y + 1) + 8 <= M) {
                y++;
            } else {
                if ((x + 1) + 8 <= N) {
                    x++;
                    y = 0;
                } else {
                    break;
                }
            }
        }
        System.out.println(answer);
    }
}

채점 결과