[프로그래머스/자바] 크기가 작은 부분 문자열 - 자료형 개념

문제 설명

숫자로 이루어진 문자열 t와 p가 주어질 때, t에서 p와 길이가 같은 부분문자열 중에서, 이 부분문자열이 나타내는 수가 p가 나타내는 수보다 작거나 같은 것이 나오는 횟수를 return하는 함수 solution을 완성하세요.

예를 들어, t="3141592"이고 p="271" 인 경우, t의 길이가 3인 부분 문자열은 314, 141, 415, 159, 592입니다. 이 문자열이 나타내는 수 중 271보다 작거나 같은 수는 141, 159 2개 입니다.

 

제한사항

• 1 ≤ p의 길이 ≤ 18
• p의 길이 ≤ t의 길이 ≤ 10,000
• t와 p는 숫자로만 이루어진 문자열이며, 0으로 시작하지 않습니다.

 

입출력 예

t	p	result
"3141592"	"271"	2
"500220839878"	"7"	8
"10203"	"15"	3

입출력 예 설명

입출력 예 #1
본문과 같습니다.

입출력 예 #2
p의 길이가 1이므로 t의 부분문자열은 "5", "0", 0", "2", "2", "0", "8", "3", "9", "8", "7", "8"이며 이중 7보다 작거나 같은 숫자는 "5", "0", "0", "2", "2", "0", "3", "7" 이렇게 8개가 있습니다.

입출력 예 #3
p의 길이가 2이므로 t의 부분문자열은 "10", "02", "20", "03"이며, 이중 15보다 작거나 같은 숫자는 "10", "02", "03" 이렇게 3개입니다. "02"와 "03"은 각각 2, 3에 해당한다는 점에 주의하세요.

 

문제 풀이 방법

1. 입력 받는 값을 ArrayList에 받아주기 위해 add 메서드를 사용한다

2. 숫자 비교를 하기 위해 형변환을 해준다. 

-> 최근 풀었던 문제에서 String 연산보다 형변환을 하고 숫자끼리 연산하는 게 더 효율적임을 알게 되었기 때문

 

<int 형변환 풀이>

import java.util.*;
class Solution {
    public int solution(String t, String p) {
        int answer = 0;
        int tLength = t.length();
        int pLength = p.length();
        List<String> chunk = new ArrayList<>();
        
        for (int i=0; i<tLength-pLength+1; i++){
            chunk.add(t.substring(i,i+pLength));
        }  
           
       
        for (String chunks : chunk){
            int iChunks = Integer.parseInt(chunks);
            int iP = Integer.parseInt(p);
            
            
            if (iChunks <= iP){
                answer++;
            }
        }
        
        return answer;
    }
}
 

테스트 1 〉	통과 (3.74ms, 74.6MB)
테스트 2 〉	통과 (8.94ms, 73.9MB)
테스트 3 〉	통과 (5.31ms, 75.1MB)
테스트 4 〉	통과 (5.99ms, 67.2MB)
테스트 5 〉	통과 (5.21ms, 74.6MB)
테스트 6 〉	통과 (5.04ms, 78.5MB)
테스트 7 〉	통과 (9.08ms, 75.7MB)
테스트 8 〉	통과 (3.58ms, 74.3MB)
테스트 9 〉	통과 (3.22ms, 76.7MB)
테스트 10 〉	통과 (0.88ms, 74.5MB)
테스트 11 〉	통과 (5.35ms, 77.5MB)
테스트 12 〉	통과 (8.25ms, 73.7MB)
테스트 13 〉	통과 (8.03ms, 77.2MB)
테스트 14 〉	통과 (4.81ms, 73.9MB)
테스트 15 〉	통과 (5.55ms, 76.8MB)
테스트 16 〉	통과 (4.54ms, 75.9MB)
테스트 17 〉	통과 (9.89ms, 78.1MB)
테스트 18 〉	통과 (5.49ms, 78.2MB)
테스트 19 〉	통과 (3.14ms, 72.6MB)
테스트 20 〉	통과 (2.42ms, 70.1MB)
테스트 21 〉	통과 (0.17ms, 77.3MB)
테스트 22 〉	통과 (1.86ms, 76.2MB)
테스트 23 〉	통과 (3.16ms, 82MB)
테스트 24 〉	통과 (0.33ms, 73.4MB)
테스트 25 〉	통과 (1.08ms, 76.1MB)
테스트 26 〉	통과 (0.47ms, 70.3MB)
테스트 27 〉	통과 (0.33ms, 67.4MB)
테스트 28 〉	통과 (0.39ms, 76.6MB)
테스트 29 〉	통과 (0.39ms, 76.7MB)
테스트 30 〉	통과 (2.80ms, 65.8MB)
테스트 31 〉	통과 (0.11ms, 76.4MB)
테스트 32 〉	통과 (0.12ms, 76.5MB)
테스트 33 〉	통과 (0.19ms, 84.1MB)
테스트 34 〉	통과 (0.20ms, 72.1MB)
테스트 35 〉	통과 (0.19ms, 73.5MB)
테스트 36 〉	통과 (0.36ms, 76.5MB)
테스트 37 〉	통과 (0.14ms, 72.1MB)
테스트 38 〉	통과 (0.29ms, 75.6MB)

 

< 문자열 비교 풀이 >

import java.util.*;
 
class Solution {
    public int solution(String t, String p) {
        int answer = 0;
        int tLength = t.length();
        int pLength = p.length();
        List<String> chunk = new ArrayList<>();
 
        for (int i = 0; i <= tLength - pLength; i++) {
            chunk.add(t.substring(i, i + pLength));
        }
        
          for (String chunks : chunk) {
            if (chunks.compareTo(p) <= 0) {
                answer++;
            }
        }
        
        return answer;
    }
}
 

 

테스트 1 〉	통과 (1.20ms, 71.8MB)
테스트 2 〉	통과 (2.35ms, 73.8MB)
테스트 3 〉	통과 (2.63ms, 77.3MB)
테스트 4 〉	통과 (1.70ms, 71.6MB)
테스트 5 〉	통과 (1.15ms, 73.6MB)
테스트 6 〉	통과 (2.53ms, 77.5MB)
테스트 7 〉	통과 (2.97ms, 78MB)
테스트 8 〉	통과 (1.99ms, 77.7MB)
테스트 9 〉	통과 (1.36ms, 81.5MB)
테스트 10 〉	통과 (0.56ms, 75.9MB)
테스트 11 〉	통과 (3.02ms, 80.8MB)
테스트 12 〉	통과 (9.91ms, 73.4MB)
테스트 13 〉	통과 (2.24ms, 76.8MB)
테스트 14 〉	통과 (2.42ms, 77.1MB)
테스트 15 〉	통과 (1.67ms, 74.8MB)
테스트 16 〉	통과 (1.48ms, 71.4MB)
테스트 17 〉	통과 (1.99ms, 75.6MB)
테스트 18 〉	통과 (2.28ms, 71.4MB)
테스트 19 〉	통과 (1.69ms, 72.4MB)
테스트 20 〉	통과 (1.29ms, 76.8MB)
테스트 21 〉	통과 (0.08ms, 78.9MB)
테스트 22 〉	통과 (0.40ms, 78.1MB)
테스트 23 〉	통과 (0.97ms, 71.8MB)
테스트 24 〉	통과 (0.07ms, 76.7MB)
테스트 25 〉	통과 (0.10ms, 66MB)
테스트 26 〉	통과 (0.08ms, 71.7MB)
테스트 27 〉	통과 (0.13ms, 77MB)
테스트 28 〉	통과 (0.06ms, 72.4MB)
테스트 29 〉	통과 (0.17ms, 75.1MB)
테스트 30 〉	통과 (0.81ms, 76.8MB)
테스트 31 〉	통과 (0.04ms, 72MB)
테스트 32 〉	통과 (0.07ms, 71.8MB)
테스트 33 〉	통과 (0.06ms, 82.9MB)
테스트 34 〉	통과 (0.10ms, 74.9MB)
테스트 35 〉	통과 (0.10ms, 74.6MB)
테스트 36 〉	통과 (0.06ms, 76.2MB)
테스트 37 〉	통과 (0.05ms, 76.6MB)
테스트 38 〉	통과 (0.09ms, 74.4MB)

 

campareTo 함수를 쓰는 게 훨 빠르다. 연산과 비교는 별개의 영역인 건가.. 리팩토링 시간에 연산과 비교에 대해서 자세히 알아보아야겠다.

 

 

 

>> 리팩토링 (06.16)

 

class Solution {
    public int solution(String t, String p) {
        int answer = 0;
        int tLength = t.length();
        int pLength = p.length();
        
        for (int i = 0; i <= tLength - pLength; i++) {
            String chunk = t.substring(i, i + pLength);
            long lChunk = Long.parseLong(chunk);
            long lP = Long.parseLong(p);
            
            if (lChunk <= lP) {
                answer++;
            }
        }
        
        return answer;
    }
}
 

1. chunk 리스트 대신에 단일 문자열 chunk을 사용하도록 변경하여 메모리 사용을 최적화했습니다.
2. chunk와 p를 문자열에서 바로 long 형으로 변환하도록 수정했습니다.
3. chunk와 p를 long 형으로 비교하여 조건을 확인하도록 변경했습니다.
4. 불필요한 ArrayList 객체를 제거하여 코드를 간결화했습니다.

메모리 사용량이 소폭 증가하긴 했지만, 코드의 가독성이 좋아졌습니다.