어쩌다 개발자

https://school.programmers.co.kr/learn/courses/30/lessons/77484?language=kotlin

class Solution {
    fun solution(lottos: IntArray, win_nums: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        var countA = 0
        var countB = 0
        var bestRank = 0
        var worstRank = 0
        lottos.map {
            if(win_nums.contains(it)) {
                countA++
            }
            if(it == 0) {
                countB++
            }
        }
        when(countA){
            6 -> worstRank = 1
            5 -> worstRank = 2
            4 -> worstRank = 3
            3 -> worstRank = 4
            2 -> worstRank = 5
            1 -> worstRank = 6
            0 -> worstRank = 6
        }
        when(countA  + countB){
            6 -> bestRank = 1
            5 -> bestRank = 2
            4 -> bestRank = 3
            3 -> bestRank = 4
            2 -> bestRank = 5
            1 -> bestRank = 6
            0 -> bestRank = 6
        }
        answer += bestRank
        answer += worstRank
        return answer
    }
}

크게 생각하지 않고 순수하게 적어봤다..

속도가 조금 아쉽다..

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

class Solution {
    fun solution(number: Int, limit: Int, power: Int): Int {
        var answer: Int = 0
        var factorList = arrayListOf<Int>()
        var count = 0
        for(i in 1..number){
            for(j in 1..i){
                if(i % j ==0){
                    count++
                }
            }
            factorList += count
            count = 0
        }
        factorList.map {
            if(it > limit){
                answer += power
            }
            else answer += it
        }
        return answer
    }
}

로직은 간단해서 그냥 바로바로 쳤더니 역시 생각없이 친 코드는 시간초과다,,ㅎㅎ

약수를 구하는 과정을 좀 단순하게 해야할 것 같다. 

import kotlin.math.sqrt
class Solution {
    fun solution(number: Int, limit: Int, power: Int): Int {
        var answer: Int = 0
        var count = 0
        for(i in 1..number){
            var sqrtNum = sqrt(i.toDouble()).toInt()
            var count = 0
            for(j in 1..sqrtNum){
                if(i%j==0){
                    if (i / j == j) count += 1
                    if (i / j != j) count += 2
                }
            }
            if(count>limit) answer+=power
            else answer+=count
        }
        return answer
    }
}

약수를 구하는 방법을 찾아보니 제곱근을 통해서 시간복잡도를 조금 해결해줄 수 있는 방법을 찾았다.

만약 100의 약수를 찾는다면 100의 제곱근인 10까지의 약수[1,2,5,10]를 구한 후 100을 10까지의 약수로 나눠진 값을 합치고 중복된 숫자를 Set나 다른 방법으로 제거하고 count해주면 된다.

하지만 나는 조금 더 간결하게 해봤다. 결국에 1을 제외하고 나머지 약수에서 결국엔 2개씩의 카운트가 나오기에 위의 코드처럼 짰다.

통과!

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

class Solution {
    fun solution(n: Int, m: Int, section: IntArray): Int {
        var answer: Int = 0
        var max = 0
        if(m == 1) {
            answer = section.size
        }
        else {
            for(i in 0 until section.size){
                if(section[i] < max){
                    continue
                }
                answer++
                max = section[i] + m
            }
        }
        return answer
    }
}

처음에 answer 값에 1을 먼저두고 max에 m값을 넣어놓고 풀었다.

예시 테스트는 통과했으나 채점테스트에서 4개의 반례가 나왔다. 찾아봐도 반례를 못찾아 조원분께 도움을 요청드렸다.

알고보니 같은 문제에서 테스트 값 5, 2, [1,2,5] 로 꽤나 고생을 하셨다고 하셨다. 한번 테스트값으로 추가해보라는 말씀대로 추가해서 보니 정말 내 코드의 반례가 되는 예시였다. 천천히 코드에 넣어서 분석해보니 for문안에 if문에서 section[i]값과 max값이 같을 때 일어나는 문제였다. 

answer 초기값 0 max도 초기값 0 으로 실행하면 정말 쉽게 풀어지는 문제였다.

도움을 요청하고 함께 문제점을 논의하는 과정이 정말 중요하다는 이야기를 들을 때면  "그래 그렇지" 라는 생각만 들었다. 하지만 사실 실제로 그렇게 하는 것은 보기보다 어려운 문제인 것 같다..

살면서 어려움에 봉착했을 때 다른 사람에게 도움을 구해야 겠다는 생각과 행동은 도움을 구해본 경험이 중요한 것 같다.

도움을 요청하려는 생각이 나의 약점을 노출시키고 초라하게 만들 것이라고 느껴왔던건지 나는 살면서 도움을 많이 요청한 경험이 많이 없었다. (<- 이런 사람 특: 알게모르게 도움 많이 받음,,ㅎㅎ)

하지만 내일배움캠프를 하면서 정말 적극적으로 모르는 것에 있어서 팀원들 그리고 튜터분들께 질문하고 도움을 요청하면서 느낀 점은 도움을 요청하는 것이 내 생각과 다르게 나를 더 빠르게 성장시키고 발전시키고 있다는 것이다.

도움을 요청하기 전에 내가 어떤 부분에서 어려움을 느끼고 있는지 정확히 인지하고 있어야 하는 부분에서 스스로 배우는 것도 많았고 모르는 부분에 대한 답변을 받을 때 모르는 부분을 포함한 그 외 것들에서도 배우는게 있었다.

이번에 정말 이건 반례가 없다!!! 프로그래머스 프로그램에서 문제점을 발견했다!!! 라고 생각했던 나를 다시 되돌아보게 된 문제였다.

3조 경식님께 감사의 말씀 올립니다ㅎㅎ

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

class Solution {
    fun solution(nums: IntArray): Int {
        var answer = 0
        var sumList = mutableListOf<Int>()
        for(i in 0 until nums.size-2) {
            for(j in i+1 until nums.size-1) {
                for(k in j+1 until nums.size)
                sumList += nums[i] + nums[j] + nums[k]
            }
        }
        for(number in sumList){
            var count = 0
            for(i in 1..number){
                if(number % i == 0){
                    count++
                }
            }
            if(count == 2){
                answer += 1
            }
        }
        return answer
    }
}

그냥 자동적으로 거의 쳐진 코드다.. 그만큼 정말 단순하게 써내려간 코드

몇몇개의 테스트 빼고는 시간도 괜찮게 나온거 같긴하지만 알고리즘을 공부해서 적용시키면 얼마나 더 빠를지 궁금하다.

개인 프로젝트를 끝내고 시간이 남으면 얼른 공부해보고 글을 작성하고 싶다.

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가 들어와서 

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

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

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