JunFe의 ANDONE

문제 설명

정수 리스트 num_list와 정수 n이 주어질 때, n 번째 원소부터 마지막 원소까지의 모든 원소를 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항

2 ≤ num_list의 길이 ≤ 30

1 ≤ num_list의 원소 ≤ 9

1 ≤ n ≤ num_list의 길이

입출력 예

입출력 예 설명

입출력 예 #1

[2, 1, 6]의 세 번째 원소부터 마지막 원소까지의 모든 원소는 [6]입니다.

입출력 예 #2

[5, 2, 1, 7, 5]의 두 번째 원소부터 마지막 원소까지의 모든 원소는 [2, 1, 7, 5]입니다.

문제풀이

-> num_list의 length와 n값을 뺀 후 +1을 하면 result의 length가 된다. 이를 통해 answer를 선언하고, for문을 통해서 length만큼 반복하여 index 값을 고려해 num_list의 값들을 담아주면된다.

코드

class Solution {
    public int[] solution(int[] num_list, int n) {
        int[] answer = {};
        int length = num_list.length - n + 1;
        answer = new int[length];
        for(int i=0;i<length;i++){
            answer[i]=num_list[n-1+i];
        }
        return answer;
    }
}

문제 설명

정수 배열 arr와 query가 주어집니다.

query를 순회하면서 다음 작업을 반복합니다.

짝수 인덱스에서는 arr에서 query[i]번 인덱스를 제외하고 배열의 query[i]번 인덱스 뒷부분을 잘라서 버립니다.

홀수 인덱스에서는 arr에서 query[i]번 인덱스는 제외하고 배열의 query[i]번 인덱스 앞부분을 잘라서 버립니다.

위 작업을 마친 후 남은 arr의 부분 배열을 return 하는 solution 함수를 완성해 주세요.

제한사항

5 ≤ arr의 길이 ≤ 100,000

     - 0 ≤ arr의 원소 ≤ 100

1 ≤ query의 길이 < min(50, arr의 길이 / 2)

     - query의 각 원소는 0보다 크거나 같고 남아있는 arr의 길이 보다 작습니다.

입출력 예

입출력 예 설명

입출력 예 #1

이번에 매번 처리할 query의 값과 처리 전후의 arr의 상태를 표로 나타내면 다음과 같습니다.

따라서 [1, 2, 3]을 return 합니다.

문제풀이

-> 배열을 넣고 빼기 위해서 ArrayList를 사용하였다. 그런데 앞부분 배열을 뺄 때, 인덱스 값을 같이 줄여줘야하는데 그대로 계속 구하려고 하다보니 런타임 오류가 나서 애를 많이 먹었다.

코드

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        ArrayList<Integer> arrayList = new ArrayList<>();

        for (int i = 0; i < arr.length; i++) {
            arrayList.add(arr[i]);
        }

        for (int i = 0; i < query.length; i++) {
            if (i % 2 == 0) {
                for (int j = query[i] + 1; j < arrayList.size();) {
                    arrayList.remove(j);
                }
            } else {
                for (int j = query[i] - 1; j >= 0;) {
                    arrayList.remove(j);
                    j--;
                }
            }
        }

        int[] answer = new int[arrayList.size()];
        for (int i = 0; i < arrayList.size(); i++) {
            answer[i] = arrayList.get(i);
        }

        return answer;
    }
}

문제 설명

정수 배열 arr가 주어집니다. 배열 안의 2가 모두 포함된 가장 작은 연속된 부분 배열을 return 하는 solution 함수를 완성해 주세요.

단, arr에 2가 없는 경우 [-1]을 return 합니다.

제한사항

- 1 ≤ arr의 길이 ≤ 100,000

            - 1 ≤ arr의 원소 ≤ 10

입출력 예

입출력 예 설명

입출력 예 #1

2가 있는 인덱스는 1번, 5번 인덱스뿐이므로 1번부터 5번 인덱스까지의 부분 배열인 [2, 1, 4, 5, 2]를 return 합니다.

입출력 예 #2

2가 한 개뿐이므로 [2]를 return 합니다.

입출력 예 #3

2가 배열에 없으므로 [-1]을 return 합니다.

입출력 예 #4

2가 있는 인덱스는 1번, 3번, 6번 인덱스이므로 1번부터 6번 인덱스까지의 부분 배열인 [2, 1, 2, 1, 10, 2]를 return 합니다.

문제 풀이

-> 먼저 2가 arr에 몇개가 있는지 count를 통해 구한다. 2의 개수가 0이 아니라면 임시 배열에 2가 있는 index값을 담은 후, 해당 배열을 통해서 반복문을 작성하여 arr배열에서 필요한 index부분의 값을 가져와 answer 배열에 담는다. 2의 개수가 0이라면 answer 배열의 크기를 1로 두고 -1을 담는다.

코드

import java.util.*;
class Solution {
    public int[] solution(int[] arr) {
        int[] answer = {};
        int count = 0;
        int count2 = 0;
        int[] temp = {};
        for(int i=0;i<arr.length;i++){
            if(arr[i]==2){
                count++;
            }
        }
        if(count!=0){
            temp = new int[count];
            
            for(int i=0;i<arr.length;i++){
            if(arr[i]==2){
                temp[count2]=i;
                count2++;
                }
            }
            answer = new int[temp[temp.length-1]-temp[0]+1];
            for(int i=0; i<temp[temp.length-1]-temp[0]+1;i++){
              answer[i]=arr[temp[0]+i];
            }
        } else {
            answer = new int [1];
            answer[0]=-1;
        }
    
        return answer;
    }
}

문제 설명

정수 배열 arr와 2개의 구간이 담긴 배열 intervals가 주어집니다. intervals는 항상 [[a1, b1], [a2, b2]]의 꼴로 주어지며 각 구간은 닫힌 구간입니다. 닫힌 구간은 양 끝값과 그 사이의 값을 모두 포함하는 구간을 의미합니다. 이때 배열 arr의 첫 번째 구간에 해당하는 배열과 두 번째 구간에 해당하는 배열을 앞뒤로 붙여 새로운 배열을 만들어 return 하는 solution 함수를 완성해 주세요.

제한사항

1 ≤ arr의 길이 ≤ 100,000

1 ≤ arr의 원소 < 100

1 ≤ a1 ≤ b1 < arr의 길이

1 ≤ a2 ≤ b2 < arr의 길이

입출력 예

입출력 예 설명

입출력 예 #1

첫 번째 구간에 해당하는 배열은 [2, 3, 4] 입니다.

두 번째 구간에 해당하는 배열은 [1, 2, 3, 4, 5] 입니다.

따라서 이 두 배열을 앞뒤로 붙인 배열인 [2, 3, 4, 1, 2, 3, 4, 5]를 return 합니다.

문제 풀이

-> answer 배열의 길이를 구해서 미리 초기화 해두고, 반복문을 통해서 intervals 값을 가지고 arr 값들을 빼내어 result를 구한다.

코드

class Solution {
    public int[] solution(int[] arr, int[][] intervals) {
        int[] answer = {};
        int length = intervals[0][1]-intervals[0][0]+1+intervals[1][1]-intervals[1][0]+1;
        answer = new int[length];
        int index = 0;
        for(int i=0;i<2;i++){
            for(int j=intervals[i][0];j<intervals[i][1]+1;j++){
                answer[index] = arr[j];
                index++;
            }
        }
        return answer;
    }
}

문제 설명

정수 리스트 num_list가 주어질 때, 첫 번째로 나오는 음수의 인덱스를 return하도록 solution 함수를 완성해주세요. 음수가 없다면 -1을 return합니다.

제한사항

5 ≤ num_list의 길이 ≤ 100
-10 ≤ num_list의 원소 ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1
5번 인덱스에서 음수가 처음 등장하므로 5를 return합니다.

입출력 예 #2
음수가 없으므로 -1을 return합니다.

풀이

-> 반복문을 통해서 처음 음수가 나오면 해당 index값을 answer에 넣어주고, break문을 통해 반복을 멈춘다. answer값은 초기값을 -1로 하여 음수가 없을 경우 -1을 리턴한다.

class Solution {
    public int solution(int[] num_list) {
        int answer = -1;
        for(int i=0;i<num_list.length;i++){
            if(num_list[i]<0){
                answer = i;
                break;
            }
        }
        return answer;
    }
}

문제 설명

정수 n과 정수 3개가 담긴 리스트 slicer 그리고 정수 여러 개가 담긴 리스트 num_list가 주어집니다. slicer에 담긴 정수를 차례대로 a, b, c라고 할 때, n에 따라 다음과 같이 num_list를 슬라이싱 하려고 합니다.

n = 1 : num_list의 0번 인덱스부터 b번 인덱스까지

n = 2 : num_list의 a번 인덱스부터 마지막 인덱스까지

n = 3 : num_list의 a번 인덱스부터 b번 인덱스까지

n = 4 : num_list의 a번 인덱스부터 b번 인덱스까지 c 간격으로

올바르게 슬라이싱한 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항

n 은 1, 2, 3, 4 중 하나입니다.

slicer의 길이 = 3

slicer에 담긴 정수를 차례대로 a, b, c라고 할 때

• 0 ≤ a ≤ b ≤ num_list의 길이 - 1
• 1 ≤ c ≤ 3

5 ≤ num_list의 길이 ≤ 30

0 ≤ num_list의 원소 ≤ 100

입출력 예

입출력 예 설명

입출력 예 #1

[1, 2, 3, 4, 5, 6, 7, 8, 9]에서 1번 인덱스부터 5번 인덱스까지 자른 리스트는 [2, 3, 4, 5, 6]입니다.

입출력 예 #2

[1, 2, 3, 4, 5, 6, 7, 8, 9]에서 1번 인덱스부터 5번 인덱스까지 2개 간격으로 자른 리스트는 [2, 4, 6]입니다.

풀이

-> 조건문으로 n 값이 1,2,3,4 일 때로 나누고, n=4일 경우 slicer[1]-slicer[0]값이 홀수일 때와 짝수일 때를 나누어 계산한다.

class Solution {
    public int[] solution(int n, int[] slicer, int[] num_list) {
        int[] answer = {};
        if(n==1){
            answer = new int[slicer[1]+1];
            for(int i=0; i<slicer[1]+1;i++){
                answer[i]=num_list[i];
            }
        } else if(n==2){
            answer = new int[num_list.length-slicer[0]];
            for(int i=0; i<num_list.length-slicer[0]; i++){
                answer[i]=num_list[slicer[0]+i];
            }
        } else if(n==3){
            answer = new int[slicer[1]-slicer[0]+1];
            for(int i=0; i<slicer[1]-slicer[0]+1;i++){
                answer[i]=num_list[slicer[0]+i];
            }
        } else if(n==4){
            if((slicer[1]-slicer[0])%2==0){
                answer = new int[(slicer[1]-slicer[0])/2+1];
                for(int i=0; i<answer.length;i++){
                    answer[i]=num_list[slicer[0]+2*i];
                }
            } else if((slicer[1]-slicer[0])%2==1){
                answer = new int[(slicer[1]-slicer[0])/2+1];
                for(int i=0; i<answer.length; i++){
                    answer[i]=num_list[slicer[0]+2*i];
                }
            }
        }
        return answer;
    }
}

문제 설명

정수 배열 arr가 주어집니다. 이때 arr의 원소는 1 또는 0입니다. 정수 idx가 주어졌을 때, idx보다 크면서 배열의 값이 1인 가장 작은 인덱스를 찾아서 반환하는 solution 함수를 완성해 주세요. 단, 만약 그러한 인덱스가 없다면 -1을 반환합니다.

제한사항

3 ≤ arr의 길이 ≤ 100'000

arr의 원소는 전부 1 또는 0입니다.

입출력 예

입출력 예 설명

입출력 예 #1

1보다 크면서 원소가 1인 가장 작은 인덱스는 3입니다. 따라서 3을 return 합니다.

입출력 예 #2

4번 인덱스 이후에 1은 등장하지 않습니다. 따라서 -1을 return 합니다.

입출력 예 #3

3번 인덱스의 값이 1입니다. 따라서 3을 return 합니다.

풀이

-> idx값부터 arr의 length만큼 반복문을 돌려서 1이 있는지 확인하고 확인되면 break문을 통해 for문을 빠져나간다.

코드

class Solution {
    public int solution(int[] arr, int idx) {
        int answer = 0;
        for(int i=idx;i<arr.length;i++){
            if(arr[i]==1){
                answer = i;
                break;
            } else {
                answer = -1;
            }
        }
        return answer;
    }
}

문제 설명

정수 start_num와 end_num가 주어질 때, start_num에서 end_num까지 1씩 감소하는 수들을 차례로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항

0 ≤ end_num ≤ start_num ≤ 50

입출력 예

입출력 예 설명

입출력 예 #1

10부터 3까지 1씩 감소하는 수를 담은 리스트는 [10, 9, 8, 7, 6, 5, 4, 3]입니다.

풀이

-> start와 end_num의 차이로 length를 정해두고 반복문을 돌려서 start값부터 1씩 감소하면서 answer배열에 담는다.

코드

class Solution {
    public int[] solution(int start, int end_num) {
        int[] answer = {};
        int length = start - end_num + 1;
        answer = new int[length];
        for(int i=0;i<length;i++){
            answer[i]=start--;
        }
        return answer;
    }
}