ArrayList_Answers.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class ArrayList_Answers {
    public static void main(String[] args) {
        // === 문제 1 ===
        System.out.println("문제1: " + solution1(new ArrayList<>(Arrays.asList(1, 1, 3, 3, 0, 1, 1))));
        // [1, 3, 0, 1]

        // === 문제 2 ===
        System.out.println("문제2: " + solution2(new ArrayList<>(Arrays.asList(5, 9, 7, 10)), 5));
        // [5, 10]
        System.out.println("문제2: " + solution2(new ArrayList<>(Arrays.asList(3, 2, 6)), 10));
        // [-1]

        // === 문제 3 ===
        System.out.println("문제3: " + solution3(new ArrayList<>(Arrays.asList(2, 1, 3, 4, 1))));
        // [2, 3, 4, 5, 6, 7]

        // === 문제 4 ===
        System.out.println("문제4: " + solution4(new ArrayList<>(Arrays.asList(1, 5, 2, 6, 3, 7, 4)), new ArrayList<>(Arrays.asList(2, 5, 3))));
        // 5

        // === 문제 5 ===
        System.out.println("문제5: " + solution5(new ArrayList<>(Arrays.asList(1, 2, 3, 4, 6, 7, 8, 0))));
        // 14

        // === 문제 6 ===
        System.out.println("문제6: " + solution6(new ArrayList<>(Arrays.asList(4, 7, 12)), new ArrayList<>(Arrays.asList(true, false, true))));
        // 9

        // === 문제 7 ===
        System.out.println("문제7: " + solution7(new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5))));
        // [1]
        System.out.println("문제7: " + solution7(new ArrayList<>(Arrays.asList(1, 3, 2, 4, 2))));
        // [1, 2, 3]

        // === 문�� 8 ===
        System.out.println("문���8: " + solution8(new ArrayList<>(Arrays.asList(1, 8, 3))));
        // [8, 3]
        System.out.println("문제8: " + solution8(new ArrayList<>(Arrays.asList(10))));
        // [-1]

        // === 문제 9 ===
        System.out.println("문제9: " + solution9(new ArrayList<>(Arrays.asList(3, 1, 2, 3))));
        // 2
        System.out.println("문제9: " + solution9(new ArrayList<>(Arrays.asList(3, 3, 3, 2, 2, 4))));
        // 3

        // === 문제 10 ===
        System.out.println("��제10: " + solution10(new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6))));
        // [6, 5, 4, 3, 2, 1]
    }

    // 문제 1. 같은 숫자는 싫어
    public static ArrayList<Integer> solution1(ArrayList<Integer> arr) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int i = 0; i < arr.size(); i++) {
            if (i == 0 || !arr.get(i).equals(arr.get(i - 1))) {
                result.add(arr.get(i));
            }
        }
        return result;
    }

    // 문�� 2. 나누어 떨어지는 숫자 배열
    public static ArrayList<Integer> solution2(ArrayList<Integer> arr, int divisor) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int num : arr) {
            if (num % divisor == 0) {
                result.add(num);
            }
        }
        if (result.isEmpty()) {
            result.add(-1);
            return result;
        }
        Collections.sort(result);
        return result;
    }

    // 문제 3. 두 개 뽑아서 더하기
    public static ArrayList<Integer> solution3(ArrayList<Integer> numbers) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int i = 0; i < numbers.size(); i++) {
            for (int j = i + 1; j < numbers.size(); j++) {
                int sum = numbers.get(i) + numbers.get(j);
                if (!result.contains(sum)) {
                    result.add(sum);
                }
            }
        }
        Collections.sort(result);
        return result;
    }

    // 문제 4. K��째수
    public static int solution4(ArrayList<Integer> arr, ArrayList<Integer> command) {
        int i = command.get(0);
        int j = command.get(1);
        int k = command.get(2);
        ArrayList<Integer> sliced = new ArrayList<>(arr.subList(i - 1, j));
        Collections.sort(sliced);
        return sliced.get(k - 1);
    }

    // 문제 5. 없는 숫자 더하기
    public static int solution5(ArrayList<Integer> numbers) {
        int total = 45;
        for (int num : numbers) {
            total -= num;
        }
        return total;
    }

    // 문제 6. 음양 더하기
    public static int solution6(ArrayList<Integer> absolutes, ArrayList<Boolean> signs) {
        int sum = 0;
        for (int i = 0; i < absolutes.size(); i++) {
            if (signs.get(i)) {
                sum += absolutes.get(i);
            } else {
                sum -= absolutes.get(i);
            }
        }
        return sum;
    }

    // 문제 7. 모의고사
    public static ArrayList<Integer> solution7(ArrayList<Integer> answers) {
        int[] p1 = {1, 2, 3, 4, 5};
        int[] p2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] p3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

        int s1 = 0, s2 = 0, s3 = 0;
        for (int i = 0; i < answers.size(); i++) {
            if (answers.get(i) == p1[i % p1.length]) s1++;
            if (answers.get(i) == p2[i % p2.length]) s2++;
            if (answers.get(i) == p3[i % p3.length]) s3++;
        }

        int max = Math.max(s1, Math.max(s2, s3));
        ArrayList<Integer> result = new ArrayList<>();
        if (s1 == max) result.add(1);
        if (s2 == max) result.add(2);
        if (s3 == max) result.add(3);
        return result;
    }

    // 문제 8. 제일 작은 수 제거하기
    public static ArrayList<Integer> solution8(ArrayList<Integer> arr) {
        if (arr.size() == 1) {
            return new ArrayList<>(Arrays.asList(-1));
        }
        int min = Collections.min(arr);
        ArrayList<Integer> result = new ArrayList<>();
        for (int num : arr) {
            if (num != min) {
                result.add(num);
            }
        }
        return result;
    }

    // 문��� 9. 폰켓몬
    public static int solution9(ArrayList<Integer> nums) {
        int pick = nums.size() / 2;
        ArrayList<Integer> types = new ArrayList<>();
        for (int num : nums) {
            if (!types.contains(num)) {
                types.add(num);
            }
        }
        return Math.min(types.size(), pick);
    }

    // 문제 10. 리스트 뒤집기
    public static ArrayList<Integer> solution10(ArrayList<Integer> arr) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int i = arr.size() - 1; i >= 0; i--) {
            result.add(arr.get(i));
        }
        return result;
    }
}