어쩌다 개발자

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

class Solution {
    fun solution(k: Int, m: Int, score: IntArray): Int {
        var answer: Int = 0
        var appleList = listOf<Int>()
        var appleBox = mutableListOf<Int>()
        
        appleList = score.sortedDescending()
        for(i in 0 until appleList.size) {
            if(appleBox.size < m) {
                appleBox.add(appleList[i])
                if(appleBox.size == m) {
                    answer += appleBox.minOf{it} * m
                    appleBox.clear()
                }
            }
        }
        return answer
    }
}

이런식으로 풀었더니 시간이 길게 걸리는게 275ms가 있었다,,, 

이런식으로는 안되겠다 싶어 좀 더 꼼꼼히 보니 결국엔 사실 m사이즈만큼의 각 배열에서 마지막 숫자만큼만 m과 곱해준다는 규칙성을 발견하고 코드를 다시 수정했다.

class Solution {
    fun solution(k: Int, m: Int, score: IntArray): Int {
        var answer: Int = 0
        score.sortDescending()
        var lastNum = 0
        score.forEach{
            lastNum++
            if(lastNum%m == 0){
               answer+= it*m
            }
        }
        return answer
    }
}

 배열에 굳이 넣을 필요없이 m 에 딱 떨어지는 숫자일 때 마다 m에 딱 떨어지는 숫자에 m을 곱해주면 된다.

효율이 2배이상 좋아졌다,,

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

또 하나 배운 알고리즘 문제였다..

코드 먼저 보자.

class Solution {
    fun solution(cards1: Array<String>, cards2: Array<String>, goal: Array<String>): String {
        var answer: String = "Yes"
        var index1 = 0
        var index2 = 0
        
        goal.forEach {
            if(cards1.size > index1 && cards1[index1] == it){
                index1++
            }
            else if(cards2.size > index2 && cards2[index2] == it){
                index2++
            }
            else {
                return "No"
            }
        }
        return answer
    }
}

if 문에서 &&연산자를 사용할 때도 조건의 순서가 중요하다는 점을 배웠다.

처음에는 && 연산자 사이에 조건을 별 생각없이 지금과 반대로 했었다. 

if(cards1[index1] == it && cards1.size > index1)

else if(cards2[index2] == it && cards2.size > index2)

이렇게 하니 돌아오는 것은,,, 런타임 에러,,,

보아 하니 인덱스 값이 길이를 초과한 모양이다.

테스트 2번 예제와 else if 구절을 뜯어보면 이해가 가능하다.

else if(cards2[index2] == it && cards2.size > index2){
      index2++
}

테스트 2번에서는 cards2의 index2값이 0에서 "want"를 만나 1이 되고 "to"를 만나 2가 된다.

이 후 "drink"를 찾으러 가는데 cards1에서는 못찾으니 else if로 내려오게 되면서 문제가 발생한다.

&&연산자 첫 번째 조건에서 cards2[index2] == it 여기서 cards1의 인덱스는 0과 1 뿐인데 index2의 값인 2가 들어와서 

배열인덱스의 범위를 초과한 값을 넣은 것이다. 

&&연산자 양옆의 조건 위치를 반대로 해주니 통과가 되었다.

이를 통해 && 연산자의 첫 번째 조건을 우선적으로 검사를 한다는 것을 알 수 있었고 결과에 큰 영향을 미칠 수 있으므로 순서도 잘 생각해서 배치해주어야 한다는 걸 배웠다.

class Solution {
    fun solution(a: Int, b: Int): String {
        var answer = ""
        var totalDay:Int = b
        
        for(month in 1 until a) {
            when(month) {
                1,3,5,7,8,10,12 -> totalDay += 31
                2 -> totalDay += 29
                4,6,9,11 -> totalDay += 30
            }
        }
        when(totalDay % 7) {
            1 -> answer = "FRI"
            2 -> answer = "SAT"
            3 -> answer = "SUN"
            4 -> answer = "MON"
            5 -> answer = "TUE"
            6 -> answer = "WED"
            else -> answer = "THU"
        }
        return answer
    }
}

로직은 어렵지 않은 문제였는데 for문에서 a 해당 월은 빼고 계산하기 위해서 ..  이 아닌 until 을 썼어야 했는데 이 부분을 늦게 눈치챘다.

for 문으로 1월부터 a월 전까지 반복을 돌리고 when 문으로 각 월의 요일 수를 더해줬다. totalDay에 이미 b 값이 들어가 있기에 또 더해줄 필요는 없게 했다.

그리고 총 요일 수를 7로 나머지 계산을 해주면 쉽게 요일 수를 알아낼 수 있다. 금요일이 1일이니 totalDay % 7이 1이면 금요일 이런식으로 계산한다.

지금 생각해보면서 조금 아쉬운건 코드량을 더 줄일 수 있었다.

val whatDay = listOf("FRI","SAT","SUN","MON","TUE","WED","THU")

answer = whatDay[totalDay%7]

이런 식으로 when문을 삭제시킬 수 있었다.

class Solution {
    fun solution(k: Int, score: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        var legendSinger = mutableListOf<Int>()
        var result = mutableListOf<Int>()
        var dangerLegend = 0
        
        score.map {
            if(legendSinger.size < k) {
                legendSinger.add(it)
            }
            else {
                if(it > dangerLegend) {
                    legendSinger.remove(dangerLegend)
                    legendSinger.add(it)
                }
            }
            dangerLegend = legendSinger.minOf{it}
            result += dangerLegend
        }
        answer = result.toIntArray()
        return answer
    }
}

별로 시간이 안걸린 문제였다. 다만 리스트에서 최솟값을 뽑는 minOrNull()에서 문제가 발생했다. 찾아보니 minOf{it}로 사용 가능하다는 정보가 있어서 적용했더니 다행히도 되었다...

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

아침부터 머리가 안돌아가서 푸는데 40분 걸렸다,, 풀고보니 간단한 문제였다..

class Solution {
    fun solution(a: Int, b: Int, n: Int): Int {
        var answer: Int = 0
        var quotient = 0
        var remainder = 0
        var newCola = 0
        var emptyCola = n
        
        while(emptyCola>=a) {
            quotient = emptyCola/a
            remainder = emptyCola%a
            
            newCola = (quotient * b)
            answer += newCola
            
            emptyCola = newCola + remainder
            newCola = 0
        }
        return answer
    }
}

while 문을 통해서 빈 병 개수가 최소요구 개수보다 클 때만 코드가 진행되도록 만들었다.

quotient 와 remainder로 몫과 나머지를 따로 빼서 새 병을 얻을 때와 빈 병 개수 처리에 쓸수 있도록 해줬다.

상빈이 그 자체인 분이 계셨다,, 완벽한 인라인 코딩,, 다른 분의 코드를 가져와봤다.

class Solution {
    fun solution(a: Int, b: Int, n: Int): Int {
        return (if (n > b) n - b else 0) / (a - b) * b
    }
}

분석해보고 싶으나 머리가 못 따라가겠다,, 다음에 다시오마,,,

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

class Solution {
    fun solution(food: IntArray): String {
        var answer: String = ""
        var numArr = food.slice(1..food.size-1).map{it/2}
        var foodList = mutableListOf<Int>()
        
        for(i in numArr.indices) {
            for(j in 0 until numArr[i]) {
                if(numArr[i] != 0) {
                    foodList.add(i+1)
                }
            }
        }
        
        answer = foodList.joinToString("") + '0' + foodList.reversed().joinToString("")
        return answer
    }
}

코드를 먼저 보자.

우선 , 물을 제외하고 음식 부분의 배열만 먼저 slice로 가져온 뒤 2로 나눠 정수 부분으로 가져왔다.

그 후 정수 숫자 만큼 인덱스 숫자를 찍어주고 나온 리스트를 '0'과 그 역순의 리스트와 합쳐줘서 반환해준다.