[프로그래머스] PCCE 기출문제 10번 / 데이터 분석 - JAVA

---

• 1. 문제
• 2. 풀이

---

문제

https://school.programmers.co.kr/learn/courses/30/lessons/250121?language=java

프로그래머스

문제 내용은 지적 재산 보호 차원에서 가져오지 않고 풀이만 공유드리도록 하겠습니다.

---

풀이

 제 풀이가 무조건적으로 맞는 것도 최적의 답변도 아니지만, 이런 풀이도 있다는 차원에서 작성해 보며, 좀 더 나은 방법이 있다면 이야기해 주셔도 도움 될 것 같습니다.

 

 해당 풀이에서는 기존의 sort를 쓰지 않고 quick sort를 구현해서 사용해 보았습니다.

2024.01.11 - [개발 창고/Algorithm] - [ALGORITHM] QUICK SORT

[ALGORITHM] QUICK SORT

import java.util.Arrays;

class Solution {
    public int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {
        int[][] answer = {};
        
        // 1. 뽑아낼 대상 문자열이 있는 위치(Index) 번호 조회
        int extIdx = -1;
        if(ext.equals("code"))          extIdx = 0;
        else if(ext.equals("date"))     extIdx = 1;
        else if(ext.equals("maximum"))  extIdx = 2;
        else if(ext.equals("remain"))   extIdx = 3;
        // System.out.println(extIdx);
        
        int sortIdx = -1;
        if(sort_by.equals("code"))          sortIdx = 0;
        else if(sort_by.equals("date"))     sortIdx = 1;
        else if(sort_by.equals("maximum"))  sortIdx = 2;
        else if(sort_by.equals("remain"))   sortIdx = 3;
        // System.out.println(sortIdx);
        
        // 2. 대상 정렬
        quickSort(data, sortIdx, 0, data.length - 1, 1);
        // int[][] answser = data;
        
        // 3. 기준 이전 데이터만 반환
        for(int[] item:data){
            int extValue = item[extIdx];
            if(extValue <= val_ext){
                // answer.add(item);
                answer  = Arrays.copyOf(answer, answer.length + 1);
                answer[answer.length - 1] = item;
            }
        }
        
        return answer;
    }
    
    /**
     * 퀵정렬
     * @param arr  대상 배열
     * @param dataIdx 대상 값 Index
     * @param minIdx  최소 값 위치
     * @param maxIdx  최대 값 위치
     * @param level   깊이 (표기를 위한 것일 뿐 필수는 아님)
     */
    private void quickSort(int[][] arr, int dataIdx, int minIdx, int maxIdx, int level){
        // System.out.println("===================== 퀵 정렬 시작 " + level + " =====================");
        
        // 최소 값 위치가 최대 값 위치보다 크거나 같은 경우 더이상 탐색 하지 않음
        if (minIdx >= maxIdx){
            return;
        }
        
        // System.out.println("입력 MIN " + minIdx + ", MAX " + maxIdx);
        
        // System.out.println("################### PIVOT 지정 ###################");
        int pivotIdx   = minIdx + (maxIdx - minIdx) / 2;    // PIVOT 값 위치 산출
        int pivotValue = arr[pivotIdx][dataIdx];                     // PIVOT 값
        // System.out.println("PIVOT 위치 " + pivotIdx + ", 값 " + pivotValue);
        
        // ################### 탐색 및 SWAP ###################
        int leftIdx  = minIdx;      // 시작 left 위치 지정
        int rightIdx = maxIdx;      // 시작 right 위치 지정
        
        // left 위치가 right과 같거나 커질 때까지 반복
        while(leftIdx < rightIdx){
            // System.out.println("################### 왼쪽 탐색 ###################");
            // left 값이 pivot값 보다 작은 경우 left 위치를 오른쪽으로 한 칸 이동
            do {
                int leftValue = arr[leftIdx][dataIdx];
                // System.out.println("LEFT 위치  " + leftIdx + ", 값 " + leftValue);
                
                if(leftValue < pivotValue){
                    leftIdx++;
                }else{
                    break;
                }
            } while(leftIdx < rightIdx);
            
            // System.out.println("################### 오른쪽 탐색 ###################");
            // right값이 pivot값 보다 큰 경우 right 위치를 왼쪽으로 한 칸 이동
            do {
                int rightValue = arr[rightIdx][dataIdx];
                // System.out.println("RIGHT 위치  " + rightIdx + ", 값 " + rightValue);
                
                if(rightValue > pivotValue){
                	rightIdx--;
                }else{
                    break;
                }
            } while(leftIdx < rightIdx);
            
            if(arr[leftIdx][dataIdx] > arr[rightIdx][dataIdx]){
                // System.out.println("################### SWAP ###################");
                int[] temp      = arr[leftIdx];
                arr[leftIdx]    = arr[rightIdx];
                arr[rightIdx]   = temp;
                
                // 현재 값이 Pivot값이 아닌 경우 한칸 이동
                if(arr[leftIdx][dataIdx] != pivotValue)    leftIdx++;
                if(arr[rightIdx][dataIdx] != pivotValue)   rightIdx--;
            }
        }
        
        // 끝이 시작보다 큰 경우 배열 좌측 정렬
        if(leftIdx > minIdx){
            // System.out.println("################### 좌측 분할 정렬 ###################");
            quickSort(arr, dataIdx, minIdx, leftIdx, level + 1);
        }
        
        // 시작이 끝보다 작은 경우 배열 우측 정렬
        if(leftIdx + 1 < maxIdx){
            // System.out.println("################### 우측 분할 정렬 ###################");
            quickSort(arr, dataIdx, leftIdx + 1, maxIdx, level + 1);
        }
        
        // System.out.println("===================== 퀵 정렬 종료 " + level + " =====================");
    }
}

코드 실행 결과

제출 결과