ArrayList_Problems.java

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

public class ArrayList_Problems {
    public static void main(String[] args) {

        // === 문제 1 테스트 ===
        ArrayList<Integer> arr1 = new ArrayList<>(Arrays.asList(1, 1, 3, 3, 0, 1, 1));
        System.out.println("문제1: " + solution1(arr1));
        // 기대 출력: [1, 3, 0, 1]

        // === 문제 2 테스트 ===
        ArrayList<Integer> arr2 = new ArrayList<>(Arrays.asList(5, 9, 7, 10));
        System.out.println("문제2: " + solution2(arr2, 5));
        // 기대 출력: [5, 10]

        // === 문제 3 테스트 ===
        ArrayList<Integer> arr3 = new ArrayList<>(Arrays.asList(2, 1, 3, 4, 1));
        System.out.println("문제3: " + solution3(arr3));
        // 기대 출력: [2, 3, 4, 5, 6, 7]

        // === 문제 4 테스트 ===
        ArrayList<Integer> arr4 = new ArrayList<>(Arrays.asList(1, 5, 2, 6, 3, 7, 4));
        ArrayList<Integer> command = new ArrayList<>(Arrays.asList(2, 5, 3));
        System.out.println("문제4: " + solution4(arr4, command));
        // 기대 출력: 5

        // === 문제 5 테스트 ===
        ArrayList<Integer> arr5 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 6, 7, 8, 0));
        System.out.println("문제5: " + solution5(arr5));
        // 기대 출력: 14

        // === 문제 6 테스트 ===
        ArrayList<Integer> abs6 = new ArrayList<>(Arrays.asList(4, 7, 12));
        ArrayList<Boolean> signs6 = new ArrayList<>(Arrays.asList(true, false, true));
        System.out.println("문제6: " + solution6(abs6, signs6));
        // 기대 출력: 9

        // === 문제 7 테스트 ===
        ArrayList<Integer> answers7 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        System.out.println("문제7: " + solution7(answers7));
        // 기대 출력: [1]

        // === 문제 8 테스트 ===
        ArrayList<Integer> arr8 = new ArrayList<>(Arrays.asList(1, 8, 3));
        System.out.println("문제8: " + solution8(arr8));
        // 기대 출력: [1, 3]

        // === 문제 9 테스트 ===
        ArrayList<Integer> arr9 = new ArrayList<>(Arrays.asList(3, 1, 2, 3));
        System.out.println("문제9: " + solution9(arr9));
        // 기대 출력: 2

        // === 문제 10 테스트 ===
        ArrayList<Integer> arr10 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
        System.out.println("문제10: " + solution10(arr10));
        // 기대 출력: [6, 5, 4, 3, 2, 1]
    }


    // ===========================================
    // 문제 1. 같은 숫자는 싫어 (프로그래머스 Lv.1 #12906)
    // https://school.programmers.co.kr/learn/courses/30/lessons/12906
    // ===========================================
    //
    // 요구사항:
    // 1. 결과를 담을 새 ArrayList<Integer>를 만드세요.
    // 2. for문으로 arr을 순회하세요.
    // 3. 첫 번째 원소는 무조건 결과에 추가하세요.
    // 4. 현재 원소가 바로 이전 원소와 다르면 결과에 추가하세요.
    // 5. 결과 리스트를 반환하세요.
    //
    // 입력: [1, 1, 3, 3, 0, 1, 1]
    // 출력: [1, 3, 0, 1]
    //
    public static ArrayList<Integer> solution1(ArrayList<Integer> arr) {
        // 여기에 코드를 작성하세요
        return new ArrayList<>();
    }


    // ===========================================
    // 문제 2. 나누어 떨어지는 숫자 배열 (프로그래머스 Lv.1 #12910)
    // https://school.programmers.co.kr/learn/courses/30/lessons/12910
    // ===========================================
    //
    // 요구사항:
    // 1. 결과를 담을 새 ArrayList<Integer>를 만드세요.
    // 2. for문으로 arr을 순회하세요.
    // 3. 각 원소가 divisor로 나누어 떨어지면 (% == 0) 결과에 추가하세요.
    // 4. 결과가 비어있으면 -1을 넣어서 반환하세요.
    // 5. 비어있지 않으면 Collections.sort()로 오름차순 정렬 후 반환하세요.
    //
    // 입력: [5, 9, 7, 10], divisor = 5
    // 출력: [5, 10]
    //
    public static ArrayList<Integer> solution2(ArrayList<Integer> arr, int divisor) {
        // 여기에 코드를 작성하세요
        return new ArrayList<>();
    }


    // ===========================================
    // 문제 3. 두 개 뽑아서 더하기 (프로그래머스 Lv.1 #68644)
    // https://school.programmers.co.kr/learn/courses/30/lessons/68644
    // ===========================================
    //
    // 요구사항:
    // 1. 결과를 담을 새 ArrayList<Integer>를 만드세요.
    // 2. 이중 for문으로 서로 다른 두 수의 조합을 만드세요. (i, j에서 j는 i+1부터)
    // 3. 두 수를 더한 값이 결과 리스트에 없으면 (.contains()로 확인) 추가하세요.
    // 4. Collections.sort()로 오름차순 정렬 후 반환하세요.
    //
    // 입력: [2, 1, 3, 4, 1]
    // 출력: [2, 3, 4, 5, 6, 7]
    //
    public static ArrayList<Integer> solution3(ArrayList<Integer> numbers) {
        // 여기에 코드를 작성하세요
        return new ArrayList<>();
    }


    // ===========================================
    // 문제 4. K번째수 (프로그래머스 Lv.1 #42748)
    // https://school.programmers.co.kr/learn/courses/30/lessons/42748
    // ===========================================
    //
    // 요구사항:
    // 1. command에서 i = command.get(0), j = command.get(1), k = command.get(2)를 꺼내세요.
    // 2. arr에서 i번째부터 j번째까지 잘라서 새 리스트를 만드세요.
    //    (힌트: new ArrayList<>(arr.subList(i-1, j)) 사용)
    // 3. 잘라낸 리스트를 Collections.sort()로 정렬하세요.
    // 4. 정렬된 리스트에서 k번째 수를 반환하세요. (.get(k-1))
    //
    // 입력: [1, 5, 2, 6, 3, 7, 4], command = [2, 5, 3]
    // 출력: 5
    //
    public static int solution4(ArrayList<Integer> arr, ArrayList<Integer> command) {
        // 여기에 코드를 작성하세요
        return 0;
    }


    // ===========================================
    // 문제 5. 없는 숫자 더하기 (프로그래머스 Lv.1 #86051)
    // https://school.programmers.co.kr/learn/courses/30/lessons/86051
    // ===========================================
    //
    // 요구사항:
    // 1. 0부터 9까지의 총합(= 45)을 변수에 저장하세요.
    // 2. for문으로 numbers를 순회하세요.
    // 3. 각 숫자를 총합에서 빼세요.
    // 4. 남은 값을 반환하세요.
    //
    // 입력: [1, 2, 3, 4, 6, 7, 8, 0]
    // 출력: 14  (5 + 9 = 14)
    //
    public static int solution5(ArrayList<Integer> numbers) {
        // 여기에 코드를 작성하세요
        return 0;
    }


    // ===========================================
    // 문제 6. 음양 더하기 (프로그래머스 Lv.1 #76501)
    // https://school.programmers.co.kr/learn/courses/30/lessons/76501
    // ===========================================
    //
    // 요구사항:
    // 1. 합계를 저장할 변수 sum = 0을 만드세요.
    // 2. for문으로 absolutes를 인덱스로 순회하세요.
    // 3. signs.get(i)가 true이면 absolutes.get(i)를 더하세요.
    // 4. signs.get(i)가 false이면 absolutes.get(i)를 빼세요.
    // 5. sum을 반환하세요.
    //
    // 입력: absolutes = [4, 7, 12], signs = [true, false, true]
    // 출력: 9  (4 + (-7) + 12 = 9)
    //
    public static int solution6(ArrayList<Integer> absolutes, ArrayList<Boolean> signs) {
        // 여기에 코드를 작성하세요
        return 0;
    }


    // ===========================================
    // 문제 7. 모의고사 (프로그래머스 Lv.1 #42840)
    // https://school.programmers.co.kr/learn/courses/30/lessons/42840
    // ===========================================
    //
    // 수포자 3명이 문제를 찍는 패턴:
    //   1번: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
    //   2번: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, ...
    //   3번: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...
    //
    // 요구사항:
    // 1. 각 수포자의 찍기 패턴을 int 배열로 만드세요.
    // 2. for문으로 answers를 순회하면서 각 수포자의 맞은 개수를 세세요.
    //    (패턴은 % 연산으로 반복: pattern[i % pattern.length])
    // 3. 세 명 중 최대 점수를 구하세요.
    // 4. 최대 점수와 같은 사람의 번호(1,2,3)를 결과 리스트에 추가하세요.
    // 5. 결과 리스트를 반환하세요.
    //
    // 입력: [1, 2, 3, 4, 5]
    // 출력: [1]
    //
    public static ArrayList<Integer> solution7(ArrayList<Integer> answers) {
        // 여기에 코드를 작성하세요
        return new ArrayList<>();
    }


    // ===========================================
    // 문제 8. 제일 작은 수 제거하기 (프로그래머스 Lv.1 #12935)
    // https://school.programmers.co.kr/learn/courses/30/lessons/12935
    // ===========================================
    //
    // 요구사항:
    // 1. arr의 크기가 1이면 [-1]을 반환하세요.
    // 2. arr에서 최소값을 찾으세요. (Collections.min() 사용 가능)
    // 3. 결과를 담을 새 ArrayList를 만드세요.
    // 4. for문으로 arr을 순회하면서 최소값이 아닌 것만 결과에 추가하세요.
    // 5. 결과 리스트를 반환하세요.
    //
    // 입력: [1, 8, 3]
    // 출력: [8, 3]
    //
    public static ArrayList<Integer> solution8(ArrayList<Integer> arr) {
        // 여기에 코드를 작성하세요
        return new ArrayList<>();
    }


    // ===========================================
    // 문제 9. 폰켓몬 (프로그래머스 Lv.1 #1845)
    // https://school.programmers.co.kr/learn/courses/30/lessons/1845
    // ===========================================
    //
    // N마리 중 N/2마리를 선택할 때, 최대한 다양한 종류를 고르고 싶습니다.
    //
    // 요구사항:
    // 1. 선택 가능한 수 = nums.size() / 2를 구하세요.
    // 2. 종류 수를 세세요. (중복 제거된 개수)
    //    - 새 ArrayList를 만들고, nums를 순회하면서 .contains()로 중복 체크 후 추가
    // 3. 종류 수와 선택 가능한 수 중 작은 값을 반환하세요. (Math.min())
    //
    // 입력: [3, 1, 2, 3]
    // 출력: 2  (종류: 3가지, 선택: 2마리 → min(3, 2) = 2)
    //
    public static int solution9(ArrayList<Integer> nums) {
        // 여기에 코드를 작성하세요
        return 0;
    }


    // ===========================================
    // 문제 10. 리스트 뒤집기
    // ===========================================
    //
    // 요구사항:
    // 1. 결과를 담을 새 ArrayList<Integer>를 만드세요.
    // 2. for문을 arr.size()-1부터 0까지 거꾸로 순회하세요.
    // 3. 각 원소를 결과 리스트에 추가하세요.
    // 4. 결과 리스트를 반환하세요.
    //
    // (Collections.reverse() 사용 금지!)
    //
    // 입력: [1, 2, 3, 4, 5, 6]
    // 출력: [6, 5, 4, 3, 2, 1]
    //
    public static ArrayList<Integer> solution10(ArrayList<Integer> arr) {
        // 여기에 코드를 작성하세요
        return new ArrayList<>();
    }
}