어쩌다 개발자

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

class Solution {
    fun solution(players: Array<String>, callings: Array<String>): Array<String> {
        val rankMap = mutableMapOf<String, Int>()
        
        players.forEachIndexed { index, player ->
            rankMap[player] = index
        }
        
        callings.forEachIndexed { index, player ->
            val calledPlayerRank = rankMap[player] ?: 0
            val frontPlayer = players[calledPlayerRank - 1]
            
            players[calledPlayerRank -1 ] = player
            players[calledPlayerRank] = frontPlayer
            
            rankMap[player] = calledPlayerRank - 1
            rankMap[frontPlayer] = calledPlayerRank
        }
        return players
    }
}

rankMap에 {mumu=0, soe=1, poe=2, kai=3, mine=4} 이런 형식으로 플레이어와 그 인덱스 값을 저장해준다. 

이후 calling된 선수의 랭크를 통해 players안에 인덱스 값을 앞선수와 바꿔준다.

그리고 rankMap의 값도 변경시켜준다.

처음 temp에 서로 인덱스값을 바꿔주는 작업으로 접근했는데 시간 초과가 걸려 hashMap을 통해 검색 시간을 단축시켜서 해결하였다.

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

class Solution {
     fun solution(today: String, terms: Array<String>, privacies: Array<String>): IntArray {
        val answer = mutableListOf<Int>()
        val term = mutableMapOf<String, Int>()
        val todayInt = today.replace(".", "").toInt()

        terms.map {
            val (type, date) = it.split(" ")
            term[type] = date.toInt()
        }

        privacies.mapIndexed { i, it ->
            val (date, type) = it.split(" ")
            var year = term[type]!! / 12
            if (year < 1)
                year = 0

            val month = term[type]!! % 12
            val expiredDate = (date.replace(".", "").toInt() + year * 10000 + month * 100).toString()

            var temp = expiredDate.toInt()
            if (expiredDate[4].toString().toInt() * 10 + expiredDate[5].toString().toInt() > 12) {
                temp -= 1200
                temp += 10000
            }

            if (temp <= todayInt) {
                answer.add(i + 1)
            }
        }
        return answer.toIntArray()
    }
}

today 날짜를 점을 뺀 Int형식으로 날짜를 저장한다.

term 에 terms의 타입과 개월 수를 Map 형식으로 { A=6, B=12, C=3 } 이런식으로 저장한다.

이 후 유효기간의 소멸날짜를 구하기 위해 연수와 개월 수를 구하여 expiredDate에 저장한다.

월 수가 12를 초과했을 경우에 올림 계산을 위해 temp를 통해 연산을 해주고 temp와 오늘 날짜를 비교하여 오늘 날짜가 더 크다면 answer에 담아준다.

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

class Solution {
    fun solution(wallpaper: Array<String>): IntArray {
        var hashIndex = ArrayList<IntArray>()
        
        wallpaper.forEachIndexed { index, i ->
            i.forEachIndexed { index2, j ->
                if ( j == '#') {
                    hashIndex.add(intArrayOf(index, index2))
                }
            }
        }
        var minX = hashIndex.minOf{it[0]}
        var minY = hashIndex.minOf{it[1]}
        var maxX = hashIndex.maxOf{it[0]} + 1
        var maxY = hashIndex.maxOf{it[1]} + 1
        
        return intArrayOf(minX, minY, maxX, maxY)
    }
}

모든 #의 인덱스를 배열리스트에 넣어주고 X,Y좌표에서 최솟값과 최대값을 뽑아주면 되는 문제였다.

이중for문이어서 조금 걱정했으나 테스트케이스의 길이가 얼마 되지 않아 시간도 짧게 나왔다.

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

class Solution {
    fun solution(survey: Array<String>, choices: IntArray): String {
        var answer: String = ""
        
        var person: CharArray = charArrayOf('R', 'T', 'C', 'F', 'J', 'M', 'A', 'N')
        var score: IntArray = IntArray(8) { 0 }

        for (i in survey.indices) {
            score[person.indexOf(survey[i][1])] += choices[i] - 4
        }

        for (i in 0..7 step 2) {
            if (score[i] >= score[i + 1]) answer += person[i]
            else answer += person[i + 1]
        }
        return answer
    }
}

나와 같은 방식으로 푸신 분의 깔끔한 코드를 가져와봤다.

분석을 하면서 공부하고 내 것으로 만들어야겠다.

우선 동점일 경우 알파벳순으로 리턴해주기에 알파벳순으로 charArray에 담아주고 그 크기에 따른 정수 배열도 만들어준다.

그리고 어차피 choices의 숫자를 통해 알파벳들의 숫자 비교를 위한 것이므로 점수에 4를 빼주고 값을 score에 넣어준다.

'CF"일 때 choices가 3이었다면 F를 가져와서 -1을 넣어주면 사실상 C가 1득점한 것과 같은 효과이다.

이후 for문으로 score값들을 step2로 2씩 띄어서 값들을 비교해주고 동점이거나 높으면 우선순위가 높은 알파벳을 리턴해주고 반대는 뒤에 알파벳을 리턴한다.

맵 컬렉션을 좀 더 공부하고 맵을 이용해서 풀어 봐야겠다.

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

class Solution {
    fun solution(ingredient: IntArray): Int {
        var answer: Int = 0
        var stack = mutableListOf<Int>()
        
        for (i in ingredient) {
            stack.add(i)
            if ( stack.size >= 4 && stack.slice(stack.size-4 until stack.size) == listOf(1,2,3,1) ) {
                repeat(4) {stack.removeLast()}
                answer++
            }
        }
        return answer
    }
}

알고리즘 문제를 풀면서 처음으로 Stack 자료 구조를 사용해봤다.

코틀린에선 스택이 구현되어있지 않아서 사용하려면 자바에서 가져오거나 스스로 구현해야한다.

자바에서 가져올 땐 java.util.Stack으로 가져오면 된다.

그럼 var stack = Stack<Int>() 이런 형태로 사용가능하다.

위 문제는 배열의 숫자를 스택에 넣어서 스택 안에 1,2,3,1 형태로 완전한 버거형태가 들어오면 카운트해주고 스택에서 하나씩 제거해주면 해결된다.

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

class Solution {
    fun solution(s: String, skip: String, index: Int): String {
        var answer: String = ""
        val alphabet = mutableListOf('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z')
        alphabet.removeAll { skip.contains(it) }
        answer = s.map {
            alphabet[(alphabet.indexOf(it) + index) % alphabet.size]
        }.joinToString("")
        return answer
    }
}

나는 이런식으로 알파벳을 모두 리스트에 넣고 removeAll을 통해서 삭제시킨 다음 시작했다.

근데 더 깔끔한 방법이 있었다.

class Solution {
    fun solution(s: String, skip: String, index: Int): String {
        val alphabet = ('a'..'z').filter{ it !in skip }
        return s.map { alphabet[(alphabet.indexOf(it) + index) % alphabet.size] }.joinToString("")
    }
}

저런식으로도 되는구나...

맵 안에를 설명하자면 간단하다.

s 안을 순회하며 it이 알파벳의 몇번째 인덱스에 속하는지 값과 건너뛰어야 하는 index값을 더하고 알파벳 배열인덱스를 초과할 수 있기 때문에 배열 사이즈로 나머지 연산을 해준다. 이후 리턴 타입이 스트링이므로 joinToString()을 통해 타입을 맞춰준다.