5-alstjr7437

[alstjr7437]

🔗 문제 링크

퍼즐게임 챌린지

✔️ 소요된 시간

30분

주의할 부분!

testCase를 친절히 주지 않으면 생각안하고 풀다가 광탈할뻔 했습니다.

처음에 그냥 퍼즐 게임 결과만 순서대로 쭉 돌리면 되겠군!
이렇게 생각을 했는데 testCase를 친절히(이거 안줬으면 바로 코테 광탈할뻔) 주길래 다행이였습니다...

diffs	times	limit	result
[1, 99999, 100000, 99995]	[9999, 9001, 9999, 9001]	3456789012	39354

위와 같이 예제가 주어지면 어 이거 완탐 돌리면 무조건 시간 초과인걸 알겠더라구요
thanks to Programmers

✨ 수도 코드

그렇게 해서 이번 문제에서 크게 생각할 부분은 두가지입니다!

1. 퍼즐 게임 결과값 얻어오기!
2. 숙련도의 최솟값을 가져오기

---

퍼즐 게임은 사실 로직을 한번 보고 이해가 안갔는데 예제를 보니까 이해를 했습니다.

1. 내가 풀 문제
   • total += 현재 문제 걸리는 시간
2. 내가 못풀 문제
   1. 몇번 틀리는지 구하기
   2. 이전 문제 푸는 시간 + 지금 문제 푸는 시간 계산
   3. 2번에서 구했던 시간 * 틀린 횟수 + 현재 문제 걸리는 시간
   4. total += 3번 시간

으로 puzzle이 돌아갔습니다!
(이해가 안가면 코드를 보면 편하실거에요!)

그러고 나머지 이분 탐색은 매번 진행했던 이분 탐색입니다!

결과 값이 limit보다 크면? -> start를 높임
결과 값이 limit보다 작거나 같으면? -> end를 낮춤
(하지만 결과 값 저장을 위해 answer에 저장해둠 -> 이후 부분이 limit보다 크면 이 answer을 사용하기 위해)

정답 코드

import Foundation

func puzzle(diffs: [Int], times: [Int], level: Int) -> Int{
    var result = 0
    for i in 0..<diffs.count {
        if diffs[i] <= level {
            result += times[i]
        } else {
            let discorrectCount = diffs[i] - level
            let discorrectUseTime = times[i - 1] + times[i]
            let totalUseTime = discorrectUseTime * discorrectCount + times[i]
            result += totalUseTime
        }
    }
    
    return result
}


func solution(_ diffs:[Int], _ times:[Int], _ limit:Int64) -> Int {
    var start = 1
    var end = diffs.max() ?? 100000
    var mid = 0
    var answer = 0
    
    while start <= end {
        mid =  (start + end) / 2
        let result = puzzle(diffs: diffs, times: times, level: mid)
        
        if result <= limit {
            answer = mid  
            end = mid - 1     
        } else {
            start = mid + 1     
        }
    }
    
    return answer
}

📚 새롭게 알게된 내용

프로그래머스에서는 먼가 언어에 대한 이해가 많지 않으면 참 힘든 것 같아요
오래만에 max를 썻다고 바로 max(diffs)를 쓰고 왜 안되지 하고 있었습니다 ㅎ..

[giljihun]

이번 문제는 코멘트에서 많은 얘기를 한거같네요 !!

제가 생각하는 문제의 핵심은 "레벨은 무조건 diff의 범위 안에 있음" 을 생각해내고,
이분탐색을 들어가는거였다고 생각이 드네요!

/*
 현재 퍼즐 난이도 - diff
 현재 퍼즐 소요시간 - time_cur
 이전 퍼즐 소요시간 - time_prev
 숙련도 - level
 
 - diff <= level : 퍼즐 틀리지 않고, time_curr만큼 시간 사용
 - diff > level : (diff - level)번 퍼즐을 틀림,
    이 경우, ((diff - level) * time_curr)만큼 시간 사용하고
    time_prev만큼의 시간을 사용해서 이전 퍼즐을 다시 풀고 와야함. (이 경우 무조건 틀리지 않음.)
 - 위 과정 이후, 무조건 time_cur만큼 시간을 사용해서 해결함.
 
 ==> ((time_cur + time_prev) * (diff - level)) + time_cur
 
 전체 제한 시간 limit.
 어떤 level이 퍼즐을 모두 해결하는 최소 레벨일까?
 
 1. 레벨은 무조건 diff의 범위 안에 있음. (왜냐하면 max난이도보다 크면 다 ok임.)
 2. 해당 범위 안에서의 최소값을 찾아야함.
 */


import Foundation

func solution(_ diffs:[Int], _ times:[Int], _ limit:Int64) -> Int {
    
    // ==> ((time_cur + time_prev) * (diff - level)) + time_cur
    func isPossible(level: Int) -> Bool {
        
        var totalTime: Int64 = 0

        for i in 0..<diffs.count {
            let diff = diffs[i]
            let timeCur = times[i]
            let timePrev: Int
            
            // 첫 퍼즐은 이전 퍼즐이 없잖여 -> 0
            if i == 0 {
                timePrev = 0
            } else {
                timePrev = times[i - 1]
            }

            if diff <= level {
                totalTime += Int64(timeCur)
            } else {
                let failCount = diff - level
                totalTime += Int64((timeCur + timePrev) * failCount + timeCur)
            }

            if totalTime > limit {
                return false
            }
        }
        return true
    }
    
    var left = 1
    
    // 이 경우 옵셔널 강제 언래핑을 하면 안되는 경우가 뭐지?
    // var right = diffs.max()!
    // 일단 가드문 처리
    guard let maxDiff = diffs.max() else { exit(0) }
    
    var right = maxDiff
    var answer = right

    while left <= right {
        let mid = (left + right) / 2
        if isPossible(level: mid) {
            answer = mid
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    return answer
}

[giljihun]

솔루션부터 읽어서 이해가 되긴합니다!
그래도 puzzle이라는 함수명은 조금 가독성을 낮춘 것 같습니다!

음.. calTotalTime() 이런건 어떨까요~?

[alstjr7437]

사실 함수가 단일 책임 원칙을 맞추기 위해서 작성했는데
생각해보니 puzzle게임을 하는 저는 이해를 하지만 다른 사람들은 이해를 못하겠네요!

그렇게 되면 주석을 추가하는게 뭔가 더 가독성이 좋을 것 같아요!

calTotalTime을 해도 뭔가 모르는 사람이 보면 무슨 총 시간을 구하는거지? 라는 생각이 들어서

puzzle게임인데 설명을 추가하는 방식이 단일 책임 원칙 + 가독성을 지키는 것 같네요!

[giljihun]

값을 넘기고 solution()에서 result <= limit 검사 방식으로 구현하셨군요!
저는 가능성 여부를 함수에서 판단하고 넘기는 방식으로 구현했어요!

// ==> ((time_cur + time_prev) * (diff - level)) + time_cur
    func isPossible(level: Int) -> Bool {
        
        var totalTime: Int64 = 0

        for i in 0..<diffs.count {
            let diff = diffs[i]
            let timeCur = times[i]
            let timePrev: Int
            
            // 첫 퍼즐은 이전 퍼즐이 없잖여 -> 0
            if i == 0 {
                timePrev = 0
            } else {
                timePrev = times[i - 1]
            }

            if diff <= level {
                totalTime += Int64(timeCur)
            } else {
                let failCount = diff - level
                totalTime += Int64((timeCur + timePrev) * failCount + timeCur)
            }

            if totalTime > limit {
                return false
            }
        }
        return true
    }

[alstjr7437]

사실 코테 문제 풀때라 상관 없긴한데
게임 한판 결과 + 통과 가능하냐 vs 게임 한판 결과
이렇게 함수를 어떻게 자르는지에 따라 함수의 사용성이 달라져서 그렇게 된 것 같네요!!

[bishoe01]

저도 limit를 넘었을때 판단하는거로 처리를 해줬는데, 맥락은 비슷한 것 같아요.
함수를 어디까지 잘라야할지 명확한 기준이 없이 항상 다른것같은데, 이거는 취향차이일까요? 저는 너무 담아주면 오히려 본코드를 다 옮긴느낌이라 최대길이를 줄이는 방식으로 분할한다는 마인드로 접근하는데, 다른분들은 어떤 생각으로 분리하시는 지 궁금하네요

while left <= right {
        let mid = (left + right) / 2
        totalSpendTime = 0
        for index in 0 ..< diffs.count {
            var prevTime = 0
            if index > 0 {
                prevTime = times[index - 1]
            }
            let tmp = caculateTime(mid, diffs[index], times[index], prevTime)
            totalSpendTime += tmp
        }
        if totalSpendTime > limit {
            left = mid + 1
        }
        else {
            level = mid
            right = mid - 1
        }
    }

[giljihun]

옹 이렇게 닐 병합 연산자로 max()를 처리하셨군요.

저는 아래처럼 짰는데요

    // 이 경우 옵셔널 강제 언래핑을 하면 안되는 경우가 뭐지?
    // var right = diffs.max()!
    // 일단 가드문 처리
    guard let maxDiff = diffs.max() else { exit(0) }

전 right로 했는데(킨더 코드에선 end네용)
생각해보니 강제 언래핑을 하면 안되는 경우가 뭐가 있나~ 생각을 하게되었습니다.
일단 가드문 처리하고 나중에보니 빈 배열인 경우만 안되는거같더라구요.

사실 문제에서 빈 배열이 주어지진 않는거같아서 중요하진 않은거같습니다.ㅋㅋ ㅎㅎ

[giljihun]

요새 느끼는데 제가 방어적으로 코드짜는 습관이 조금 생기지 않았나 싶어요!
근데 비효율을 가져오기도 하는거같아서 더 조심히 사용해야겠습니다.

[alstjr7437]

옹 이렇게 guard문을 하니 예외를 더 확실히 잡는 느낌이라 좋네요!!

이 문제에서 그런 예제는 없지만
갑자기 초과되는 경우 0을 출력해라

이렇게 되면 Gil 처럼 guard문으로 탈출해서 print(0)을 찍으면 끝이라 더욱 좋은 것 같아요!

전 사실 max()가 옵셔널로 오는지 몰라서 급하게 10000을 넣었어요..

[bishoe01]

기가막히네요.. 저는 언제쯤 guard를 자연스럽게 넣을 수 있을까요..
guard쓰면 명시적으로 예외가 느껴져서 가독성이 좋은 것 같아요 !

[alstjr7437]

이번 문제는 코멘트에서 많은 얘기를 한거같네요 !!

제가 생각하는 문제의 핵심은 "레벨은 무조건 diff의 범위 안에 있음" 을 생각해내고, 이분탐색을 들어가는거였다고 생각이 드네요!

@giljihun
Comment 댓글들 달았습니다!!
푼 코드 중 궁금한게 Int64를 따로 준 이유가 있을까요?

+if문 궁금증

            let timePrev: Int
            // 첫 퍼즐은 이전 퍼즐이 없잖여 -> 0
            if i == 0 {
                timePrev = 0
            } else {
                timePrev = times[i - 1]
            }

            let timePrev = (i == 0) ? 0 : times[i - 1]

이렇게 if i == 0 과 같은 부분은 위와 같이 만들 수도 있을 것 같아요!

[giljihun]

@alstjr7437
func solution(~ _ limt:Int64)에서 리밋이 int64고
처음에 Int64안해준 부분에서 계속 오류가 떠서, 밑에 값들도 그렇게 선언해서 줬습니다..!
부분적으로 불필요한 부분이 있네요~ 감사합니다.!

[bishoe01]

문제가 눈에 잘 안들어왔어요! 설명이 장황하니까 헷갈리네요.

Level이 숙련도라고 표현되어있어서 혼란..

결국엔 그냥 적절한 Level값 찾는거였네요!

그럼이제 그러면 시작점을 어떻게 잡을 것이냐...! 였는데,
left를 최소레벨로 , right를 최대레벨로 잡고 이분탐색을 해줬습니다 !

1. caculateTime 함수로 하나의 문제를 풀때 계산해주는 것을 빼줬습니다.
2. 이분탐색으로 limit 넘냐 안넘냐로 범위 조정해주면서 풀이했습니다.

import Foundation

func solution(_ diffs: [Int], _ times: [Int], _ limit: Int64) -> Int {
    var level = -1
    var left = diffs.min()!
    var right = diffs.max()!

    var totalSpendTime = 0

    func caculateTime(_ level: Int, _ diff: Int, _ time: Int, _ prevTime: Int) -> Int {
        let gap = diff - level
        // level이 더 높을 때 - 바로풀릴때
        if gap <= 0 {
            return time
        }
        else {
//            print(gap)
//            print(time)
//            print(prevTime)
//            print((gap * (time + prevTime)) + time)
            return (gap * (time + prevTime)) + time
        }
    }

    while left <= right {
        let mid = (left + right) / 2
        totalSpendTime = 0
        for index in 0 ..< diffs.count {
            var prevTime = 0
            if index > 0 {
                prevTime = times[index - 1]
            }
            let tmp = caculateTime(mid, diffs[index], times[index], prevTime)
            totalSpendTime += tmp
//            print(totalSpendTime)
        }
        if totalSpendTime > limit {
//            print("TOTLAL", totalSpendTime)
            left = mid + 1
        }
        else {
            level = mid
            right = mid - 1
        }
//        print(totalSpendTime)
    }
    return level
}