Strong Root

난이도 ★★☆☆


문제를 보시려면 여기를 클릭





문제 요약

 등장하지 않은 정수 찾기 (범위 : 1 ~ 2,147,483,647)





힌트

 자료구조 문제입니다. HashSet을 잘 이용할 것





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public int solution(int[] A) {
    Set<Integer> foundNums = new HashSet<>();
 
    for (int a : A) {
        foundNums.add(a);
    }
 
    for (int i = 1; i <= Integer.MAX_VALUE; i++) {
        if (!foundNums.contains(i)) {
            return i;
        }
    }
 
    return -1;
}
cs

난이도 ★★☆☆


문제를 보시려면 여기를 클릭





문제 요약

 1, 2, ... , X가 다 나오는 최소 인덱스 찾기 (없으면 -1 리턴)





힌트

 자료구조 문제입니다. HashSet을 잘 이용할 것





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public int solution(int X, int[] A) {
    Set<Integer> marks = new HashSet<>();
 
    for (int i = 0; i < A.length; i++) {
        if (A[i] <= X) {
            marks.add(A[i]);
 
            if (marks.size() == X) {
                return i;
            }
        }
    }
 
    return -1;
}
cs

난이도 ★★☆☆


문제를 보시려면 여기를 클릭





문제 요약

 1부터 모든 정수가 다 있는지 확인하기 (완전한 순열인지 확인)





힌트

 완전한 순열이 아니게 되는 조건을 특정해서 그거만 체크하기 (딱 2가지 있음)





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public int solution(int[] A) {
    Set<Integer> marks = new HashSet<>();
 
    for (int i = 0; i < A.length; i++) {
        if (A[i] > A.length) {
            return 0;
        }
 
        if (marks.contains(A[i])) {
            return 0;
        }
 
        marks.add(A[i]);
    }
 
    return 1;
}
cs

난이도 ★★☆☆


문제를 보시려면 여기를 클릭





문제 요약

 두 구간으로 쪼갰을 때, 구간별 합의 차가 가장 적은 곳 찾기





힌트

 구간별 합을 미리 구해놓아서 중첩for문 없애기





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public int solution(int[] A) {
    int sum_fromFirst = 0;
    int sum_toLast = 0;
 
    for (int i = 0; i < A.length; i++) {
        sum_toLast += A[i];
    }
 
    int minDiff = Integer.MAX_VALUE;
 
    for (int p = 1; p < A.length; p++) {
        sum_fromFirst += A[p - 1];
        sum_toLast -= A[p - 1];
 
        int diff = Math.abs(sum_fromFirst - sum_toLast);
 
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
 
    return minDiff;
}
cs

난이도 ★


문제를 보시려면 여기를 클릭





문제 요약

 X부터 Y까지 D씩 몇번가면 도착하나





힌트

 반복문 돌지말고 수학으로 계산하세요





이하는 코드입니다.


1
2
3
public int solution(int X, int Y, int D) {
    return (int) Math.ceil((Y - X) / (double) D);
}
cs

난이도 ★


문제를 보시려면 여기를 클릭





문제 요약

 정수 1부터 쭉 찾다보면 딱 1개가 등장하지 않는데, 그 숫자를 리턴하면 됩니다





힌트

 체크를 효율적으로 잘(?) 하면 됩니다. 중첩for문을 돌면 안됩니다





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public int solution(int[] A) {
    boolean[] checked = new boolean[A.length + 2];
 
    for (int i = 0; i < A.length; i++) {
        checked[A[i]] = true;
    }
 
    for (int i = 1; i < checked.length; i++) {
        if (!checked[i]) {
            return i;
        }
    }
 
    return -1;
}
cs

난이도 ★


문제를 보시려면 여기를 클릭





문제 요약

 A배열을 K번만큼 오른쪽으로 shift하면 됩니다





힌트

 K번만큼 실제로 일일이 이동하지 말고, 최종 위치로 한번에 일괄 이동합니다





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
public int[] solution(int[] A, int K) {
    int[] ret = new int[A.length];
 
    for (int i = 0; i < A.length; i++) {
        int idx = (i + K) % A.length;
 
        ret[idx] = A[i];
    }
 
    return ret;
}
cs


난이도 ★


문제를 보시려면 여기를 클릭





문제 요약

 총 홀수번 등장하는 숫자가 딱 1종류 있는데 그걸 리턴하면 됩니다 





힌트

 자료구조 문제이며, 등장 횟수 측정의 부하를 줄이는 것이 핵심입니다 (Hash 사용을 추천)





이하는 코드입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public int solution(int[] A) {
    Map<Integer, Integer> countMap = new HashMap<>();
 
    for (int i = 0; i < A.length; i++) {
        increaseCount(countMap, A[i]);
    }
 
    for (Integer key : countMap.keySet()) {
        if (countMap.get(key) % 2 != 0) {
            return key;
        }
    }
 
    return -1;
}
 
private void increaseCount(Map<Integer, Integer> countMap, int targetNum) {
    Integer target = countMap.get(targetNum);
 
    if (target == null) {
        countMap.put(targetNum, 1);
    }
    else {
        countMap.put(targetNum, target + 1);
    }
}
cs