알고리즘 - 프로그래머스 2018 카카오 블라인드 다트 게임 [Swift]

알고리즘 - 프로그래머스 2018 카카오 블라인드 다트 게임 [Swift]

2020. 7. 8. 17:15ㆍAlgorism

다트 게임

카카오톡에 뜬 네 번째 별! 심심할 땐? 카카오톡 게임별~

카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다. 다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.
갓 입사한 무지는 코딩 실력을 인정받아 게임의 핵심 부분인 점수 계산 로직을 맡게 되었다. 다트 게임의 점수 계산 로직은 아래와 같다.

다트 게임은 총 3번의 기회로 구성된다.
각 기회마다 얻을 수 있는 점수는 0점에서 10점까지이다.
점수와 함께 Single(S), Double(D), Triple(T) 영역이 존재하고 각 영역 당첨 시 점수에서 1제곱, 2제곱, 3제곱 (점수1 , 점수2 , 점수3 )으로 계산된다.
옵션으로 스타상(*) , 아차상(#)이 존재하며 스타상(*) 당첨 시 해당 점수와 바로 전에 얻은 점수를 각 2배로 만든다. 아차상(#) 당첨 시 해당 점수는 마이너스된다.
스타상(*)은 첫 번째 기회에서도 나올 수 있다. 이 경우 첫 번째 스타상(*)의 점수만 2배가 된다. (예제 4번 참고)
스타상(*)의 효과는 다른 스타상(*)의 효과와 중첩될 수 있다. 이 경우 중첩된 스타상(*) 점수는 4배가 된다. (예제 4번 참고)
스타상(*)의 효과는 아차상(#)의 효과와 중첩될 수 있다. 이 경우 중첩된 아차상(#)의 점수는 -2배가 된다. (예제 5번 참고)
Single(S), Double(D), Triple(T)은 점수마다 하나씩 존재한다.
스타상(*), 아차상(#)은 점수마다 둘 중 하나만 존재할 수 있으며, 존재하지 않을 수도 있다.

0~10의 정수와 문자 S, D, T, *, #로 구성된 문자열이 입력될 시 총점수를 반환하는 함수를 작성하라.

입력 형식

점수|보너스|[옵션]으로 이루어진 문자열 3세트.
예) 1S2D*3T

점수는 0에서 10 사이의 정수이다.
보너스는 S, D, T 중 하나이다.
옵선은 *이나 # 중 하나이며, 없을 수도 있다.

출력 형식

3번의 기회에서 얻은 점수 합계에 해당하는 정수값을 출력한다.
예) 37

네 문제를 푸는 방법은 문자열에 대한 처리를 할 수 있다면 가능한 문제 인 것으로 보이네요!!

문제의 요점은 아래와 같아요. (이제는 문제 읽는 것을 꼼곰히 하고 있어요.. 하하 읽다보니 잘 읽어 지네요..)

점수  : 0 ~ 10
보너스 : S(1제곱), D(2제곱), T(3제곱)
       - 점수별 1개식 존재
이벤트 :
-> * (스타상) : 해당 점수, 이전 점수 *2
       1번 회차에 나올경우 해당 회차 점수만 *2
       중첩시 *4 효과
-> # (아차상) : 해당 점수 마이너스 (-)

*, # 점수별 둘중 하나만 존재 or 없을 수도 있다.

문제 푸는 핵심은 문자열을 어떻게 처리 할것인가에 대해서인데. 아래와 같이 3개가 있네요.

먼저 문자열 한개식 처리를 진행해 보고 split함수로 처리를 진행해볼게요. 정규식과 split함수는 사용법이 비슷하니 따로 다루지 않을게요.

1. char로 1개식 문자열을 처리

2. 숫자 & 문자를 분리하여 처리

- split 함수로 처리

- 정규식으로 처리

# char로 1개식 문자열을 처리

func solution(_ dartResult:String) -> Int {
    
    var scoresArray = [Int]()
    var score = 0
    var isCalculation = false
    dartResult.forEach { char in
        
        let scroeNumber = scoresArray.count - 1
        
        switch char {
        case "S":
            scoresArray.append(score*1)
            isCalculation = true
            return
        case "D":
            scoresArray.append(score*score)
            isCalculation = true
            return
        case "T":
            scoresArray.append(score*score*score)
            isCalculation = true
            return
        case "*":
            if scroeNumber > 0  {
                scoresArray[scroeNumber - 1] = scoresArray[scroeNumber - 1] * 2
            }
            scoresArray[scroeNumber] = scoresArray[scroeNumber] * 2
            isCalculation = true
            return
        case "#":
            scoresArray[scroeNumber] = scoresArray[scroeNumber] * -1
            isCalculation = true
            return
        default:
            if isCalculation == false {
                score = Int(String(score) + String(char))!
            } else {
                score = Int(String(char))!
            }
            
            isCalculation = false
            return
        }
    }
    
    return scoresArray.reduce(0, +)
}

소스를 보시면 아시겠지만 정말 간단하게 풀었습니다. (... 쉽게 좋게 풀었다는 이야기는 아닙니다.)

각 문자열을 쪼개서 루프를 돌며 연산에서는 연산을 진행하여 배열에 넣어주고

1개의 문자식 처리를 진행하다보니 10의 숫자가 들어오는 내용은 확인을 못하니 isCalculation의 변수를 두어 처리를 진행하였습니다.

# Split 함수를 이용한 숫자 & 문자를 분리하여 처리

func solutionA(_ dartResult:String) -> Int {
    var scoresArray = [Int]()
    
    let numberArray = dartResult.split(whereSeparator: { $0.isLetter || $0 == "#" || $0 == "*" }).map { Int($0)! }
    let calArray = dartResult.split(whereSeparator: { $0.isNumber })

    let zipArray = Array(zip(numberArray, calArray))
    
    
    zipArray.enumerated().forEach { index, zip in
        let cal = zip.1.map { String($0) }
    
        scoresArray.append(cal[0].contains("T") ? zip.0 * zip.0 * zip.0 : cal[0].contains("D") ? zip.0 * zip.0 : zip.0)
        
        
        guard cal.count >= 2 else { return }
        
        scoresArray[index] = cal[1].contains("*") ? scoresArray[index] * 2 : scoresArray[index] * -1
        
        if cal[1].contains("*") && index >= 1 {
            scoresArray[index - 1] = scoresArray[index - 1] * 2
        }
    }
    
    return scoresArray.reduce(0, +)
}

네 그냥 봐도 복잡하조.. zipArray for문 부터는 개인간의 차이가 있을 수 있어요.

저는 이왕 함수를 사용하는거 최대한 많이 사용해서 만들어봤어요.. 하하..

zipArray에는 숫자 배열과, 문자배열 (D,T,S,#,*)이 들어가 있습니다.

그래서 zip함수를 사용하여 묶어준뒤 for문을 사용하여 내부 계산을 진행하였습니다.

어떤 코드가 정답이고 어떻게 짜야 효율적으로 짜는지 조금 더 고민이 필요할 것 같아요.

일단 그래서 성능비교를 해보니 아래 로직이 2배가량 속도가 더 걸리더라구요.

그래서 아래 코드에서 zipArray를 생성하지 않고 단순 포문으로 풀어도 맨위의 코드보다

1.5배가량 더걸리기 때문에 신중하게 생각해서 푸는게 좋을것 같습니다.

# char로 1개식 문자열을 처리 실행 속도

테스트 1 〉	통과 (0.18ms, 23.9MB)
테스트 2 〉	통과 (0.20ms, 24MB)
테스트 3 〉	통과 (0.19ms, 24.3MB)
테스트 4 〉	통과 (0.21ms, 24.2MB)
테스트 5 〉	통과 (0.19ms, 23.8MB)
테스트 6 〉	통과 (0.20ms, 23.5MB)
테스트 7 〉	통과 (0.19ms, 23.9MB)
테스트 8 〉	통과 (0.19ms, 24.1MB)
테스트 9 〉	통과 (0.19ms, 24MB)
테스트 10 〉	통과 (0.22ms, 23.8MB)
테스트 11 〉	통과 (0.21ms, 24MB)
테스트 12 〉	통과 (0.20ms, 24.2MB)
테스트 13 〉	통과 (0.19ms, 24.1MB)
테스트 14 〉	통과 (0.19ms, 24MB)
테스트 15 〉	통과 (0.19ms, 24.1MB)
테스트 16 〉	통과 (0.19ms, 24.2MB)
테스트 17 〉	통과 (0.20ms, 24.1MB)
테스트 18 〉	통과 (0.19ms, 23.7MB)
테스트 19 〉	통과 (0.19ms, 23.9MB)
테스트 20 〉	통과 (0.18ms, 24.3MB)
테스트 21 〉	통과 (0.18ms, 23.8MB)
테스트 22 〉	통과 (0.19ms, 23.5MB)
테스트 23 〉	통과 (0.20ms, 24MB)
테스트 24 〉	통과 (0.20ms, 23.9MB)
테스트 25 〉	통과 (0.20ms, 24MB)
테스트 26 〉	통과 (0.18ms, 23.9MB)
테스트 27 〉	통과 (0.18ms, 24.4MB)
테스트 28 〉	통과 (0.18ms, 23.8MB)
테스트 29 〉	통과 (0.19ms, 24.2MB)
테스트 30 〉	통과 (0.19ms, 24.1MB)
테스트 31 〉	통과 (0.18ms, 24.1MB)
테스트 32 〉	통과 (0.19ms, 24.2MB)

# Split 함수만을 사용한 실행 속도

테스트 1 〉	통과 (0.30ms, 24.2MB)
테스트 2 〉	통과 (0.32ms, 24.4MB)
테스트 3 〉	통과 (0.31ms, 23.8MB)
테스트 4 〉	통과 (0.31ms, 24.3MB)
테스트 5 〉	통과 (0.32ms, 24.5MB)
테스트 6 〉	통과 (0.30ms, 24.4MB)
테스트 7 〉	통과 (0.30ms, 24.2MB)
테스트 8 〉	통과 (0.30ms, 24MB)
테스트 9 〉	통과 (0.30ms, 24.4MB)
테스트 10 〉	통과 (0.30ms, 24.3MB)
테스트 11 〉	통과 (0.30ms, 24.5MB)
테스트 12 〉	통과 (0.33ms, 24.4MB)
테스트 13 〉	통과 (0.30ms, 24.3MB)
테스트 14 〉	통과 (0.29ms, 23.8MB)
테스트 15 〉	통과 (0.34ms, 24.5MB)
테스트 16 〉	통과 (0.32ms, 24.3MB)
테스트 17 〉	통과 (0.28ms, 24.4MB)
테스트 18 〉	통과 (0.30ms, 24.3MB)
테스트 19 〉	통과 (0.30ms, 24.6MB)
테스트 20 〉	통과 (0.31ms, 24.4MB)
테스트 21 〉	통과 (0.31ms, 24.3MB)
테스트 22 〉	통과 (0.32ms, 24.3MB)
테스트 23 〉	통과 (0.31ms, 24.2MB)
테스트 24 〉	통과 (0.32ms, 24.2MB)
테스트 25 〉	통과 (0.30ms, 24.5MB)
테스트 26 〉	통과 (0.30ms, 24.4MB)
테스트 27 〉	통과 (0.30ms, 24.4MB)
테스트 28 〉	통과 (0.31ms, 23.9MB)
테스트 29 〉	통과 (0.31ms, 24MB)
테스트 30 〉	통과 (0.31ms, 24.4MB)
테스트 31 〉	통과 (0.28ms, 24.4MB)
테스트 32 〉	통과 (0.32ms, 24.2MB)

# Split 함수만 + zip + forEach 함수를 사용한 실행 속도

테스트 1 〉	통과 (0.41ms, 24.3MB)
테스트 2 〉	통과 (0.41ms, 24.1MB)
테스트 3 〉	통과 (0.40ms, 24.3MB)
테스트 4 〉	통과 (0.42ms, 24.2MB)
테스트 5 〉	통과 (0.42ms, 24.1MB)
테스트 6 〉	통과 (0.40ms, 24.5MB)
테스트 7 〉	통과 (0.40ms, 24.5MB)
테스트 8 〉	통과 (0.39ms, 24.1MB)
테스트 9 〉	통과 (0.40ms, 24.4MB)
테스트 10 〉	통과 (0.42ms, 24.4MB)
테스트 11 〉	통과 (0.42ms, 24.2MB)
테스트 12 〉	통과 (0.41ms, 24.1MB)
테스트 13 〉	통과 (0.39ms, 24.4MB)
테스트 14 〉	통과 (0.41ms, 24.5MB)
테스트 15 〉	통과 (0.40ms, 24.4MB)
테스트 16 〉	통과 (0.43ms, 24.4MB)
테스트 17 〉	통과 (0.48ms, 24.2MB)
테스트 18 〉	통과 (0.39ms, 24.6MB)
테스트 19 〉	통과 (0.43ms, 24.4MB)
테스트 20 〉	통과 (0.43ms, 24.3MB)
테스트 21 〉	통과 (0.37ms, 24.5MB)
테스트 22 〉	통과 (0.40ms, 24.6MB)
테스트 23 〉	통과 (0.41ms, 24.3MB)
테스트 24 〉	통과 (0.44ms, 24.6MB)
테스트 25 〉	통과 (0.40ms, 24.3MB)
테스트 26 〉	통과 (0.40ms, 24.5MB)
테스트 27 〉	통과 (0.42ms, 24.2MB)
테스트 28 〉	통과 (0.39ms, 24.2MB)
테스트 29 〉	통과 (0.41ms, 24.4MB)
테스트 30 〉	통과 (0.41ms, 24MB)
테스트 31 〉	통과 (0.44ms, 24.2MB)
테스트 32 〉	통과 (0.40ms, 24.4MB)

'Algorism' 카테고리의 다른 글

알고리즘 - 프로그래머스 멀쩡한 사각형 (Swift) (0)	2020.07.10
알고리즘 - 프로그래머스 쇠막대기 (Swift) (0)	2020.07.10
알고리즘 - 프로그래머스 2018 KAKAO BLIND RECRUITMENT[1차] 비밀지도 (Swift) (0)	2020.07.06
알고리즘 - 프로그래머스 행렬의 덧셈 (Swift) (0)	2020.07.06
알고리즘 - 프로그래머스 콜라츠 추측 (Swift) (0)	2020.07.03

CodingLearn

CodingLearn

태그

최근글

댓글

공지사항

아카이브

다트 게임

입력 형식

출력 형식

'Algorism' 카테고리의 다른 글

관련글

티스토리툴바