[Programmers] 베스트 앨범

본 게시글은 PC 환경에서 보기 편하도록 설정이 되어 있습니다.

베스트 앨범

해시로 분류되어 있는 문제 입니다.

주어진 조건에 따라 compare를 할 수 있도록 @Override 된 compareTo 를 잘 구현하는 것이 관건인 문제입니다.

풀이 스타일

Java와 같은 객체지향 언어를 이용하여 알고리즘을 푼다면 객체지향스럽게 알고리즘을 풀어야 한다고 생각합니다.

단순한 알고리즘 풀이는 가독성은 당연히 떨어지고, Java를 쓰는 이유가 퇴색되는 것 같습니다.

따라서, Java를 이용해서 문제를 푸신다면 객체가 해야할 행동으로 문제를 풀 수 있도록 하시는 것을 추천드립니다.

Album 객체와 Album 객체를 List로 들고있는 AlbumBundle 객채를 이용하여 문제를 풀었습니다.

문제를 풀때 조금 더 편하게 하기 위해 AlbumBundle 객체의 멤버변수에 totalPlays 가 있지만 이를. 제거하고 구현 한다면 일급 컬렉션을 이용하여 문제를 푼다고 볼 수도 있을것 같습니다.

코드

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class BestAlbum {
    public static void main(String[] args) {
        Solution solution = new Solution();
        String[] genre = {"classic", "pop", "classic", "classic", "pop"};
        int[] plays = {500, 600, 150, 800, 2500};
        System.out.println(Arrays.toString(solution.solution(genre, plays)));
    }
}

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        int[] answer = {};

        Map<String, List<Album>> albums = new HashMap<>();

        for (int i = 0; i < genres.length; i++) {
            String genre = genres[i];
            Album album = new Album(i, genre, plays[i]);
            List<Album> albumList = albums.getOrDefault(genre, new ArrayList<>());
            albumList.add(album);
            Collections.sort(albumList);
            albums.put(genre,albumList);
        }

        List<AlbumBundle> albumBundles = new ArrayList<>();
        for (List<Album> albumList : albums.values()) {
            AlbumBundle albumBundle = new AlbumBundle(albumList);
            albumBundles.add(albumBundle);
        }

        Collections.sort(albumBundles);

        List<Integer> answers = new ArrayList<>();
        for (AlbumBundle albumBundle : albumBundles) {
            answers.addAll(albumBundle.getIndexList());
        }

        answer = answers.stream()
                .mapToInt(Integer::intValue)
                .toArray();

        return answer;
    }
}

class Album implements Comparable<Album> {
    private Integer index;
    private String genre;
    private Integer plays;

    public Album(Integer index, String genre, Integer plays) {
        this.index = index;
        this.genre = genre;
        this.plays = plays;
    }

    public Integer getPlays() {
        return plays;
    }

    public Integer getIndex() {
        return index;
    }

    @Override
    public int compareTo(Album album) {
        if (this.plays > album.plays) {
            return -1;
        }
        if (this.plays < album.plays) {
            return 1;
        }
        if (this.index > album.index) {
            return 1;
        }
        if (this.index < album.index) {
            return -1;
        }
        return 0;
    }

}

class AlbumBundle implements Comparable<AlbumBundle> {

    private List<Album> albums;
    private Integer totalPlays;

    public AlbumBundle(List<Album> albums) {
        this.albums = albums;
        this.totalPlays = albums.stream()
                .mapToInt(Album::getPlays)
                .sum();
    }

    public List<Integer> getIndexList() {
        List<Integer> bestIndex = new ArrayList<>();

        for (int i = 0; i < albums.size() && i < 2; i++) {
            bestIndex.add(albums.get(i).getIndex());
        }

        return bestIndex;
    }


    @Override
    public int compareTo(AlbumBundle albumBundle) {
        return albumBundle.totalPlays.compareTo(this.totalPlays);
    }

}