[프로그래머스] 브라이언의 고민

- 틀린 답

- 틀린 답입니다.

- 틀린 이유 : 규칙에 넣는 특수 문자 패턴을 기준으로 생각하면 예외를 깔끔하게 나눌 수 있었을 텐데 문구 전체로 생각해서 중간에 나오는 예외들이 너무 많아졌다. 

- 현재 코드에서 안되는 반례 : ( "XcXbXcX" -> "X XX X")

 

 

import java.util.*;
class Solution {
    
    private boolean isLowerCase(char c) {
        return c-'a' >= 0 && c-'z' <= 0;
    }
    private boolean isUpperCase(char c) {
        return c-'A' >= 0 && c-'Z' <=0;
    }
    
    private boolean isNoSpace(String str) {
        for(int i=0; i<str.length(); i++) {
            char c = str.charAt(i);
            if(c == ' ') {
                return false;
            }
        }
        return true;
    }
    
    private boolean isAllUpperCase(String str) {
        for(int i=0; i<str.length(); i++) {
            char c = str.charAt(i);
            if(isLowerCase(c)) {
                return false;
            }
        }
        return true;
    }
    
    private String getOnlyUpperCase(String str) {
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<str.length(); i++) {
            char c = str.charAt(i);
            if(isUpperCase(c)) {
                sb.append(c);
            }
        }
        return sb.toString();
    }
    
    public String solution(String sentence) {
        String answer = "";
        boolean isValid = true;
        if(!isNoSpace(sentence)) {
            return "invalid";
        }
        if(isAllUpperCase(sentence)) {
            return sentence;
        }
        int cIndex = 0;
        int eIndex = 0;
        char sChar;
        while(cIndex < sentence.length()-1) {
            sChar = sentence.charAt(cIndex);
            if(cIndex > 0) 
                answer += " ";
            // System.out.println("cIndex : " + cIndex);
            // System.out.println("sChar : " + sChar);
            if(isLowerCase(sChar)) {
                // 소문자 시작 -> rule 2 check
                // findIdx 다음 같은 소문자 전까지
                // idx 2에서 찾았을 경우 4에도 있으면 오류 : 같은 소문자 2개 들어간 경우
                eIndex = findRule2Idx(sentence, sChar, cIndex);
                if(eIndex == -1) {
                    return "invalid";
                }
                // rule 2의 경우 내부에 rule 1 이 존재할 수 있음.
                // rule 1 체크 한번 더 해 줘야 함.
                // 룰 2가 두번 들어갈 수는 없다.
                String subPart = sentence.substring(cIndex+1, eIndex);
                if(isLowerCase(sentence.charAt(cIndex+1))) {
                    return "invalid";
                }
                if(findRule1Idx(subPart, subPart.charAt(1), 0) == -1) {
                    return "invalid";
                }
                answer += getOnlyUpperCase(sentence.substring(cIndex, eIndex+1));
                cIndex = eIndex+1;
            } else {
                // 대문자 시작 -> rule 1 check
                // findIdx 다음 다른 소문자를 찾으면 마지막 현재 소문자의 위치 = eIndex
                // 대문자로 시작하면 끝도 대문자로 끝나야함.
                sChar = sentence.charAt(cIndex+1);
                eIndex = findRule1Idx(sentence, sChar, cIndex);
                if(eIndex == -1) {
                    return "invalid";
                }
                answer += getOnlyUpperCase(sentence.substring(cIndex, eIndex+1));
                cIndex = eIndex+1;
            }
        }
        return answer;
    }
    
    private int findRule2Idx(String str, char sChar, int cIndex) {
        int count = 0;
        int idx = -1;
        int len = str.length();
        for(int i=cIndex+1;i<len; i++) {
            char c = str.charAt(i);
            if(sChar == c) {
                idx = i;
                count++;
            }
        }
        return count > 1 ? -1 : idx; // 있어서는 안 됨
    }
    
    private int findRule1Idx(String str, char sChar, int cIndex) {
        int idx = -1;
        int len = str.length();
        for(int i=cIndex+1;i<len; i++) {
            char c = str.charAt(i);
            if(sChar == c) {
                idx = i;
            }
            if(isLowerCase(c) && sChar != c) {
                return idx+1;
            }
        }
        if(idx+1 >= len || isLowerCase(str.charAt(idx+1))) return -1;
        return idx != -1 ? ++idx : idx;
    }
}