프로그래머스 LV2 - 귤 고르기

나의 풀이

public class P138476 {
    public static void main(String[] args) {
        int[] tangerine = {1, 3, 2, 5, 4, 5, 2, 3};
//        int[] tangerine = {1, 1, 1, 1, 2, 2, 2, 3};
//        int[] tangerine = {1};
        new Solution().solution(1, tangerine);
    }
}


class Solution {
    public int solution(int k, int[] tangerine) {
        int answer = 0;
        Arrays.sort(tangerine);

        Map<Integer, Integer> maps = new HashMap<>();
        for(int i = 0; i < tangerine.length; i++){
            if(maps.containsKey(tangerine[i])){
                int value = maps.get(tangerine[i]);
                maps.put(tangerine[i], value + 1);
            } else {
                maps.put(tangerine[i], 1);
            }
        }
        // 간략하게 한 버전
//            for (int i = 0; i < tangerine.length; i++) {
//                maps.put(tangerine[i], maps.getOrDefault(tangerine[i], 0) + 1);
//            }

//        List<Integer> arrList = new ArrayList<>();
//        Set<Integer> keys = maps.keySet();
//        for (Integer key : keys) {
//            int value = maps.get(key);
//            arrList.add(value);
//        }
        // 위의 코드를 간략하게 한 버전
        List<Integer> arrList = new ArrayList<>(maps.values());

        arrList.sort(Collections.reverseOrder());

        int sum = 0;
        for (Integer integer : arrList) {
            answer++;
            sum += integer;
            if (k <= sum) {
                break;
            }
        }

        return answer;
    }
}

1, 우선 tangerine을 오름차순으로 정렬 (지금보면 필요 없는 로직이었다. 귤의 위치를 기억해야 한다고 생각했어서 정렬을 해줬던거 같다.)
2, Map을 통해 해당크기에 같은 귤의 크기를 key와 value(갯수)로 정해준다. (나중에 리팩토링 했지만 maps.put(tangerine[i], maps.getOrDefault(tangerine[i], 0) + 1) 이런식으로 하면 containsKey를 사용하지 않아도 되어 더 효율이 좋다.
3, List<Integer> arrList = new ArrayList<>(maps.values()) 통해 List에 value값을 넣어준다.
4, 내림차순으로 정렬해준다. 정렬해주는 이유는 k값이 넣으면 최소 값을 찾을 수 있어서 내림차순으로 정렬해주었다.
5, sum에다 integer를 더 해주며 sum이 k보다 높거나 같을 때 break를 해준다. (변수명에 신경 써야겠다.)

다른 사람 풀이

class Solution {
    public int solution(int k, int[] tangerine) {
        int answer = 0;
        HashMap<Integer,Integer> map =new HashMap<>();

        for (int t : tangerine) {
            map.put(t, map.getOrDefault(t, 0) + 1);
        }

        List<Integer> list = new ArrayList<>(map.keySet());
        list.sort((o1, o2) -> map.get(o2)-map.get(o1));

        for(Integer key:list){
            k -=map.get(key);
            answer++;
            if(k<=0){
                break;
            }
        }

        return answer;
    }
}

나랑 기본적으로 로직은 비슷하였다.

        List<Integer> list = new ArrayList<>(map.keySet());
        list.sort((o1, o2) -> map.get(o2)-map.get(o1));

이 부분에서 많이 차이가 났는데 Map의 value를 기준으로 list.sort((o1, o2) -> map.get(o2)-map.get(o1))를 이용하여 내림차순으로 정렬해 주었다.

        for(Integer key:list){
            k -=map.get(key);
            answer++;
            if(k<=0){
                break;
            }
        }

그리고 내림차순으로 한 key를 기준으로 map의 value를 가지고 와서 k를 뺴주면서 0이되거나 0이 더커질 때 break를 해주었다.