[프로그래머스/Kotlin]Lv1 - 숫자 문자열과 영단어

프로그래머스

 

---

문제

문제 설명

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.

다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.

• 1478 → "one4seveneight"
• 234567 → "23four5six7"
• 10203 → "1zerotwozero3"

이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.

참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다.

숫자 영단어

0	zero
1	one
2	two
3	three
4	four
5	five
6	six
7	seven
8	eight
9	nine

 

제한사항

• 1 ≤ s의 길이 ≤ 50
• s가 "zero" 또는 "0"으로 시작하는 경우는 주어지지 않습니다.
• return 값이 1 이상 2,000,000,000 이하의 정수가 되는 올바른 입력만 s로 주어집니다.

입출력 예

s	result
"one4seveneight"	1478
"23four5six7"	234567
"2three45sixseven"	234567
"123"	123

 

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다.

입출력 예 #2

• 문제 예시와 같습니다.

입출력 예 #3

• "three"는 3, "six"는 6, "seven"은 7에 대응되기 때문에 정답은 입출력 예 #2와 같은 234567이 됩니다.
• 입출력 예 #2와 #3과 같이 같은 정답을 가리키는 문자열이 여러 가지가 나올 수 있습니다.

입출력 예 #4

• s에는 영단어로 바뀐 부분이 없습니다.

제한시간 안내

• 정확성 테스트 : 10초
•  

---

풀이

풀이 접근 과정

원래는 for문을 돌면서 하나하나 처리하려다가.

생각해보니까 앞에서부터 진행할 필요 없이 그냥 replace 돌려버리면 되잖아?!

확인해보니 제한사항도 s의 길이가 50 밖에 안됐다.

이건 분명 시간초과 안된다.

최종 소스코드

class Solution {
    fun solution(s: String) = 
        s.replace("zero", "0")
        .replace("one", "1")
        .replace("two", "2")
        .replace("three", "3")
        .replace("four", "4")
        .replace("five", "5")
        .replace("six", "6")
        .replace("seven", "7")
        .replace("eight", "8")
        .replace("nine", "9")
        .toInt()
}

싹 다 replace

class Solution {
    fun solution(s: String): Int {
        val answer = StringBuffer()
        var index = 0

        while(index < s.length) {
            when (s[index]) {
                'z' -> { // zero
                    answer.append(0)
                    index += 4
                }
                'o' -> { // one
                    answer.append(1)
                    index += 3
                }
                't' -> { // two, three
                    when (s[index+1]) {
                        'w' -> {
                            answer.append(2)
                            index += 3
                        }
                        'h' -> {
                            answer.append(3)
                            index += 5
                        }
                    }
                }
                'f' -> { // four, five
                    when (s[index+1]) {
                        'o' -> {
                            answer.append(4)
                            index += 4
                        }
                        'i' -> {
                            answer.append(5)
                            index += 4
                        }
                    }
                }
                's' -> { // six, seven
                    when (s[index+1]) {
                        'i' -> {
                            answer.append(6)
                            index += 3
                        }
                        'e' -> {
                            answer.append(7)
                            index += 5
                        }
                    }
                }
                'e' -> { // eight
                    answer.append(8)
                    index += 5
                }
                'n' -> { // nine
                    answer.append(9)
                    index += 4
                }
                else -> {
                    answer.append(s[index])
                    index++
                }
            }
        }

        return answer.toString().toInt()
    }
}

replace 방법으로는 시간복잡도가 아쉬워서 맨 처음 접근으로 다시 풀었다.

확실히 두 풀이의 시간 복잡도는 엄청 차이난다.

replace로는 9번의 반복을 도는데 비해, 위 코드는 한번의 반복문만 돌면 되기 때문이다.

---

Comment

간결한 코드를 포기하고 효율성 측면으로 바라봤다.

속이 다 후련하다.