[Programmers / Level 2] 17686. [3차] 파일명 정렬 (Java)

💡 Info

• 난이도: Lv2
  프로그래머스 링크: https://school.programmers.co.kr/learn/courses/30/lessons/17686
  풀이 링크(GitHub): hayannn/CodingTest_Java/프로그래머스/2/[3차] 파일명 정렬

입출력 조건

입출력 예시

문제 이해

• 파일명을 HEAD, NUMBER, TAIL 세 부분으로 나누어 특정 규칙에 따라 정렬하는 문제

알고리즘

풀이 시간 : 35분

• 정규 표현식 : ^([^0-9]+)([0-9]{1,5})(.*)$ 패턴으로 HEAD, NUMBER, TAIL 분리
• Arrays.sort() + 람다식: 커스텀 정렬 로직을 람다식으로 구현
• HEAD 먼저 비교 -> HEAD가 같으면 NUMBER 비교

import java.util.*;
import java.util.regex.*;

class Solution {
    public String[] solution(String[] files) {
        Arrays.sort(files, (o1, o2) -> {
            // 정규표현식 : HEAD, NUMBER 추출
            Pattern pattern = Pattern.compile("^([^0-9]+)([0-9]{1,5})(.*)$");
            Matcher m1 = pattern.matcher(o1);
            Matcher m2 = pattern.matcher(o2);
            
            m1.matches();
            m2.matches();
            
            String head1 = m1.group(1).toLowerCase();
            String head2 = m2.group(1).toLowerCase();
            int num1 = Integer.parseInt(m1.group(2));
            int num2 = Integer.parseInt(m2.group(2));
            
            // HEAD 먼저 비교
            int headCompare = head1.compareTo(head2);
            if (headCompare != 0) {
                return headCompare;
            }
            
            // HEAD가 같으면 -> NUMBER 비교
            return Integer.compare(num1, num2);
        });
        
        return files;
    }
}

결과

✍️ 다른 풀이 - 문자열 파싱 + Comparator 인터페이스 구현

• 문자열 직접 파싱 : 반복문으로 문자를 하나씩 확인하여 HEAD, NUMBER 분리
• Comparator 인터페이스 사용

import java.util.*;

class Solution {
    class FileInfo {
        String head;
        int number;
        String original;
        int index;
        
        FileInfo(String original, int index) {
            this.original = original;
            this.index = index;
            parseFile(original);
        }
        
        private void parseFile(String fileName) {
            int i = 0;
            StringBuilder headBuilder = new StringBuilder();
            
            // HEAD
            while (i < fileName.length() && !Character.isDigit(fileName.charAt(i))) {
                headBuilder.append(fileName.charAt(i));
                i++;
            }
            this.head = headBuilder.toString().toLowerCase();
            
            // NUMBER
            StringBuilder numberBuilder = new StringBuilder();
            int count = 0;
            while (i < fileName.length() && Character.isDigit(fileName.charAt(i)) && count < 5) {
                numberBuilder.append(fileName.charAt(i));
                i++;
                count++;
            }
            this.number = Integer.parseInt(numberBuilder.toString());
        }
    }
    
    public String[] solution(String[] files) {
        List<FileInfo> fileList = new ArrayList<>();
        
        for (int i = 0; i < files.length; i++) {
            fileList.add(new FileInfo(files[i], i));
        }
        
        // Comparator
        fileList.sort(new Comparator<FileInfo>() {
            @Override
            public int compare(FileInfo f1, FileInfo f2) {
                // HEAD 비교
                int headCompare = f1.head.compareTo(f2.head);
                if (headCompare != 0) {
                    return headCompare;
                }
                
                // HEAD가 같으면 NUMBER 비교
                int numberCompare = Integer.compare(f1.number, f2.number);
                if (numberCompare != 0) {
                    return numberCompare;
                }
                
                return Integer.compare(f1.index, f2.index);
            }
        });
        
        return fileList.stream()
                      .map(f -> f.original)
                      .toArray(String[]::new);
    }
}