[프로그래머스] 모의고사 풀이 Kotlin

thumbnail

안녕하세요. 이번에는 프로그래머스 모의고사 문제를 풀어보려고 합니다. 

Problem

---

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

프로그래머스

Solution

---

import kotlin.math.max

class Solution {
    fun solution(answers: IntArray): IntArray {
        var answer = intArrayOf()
        val one = listOf<Int>(1, 2, 3, 4, 5)
        val two = listOf<Int>(2, 1, 2, 3, 2, 4, 2, 5)
        val three = listOf<Int>(3, 3, 1, 1, 2, 2, 4, 4 ,5 ,5)
        var highScore = 0
        var scoreList = intArrayOf()

        for(i in 0..2) {
            var size = answers.size / one.size + 1
            var count = 0

            when(i) {
                0 -> {
                    count = getScore(one, size, answers)
                }

                1 -> {
                    count = getScore(two, size, answers)
                }

                2 -> {
                    count = getScore(three, size, answers)
                }
            }

            highScore = max(highScore, count)
            scoreList += count
        }

        for(i in scoreList.indices) {
            if(highScore == scoreList[i]) {
                answer += i + 1
            }    
        }

        return answer
    }

    /**
    * 각 수포자의 점수를 얻는 함수
    * @param way 수포자가 찍는 방식
    * @param size answers의 길이만큼 way를 늘려주기 위한 크기
    * @param answers 정답 개수를 매칭 하기 위한 정보
    * @return 맞춘 개수를 리턴
    */

    fun getScore(way: List<Int>, size: Int, answers: IntArray): Int {
        val repeatedList = List(size) { way  }.flatten()

        val count = answers.filterIndexed { index, num ->
            num == repeatedList[index]
        }.count()

        return count
    }

}

 이번 문제는 찍는 방식을 선언해 주고 filterIndexed와 count를 사용해서 맞춘 갯수를 카운트하는 방식으로 코드를 작성해 보았습니다. 이번 문제는 크게 어려움이 없던 문제였습니다.

 

1. 다른 사람 코드

class Solution {
        fun solution(answers: IntArray): IntArray {

            val studentA = listOf(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
            val studentB = listOf(2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5)
            val studentC = listOf(3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5)

            val r = listOf(
                Pair(1, answers.filterIndexed { index, i -> studentA[index % studentA.size] == i }.count()),
                Pair(2, answers.filterIndexed { index, i -> studentB[index % studentB.size] == i }.count()),
                Pair(3, answers.filterIndexed { index, i -> studentC[index % studentC.size] == i }.count())
            )
                .also { println(it) }
                .sortedByDescending { it.second }

            return when {
                r[0].second == r[1].second && r[1].second == r[2].second -> intArrayOf(r[0].first, r[1].first, r[2].first)
                r[0].second == r[1].second -> intArrayOf(r[0].first, r[1].first)
                else -> intArrayOf(r[0].first)
            }
        }
    }

 이번 코드는 찍는 수를 % 나머지 연사자를 통해서 접근한 방법입니다. 앞으로 index를 접근할 때 나머지 연산자를 잘 활용해도 좋을 것 같습니다. 풀이는 크게 저의 코드와 다르지는 않지만 % 연산자를 잘 활용한 코드 같아서 공부용으로 가져와보았습니다. 더 좋은 방법이나 추천해주고 싶은 방법이 있으신다면 편하게 댓글 남겨주세요 :)

---

Performance

1. 내가 작성한 코드	2. 다른 사람 코드