[알고리즘문제풀기] 리스트 자르기

문제

내가 작성한 정답

for

import java.util.*;

class Solution {
    public int[] solution(int n, int[] slicer, int[] num_list) {
        ArrayList<Integer> answer = new ArrayList<>();
        if(n==1){
            for(int i = 0; i<=slicer[1]; i++) {
                answer.add(num_list[i]);
            }
        } else if (n==2) {
            for(int i = slicer[0]; i<num_list.length; i++) {
                answer.add(num_list[i]);
            }
        } else if (n==3) {
            for(int i = slicer[0]; i<=slicer[1]; i++) {
                answer.add(num_list[i]);
            }
        } else if (n==4) {
            for(int i = slicer[0]; i <= slicer[1]; i += slicer[2]) {
                answer.add(num_list[i]);
            }
        }
        return answer.stream().mapToInt(i->i).toArray();
    }
}

stream

import java.util.stream.IntStream;

class Solution {
    public int[] solution(int n, int[] slicer, int[] num_list) {
        if(n==1) {
            return IntStream.rangeClosed(0,slicer[1]).map(i->num_list[i]).toArray();
        } else if (n==2) {
            return IntStream.range(slicer[0],num_list.length).map(i->num_list[i]).toArray();
        } else if (n==3) {
            return IntStream.rangeClosed(slicer[0],slicer[1]).map(i->num_list[i]).toArray();
        } else if (n==4) {
            return IntStream.rangeClosed(slicer[0]-1,slicer[1])
                    .filter(i-> (i - slicer[0])%slicer[2]==0)
                    .map(i->num_list[i]).toArray();
        }
        return null;
    }
}

다른 사람들의 정답

class Solution {
    public int[] solution(int n, int[] slicer, int[] num_list) {
        int start = n == 1 ? 0 : slicer[0];
        int end = n == 2 ? num_list.length - 1 : slicer[1];
        int step = n == 4 ? slicer[2] : 1;
        int[] answer = new int[(end - start + step) / step];
        for (int i = start, j = 0; i <= end; i += step) {
            answer[j++] = num_list[i];
        }
        return answer;
    }
}

import java.util.Arrays;
import java.util.stream.IntStream;

class Solution {
    public int[] solution(int n, int[] slicer, int[] num_list) {

        int[] answer = null;
        int a = slicer[0], b = slicer[1], c = slicer[2];

        switch (n) {
        case 1:
            answer = Arrays.copyOf(num_list, b + 1);
            break;
        case 2:
            answer = Arrays.copyOfRange(num_list, a, num_list.length);
            break;
        case 3:
            answer = Arrays.copyOfRange(num_list, a, b + 1);
            break;
        case 4:
            answer = IntStream.range(0, (b - a) / c + 1).map(i -> num_list[a + i * c]).toArray();
            break;
        }

        return answer;
    }
}

import java.util.*;
import java.util.stream.IntStream;

class Solution {
    public int[] solution(int n, int[] slicer, int[] numList) {
        return IntStream.iterate(
                    // 1. 초기값 (시작 인덱스)
                    // n이 1이면 0부터 시작하고, 그렇지 않으면 slicer[0]부터 시작한다.
                    n == 1 ? 0 : slicer[0],

                    // 2. 조건식 (스트림 생성을 계속할지 판단)
                    // 현재 인덱스 i가 이 조건을 만족하는 동안 스트림 요소가 생성된다.
                    // n이 2이면 i가 numList.length - 1 이하인지 확인하고,
                    // n이 2가 아니면 i가 slicer[1] 이하인지 확인한다.
                    // -> 각 경우에 맞는 끝 인덱스까지 포함하도록 조건을 설정
                    i -> i <= (n == 2 ? numList.length - 1 : slicer[1]),

                    // 3. 다음값 생성 함수 (인덱스를 어떻게 증가시킬지 결정)
                    // 현재 인덱스 i를 가지고 다음 인덱스를 만든다.
                    // n이 4이면 i에 slicer[2] (간격)를 더하고,
                    // n이 4가 아니면 i에 1을 더한다.
                    // ->  n=4일 때만 간격이 적용되고 나머지 경우는 1씩 증가
                    i -> n == 4 ? i + slicer[2] : i + 1
               )
               // 4. map(i -> numList[i]): 위 iterate로 생성된 각 숫자(i,배열의 인덱스)를 가지고
               //                         numList 배열에서 해당 인덱스 위치의 값을 가져온다.
               .map(i -> numList[i])
               // 5. toArray(): map으로 가져온 값들을 int 배열로 모아서 최종 결과로 반환한다.
               .toArray();
    }
}
    }
}