모의 테스트

두개 뽑아서 더하기

public static int[] solution_03(int[] numbers) {
    TreeSet<Integer> result = new TreeSet<>();

    for (int i = 0; i < numbers.length - 1; i++) {
        for (int j = i + 1; j < numbers.length; j++) {
            result.add(numbers[i] + numbers[j]);
        }
    }

    return result.stream().sorted().mapToInt(Integer::intValue).toArray();
}

• stream 사용법

모의고사 (수포자)

public static int[] solution_04(int[] answers) {
    int[] pattern1 = {1, 2, 3, 4, 5};
    int[] pattern2 = {2, 1, 2, 3, 2, 4, 2, 5};
    int[] pattern3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

    int[] scores = new int[3];

    for (int i = 0; i < answers.length; i++) {
        scores[0] += answers[i] == pattern1[i % pattern1.length % pattern1.length] ? 1 : 0;
        scores[1] += answers[i] == pattern2[i % pattern2.length % pattern2.length] ? 1 : 0;
        scores[2] += answers[i] == pattern3[i % pattern3.length % pattern3.length] ? 1 : 0;
    }

    int maxScore = Arrays.stream(scores).max().getAsInt();

    ArrayList<Integer> answer = new ArrayList<>();
    for (int i = 0; i < scores.length; i++) {
        if (scores[i] == maxScore) {
            answer.add(i + 1);
        }
    }
    return answer.stream().mapToInt(Integer::intValue).toArray();
}

• 패턴 파악, maxScore 구하는 방법 .max().getAsInt()

행렬의 곱셉

public static int[][] solution_05(int[][] arr1, int[][] arr2) {
    int[][] answer = new int[arr1.length][arr2[0].length];

    for (int i = 0; i < arr1.length; i++) {
        for (int j = 0; j < arr2[0].length; j++) {
            for (int k = 0; k < arr1[0].length; k++) {
                answer[i][j] += arr1[i][k] * arr2[k][j];
            }
        }
    }
    return answer;
}

• O(N^3) 의 index 유의

실패율

public static int[] solution_06(int N, int[] stages) {

    int[] challenger = new int[N+2];
    Arrays.stream(stages).forEach(stage -> challenger[stage]++);

    HashMap<Integer, Double> fails = new HashMap<>();
    double totalPlayer = stages.length;

    for( int i = 1; i <= N; i++) {
        if(challenger[i] == 0) {
            fails.put(i, 0.0);
        }else {
            fails.put(i, (double)challenger[i]/totalPlayer);
            totalPlayer -= challenger[i];
        }
    }

    return fails.entrySet().stream()
        .sorted((o1, o2) -> Double.compare(o2.getValue(), o1.getValue()))
        .mapToInt(HashMap.Entry::getKey).toArray();
}

• challenger 을 [N+2] 개로 잡는 이유
• for문에서 totalPlayer -= challenger[i];
• HashMap의 entrySet 사용 요령 기억하기

방문 길이

import java.util.HashMap;
import java.util.HashSet;

class Solution {

    private static HashMap<Character, int[]> location = new HashMap<>();

    private static void initLocation() {
        location.put('U', new int[]{0, 1});
        location.put('D', new int[]{0, -1});
        location.put('L', new int[]{-1, 0});
        location.put('R', new int[]{1, 0});
    }

    public int solution(String dirs) {
        initLocation();
        int x = 5, y = 5;

        HashSet<String> answer = new HashSet<>();

        for (int i = 0; i < dirs.length(); i++) {
            int[] move = location.get(dirs.charAt(i));
            int nx = x + move[0];
            int ny = y + move[1];

            if (!isValidMove(nx, ny)) {
                continue;
            }
            answer.add(x + " " + y + " " + nx + " " + ny);
            answer.add(nx + " " + ny + " " + x + " " + y);

            x = nx;
            y = ny;
        }

        return answer.size() / 2;
    }

    private static boolean isValidMove(int nx, int ny) {
        return nx < 11 && nx >= 0 && ny < 11 && ny >= 0;
    }
}

• A->B, B->A 도 하나의 이동경로로 파악되는 점 유의 answer.size() / 2 (문제에는 상세 설명이 없음)