[ 프로그래머스 JAVA ] 데이터 분석

문제 출처

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

프로그래머스

 

걸린 시간

11:10 ~ 11:49 // 소요 시간 39분

 

피드백

정렬 문제가 나올 경우 함수를 사용한 정렬로 방향을 잡는 것이 좋다.

다만 , 데이터의 수가 많을 경우 함수는 시간 복잡도가 nLogn 이기 때문에 시간 복잡도가 더 낮은 정렬 알고리즘을 사용해야 할 수도 있다.

 

문제

AI 엔지니어인 현식이는 데이터를 분석하는 작업을 진행하고 있습니다. 데이터는 ["코드 번호(code)", "제조일(date)", "최대 수량(maximum)", "현재 수량(remain)"]으로 구성되어 있으며 현식이는 이 데이터들 중 조건을 만족하는 데이터만 뽑아서 정렬하려 합니다.

예를 들어 다음과 같이 데이터가 주어진다면

data = [[1, 20300104, 100, 80], [2, 20300804, 847, 37], [3, 20300401, 10, 8]]

이 데이터는 다음 표처럼 나타낼 수 있습니다.

code date maximum remain

1	20300104	100	80
2	20300804	847	37
3	20300401	10	8

주어진 데이터 중 "제조일이 20300501 이전인 물건들을 현재 수량이 적은 순서"로 정렬해야 한다면 조건에 맞게 가공된 데이터는 다음과 같습니다.

data = [[3,20300401,10,8],[1,20300104,100,80]]

정렬한 데이터들이 담긴 이차원 정수 리스트 data와 어떤 정보를 기준으로 데이터를 뽑아낼지를 의미하는 문자열 ext, 뽑아낼 정보의 기준값을 나타내는 정수 val_ext, 정보를 정렬할 기준이 되는 문자열 sort_by가 주어집니다.

data에서 ext 값이 val_ext보다 작은 데이터만 뽑은 후, sort_by에 해당하는 값을 기준으로 오름차순으로 정렬하여 return 하도록 solution 함수를 완성해 주세요. 단, 조건을 만족하는 데이터는 항상 한 개 이상 존재합니다.

 

제한사항

• 1 ≤ data의 길이 ≤ 500
  • data[i]의 원소는 [코드 번호(code), 제조일(date), 최대 수량(maximum), 현재 수량(remain)] 형태입니다.
  • 1 ≤ 코드 번호≤ 100,000
  • 20000101 ≤ 제조일≤ 29991231
  • data[i][1]은 yyyymmdd 형태의 값을 가지며, 올바른 날짜만 주어집니다. (yyyy : 연도, mm : 월, dd : 일)
  • 1 ≤ 최대 수량≤ 10,000
  • 1 ≤ 현재 수량≤ 최대 수량
• ext와 sort_by의 값은 다음 중 한 가지를 가집니다.
  • "code", "date", "maximum", "remain"
  • 순서대로 코드 번호, 제조일, 최대 수량, 현재 수량을 의미합니다.
• val_ext는 ext에 따라 올바른 범위의 숫자로 주어집니다.
• 정렬 기준에 해당하는 값이 서로 같은 경우는 없습니다.

문제 풀이 ( 주석 참고 )

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

class Solution {
        public int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {


            // Data 저장할 list 생성
            List<Data> dataList = new ArrayList<>();

            for( int i = 0 ; i < data.length; i++ ){
                // 생성자를 통해 data 배열에 있는 데이터 dataList 에 삽입
                // 조건에 따라서 저장되는 것들만 선별
                if("code".equals(ext) && data[i][0] < val_ext ){
                    dataList.add(new Data( data[i][0] , data[i][1]  , data[i][2]  , data[i][3] ));
                }
                if("date".equals(ext) && data[i][1] < val_ext){
                    dataList.add(new Data( data[i][0] , data[i][1]  , data[i][2]  , data[i][3] ));
                }
                if("maximum".equals(ext) && data[i][2] < val_ext){
                    dataList.add(new Data( data[i][0] , data[i][1]  , data[i][2]  , data[i][3] ));
                }
                if("remain".equals(ext) && data[i][3] < val_ext){
                    dataList.add(new Data( data[i][0] , data[i][1]  , data[i][2]  , data[i][3] ));
                }
            }
						// 오름차순 정렬 해야되는 요소에 따라서 다르게 오름차순 정렬
            if("code".equals(sort_by)){
                dataList = dataList.stream().sorted(Comparator.comparing(Data::getCode)).collect(Collectors.toList());
            }
            if("date".equals(sort_by)){
                dataList = dataList.stream().sorted(Comparator.comparing(Data::getDate)).collect(Collectors.toList());
            }
            if("maximum".equals(sort_by)){
                dataList = dataList.stream().sorted(Comparator.comparing(Data::getMaximum)).collect(Collectors.toList());
            }
            if("remain".equals(sort_by)){
                dataList = dataList.stream().sorted(Comparator.comparing(Data::getRemain)).collect(Collectors.toList());
            }

            int[][] answer = new int[dataList.size()][4];
						// 이중 배열로 다시 parsing 작업 
            for( int i = 0; i < dataList.size() ; i++ ){
                answer[i][0] = dataList.get(i).getCode();
                answer[i][1] = dataList.get(i).getDate();
                answer[i][2] = dataList.get(i).getMaximum();
                answer[i][3] = dataList.get(i).getRemain();
            }


            return answer;
        }


        class Data{
            int code;
            int date;
            int maximum;
            int remain;

            public Data( int code , int loc , int maximum , int remain ) {
                this.code = code;
                this.date = loc;
                this.maximum = maximum;
                this.remain = remain;
            }

            public int getCode() {
                return code;
            }

            public void setCode (int code) {
                this.code = code;
            }

            public int getDate() {
                return date;
            }

            public void setDate (int date) {
                this.date = date;
            }
            public int getMaximum() {
                return maximum;
            }

            public void setMaximum (int maximum) {
                this.maximum = maximum;
            }
            public int getRemain() {
                return remain;
            }

            public void setRemain (int remain) {
                this.remain = remain;
            }

        }

}