이진 변환 반복하기

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

프로그래머스

반성하기 위해 기록한다.

class Solution {
    public int[] solution(String s) {
        StringBuilder sb = new StringBuilder();
        sb.append(s);
        int zeroCount = 0;
        int totalCount = 0;
        int lengthAfterRemoveZero = 0;
        
        while(!sb.equals("1")) {
            String str = sb.toString();
            String[] strArr = str.split("");
            for(String e : strArr) {
                if(e.equals("0")) {
                    zeroCount++;
                }
            }
            String replacedString = str.replace("0","");
            lengthAfterRemoveZero = replacedString.length();
            sb.setLength(0);
            sb.append(Integer.toBinaryString(lengthAfterRemoveZero));
            totalCount++;
        }
        return new int[]{totalCount,zeroCount};
    }
}

돌아는 가는 코드다. 

그런데 실행 시간이 10초가 넘어서 실행이 안 된다.

지금 실행 시간이 넘는 문제가 연속 2번 발생했다.

이제 문풀 그만하고 공부를 다시 시작할 때라는 신호다.

내가 저렇게 짠 건 나름의 이유가 있어서였다.

그런데 GPT는

1. String.split("") 사용 제거: split 메소드를 사용하여 문자열을 문자 단위로 분리한 후, 각 문자를 검사하는 방법은 비효율적입니다. 대신, 문자열을 직접 순회하여 '0'의 개수를 세는 것이 더 효율적입니다.
2. String.replace("0","") 사용 최소화: '0'을 제거한 후의 문자열 길이를 직접 계산할 수 있습니다. 이는 '0'의 개수를 세는 동안 함께 처리할 수 있어, 불필요한 문자열 생성과 처리를 줄일 수 있습니다.
3. StringBuilder 재사용: StringBuilder의 setLength(0) 메소드를 사용하여 객체를 재사용할 수 있지만, 여기서는 변환 결과를 단순히 새로운 문자열로 대체하고 있어, 매번 새로운 문자열을 할당하는 것과 큰 차이가 없습니다. 직접 숫자를 이진 문자열로 변환하는 과정을 최적화할 필요가 있습니다.

이렇게 피드백한다.

코드를 보면 바로 납득이 된다.

class Solution {
    public int[] solution(String s) {
        int zeroCount = 0;
        int transformCount = 0;

        while (!s.equals("1")) {
            int length = s.length();
            s = s.replace("0", "");
            zeroCount += length - s.length(); // 제거된 0의 개수
            length = s.length(); // 0을 제거한 후의 길이
            s = Integer.toBinaryString(length); // 이진 변환
            transformCount++;
        }
        
        return new int[]{transformCount, zeroCount};
    }
}

하...

뭐 그렇다 치자.

그런데 스트링 객체 생성 매 번 되는 것보다 스트링 빌더 쓰는 게 더 효율이 좋을 것 같아서 그렇게 했다라고 하니

다음과 같은 코드를 보여 준다.

class Solution {
    public int[] solution(String s) {
        int zeroCount = 0;
        int transformCount = 0;

        while (!s.equals("1")) {
            StringBuilder sb = new StringBuilder(); // 새로운 StringBuilder 객체
            for (char c : s.toCharArray()) {
                if (c == '0') {
                    zeroCount++;
                } else {
                    sb.append(c); // '0'이 아닌 경우에만 문자 추가
                }
            }

            int length = sb.length(); // '0'이 제거된 후의 길이
            s = Integer.toBinaryString(length); // 이진 변환
            transformCount++;
        }

        return new int[]{transformCount, zeroCount};
    }
}

흐음...

 

내가 무지해서 이렇게 생각하는 것이겠으나 여전히 내 눈에는 세 코드가 그렇게 크리티컬하게 다른 점이 있나 싶다.

2024년의 '콤퓨타'가 저것도 처리를 못 한다고?

내 첫 코드는 망했다 치고 둘의 속도를 비교해 보자.

 

스트링만 쓴 건 이 정도.

스트링 빌더 쓴 건 이 정도.

처리할 문자열이 길수록 스트링 빌더 도입이 빛을 발하는 거 같다.

 

레벨2로 오니까 또 생각이 많아지네...