[코딩테스트] 프로그래머스 - 베스트앨범(Java, Level3)

안녕하세요~

오늘 벌서 글을 3개나 기록하네요~

 

그래도 이번거는 시간이 꽤 걸렸지만 제가 풀었다는데 의의를 두고자 하는 문제입니다,

사실 풀기는 진작에 풀었지만 Map을 정렬해놓고 사용하지않아 바보같이 오래걸린 문제입니다.

문제 같이 확인해보고 코드, 그다음 제가 생각한 방식을 기록해보겠습니다.

 

먼저 문제만나보시죠.

https://school.programmers.co.kr/learn/courses/30/lessons/42579

프로그래머스

 

다음은 제가 작성한 코드입니다. 아무래도 그렇게 체계적이지는 않습니다.

import java.util.*;

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        
        List<Integer> answer_list=new ArrayList<>();
        
        Map<String, List<Integer>> map=new HashMap<>();
        
        for(int i=0;i<genres.length;i++)
        {
            List<Integer> list;
            
            if(map.containsKey(genres[i]))
            {
                list=map.get(genres[i]);
                list.add(plays[i]);
                map.replace(genres[i],list);
            }
            else
            {
                list=new ArrayList<>();
                list.add(plays[i]);
                map.put(genres[i],list);
            }
        }
        
        List<Map.Entry<String, List<Integer>>> entryList=new LinkedList<>(map.entrySet());
        Collections.sort(entryList,new Comparator<Map.Entry<String,List<Integer>>>()
                       {
                           @Override
                           public int compare(Map.Entry<String, List<Integer>>o1, Map.Entry<String, List<Integer>>o2)
                           {
                               List<Integer>o1List=o1.getValue();
                               List<Integer>o2List=o2.getValue();
                               if(o1List.stream().mapToInt(Integer::valueOf).sum()<=o2List.stream().mapToInt(Integer::valueOf).sum())
                                   return 1;
                               else
                                   return -1;
                               
                           }
                       });
        for(int k=0;k<entryList.size();k++)
        {
            Map.Entry<String, List<Integer>> element=entryList.get(k);
            List<Integer>genres_list=element.getValue();
                        Collections.sort(genres_list,Collections.reverseOrder());
            String key=element.getKey();
            
            if(genres_list.size()>=2)
            {
                int first=genres_list.get(0);
                int second=genres_list.get(1);
                
                int firstposition=-1;
                int secondposition=-1;
                
                for(int i=0;i<genres.length;i++)
                {
                    
                    if(first==second)
                    {
                        if(genres[i].equals(key)&&plays[i]==first&&firstposition==-1)
                        {
                            firstposition=i;
                        }                        
                        else if(genres[i].equals(key)&&plays[i]==second&&
                               secondposition==-1&&firstposition>-1)
                        {
                            secondposition=i;
                        }
                        
                        if(firstposition>-1&&secondposition>-1)
                            break;
                    }
                    else
                    {
                        if(genres[i].equals(key)&&plays[i]==first)
                            firstposition=i;                     
                        else if(genres[i].equals(key)&&plays[i]==second)
                            secondposition=i;
                        
                        if(firstposition>-1&&secondposition>-1)
                            break;
                    }

                        
                }
                answer_list.add(firstposition);
                answer_list.add(secondposition);
            }
            else if(genres_list.size()==1)
            {
                int first=genres_list.get(0);
                int firstposition=-1;
                for(int j=0;j<genres.length;j++)
                {
                    if(genres[j].equals(key)&&plays[j]==first)
                    {
                        firstposition=j;
                        break;
                    }
                        
                }
                answer_list.add(firstposition);
            }
        }

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

코드입니다.

이제 제가 생각한순서입니다.

① 장르key값으로 하고 플레이시간List를 Value로 갖는 HashMap을 만들었습니다.

② 다음은 해당 map의 value인 list의 합을 이용해 sorting해줬습니다. new Compare~부분참고해주시면 되겠습니다.

③ 정렬후 순서대로 탐색하기위해 key값을 가져오고 key에 해당하는 List를 가져오겠습니다.

④ 가져온 리스트를 Collections.reverseOrder를 통해 내림차순 정렬하겠습니다.

⑤ 만약 리스트 길이가 1이라면 하나의 값을, 2이상이라면 0,1번째의 값을 순서대로 가져옵니다.

ㄴ> 길이가 1일때는 가장 큰 값 하나

ㄴ> 길이가 2이상일때는 가장큰값, 그 다음으로 큰 값을 가져오겠습니다.

⑥ 다음은 기존의 Key값과 ⑤에서 구한 값들을 통해 위치를 찾아나가겠습니다. 위치는 

길이가 2이상일시 1,2번째가 같은 값일경우가 있을까 싶어 다르게 처리했습니다.

⑦ 해당값들을 검색완료하면 이제 List에 추가 후 toArray해 답을 리턴했습니다.

 

로직은 간단하다고 생각했는데 사실 며칠이 걸렸네요... 실제로 이문제가 나온다면 코딩테스트에 적용할 수 있을까라고 한다면 솔직히 못하겠네요.. 헤헤

 

그럼에도 풀었다는거에 의의를 두고싶네요.

 

오늘도 좋은하루 보내시길 바랍니다.

감사합니다. :D