어쩌다 개발자

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()을 통해 타입을 맞춰준다.

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

class Solution {
    fun solution(keymap: Array<String>, targets: Array<String>): IntArray =
        targets.map { str ->
            str.map { c -> keymap.map { it.indexOf(c) + 1 }
                .filterNot { it < 1 }
                .let { list ->
                    if (list.isEmpty()) -1
                    else list.minOf { it }
                }
            }.let { if ( it.contains(-1)) -1 else it.sum() }
        }.toIntArray()
}

좋은 코드를 짜려면 좋은 코드를 많이 보라는 말에 따라 오늘부터 코틀린스러운 문제 해결법에 집중해서 다른 분의 코드를 분석하고 내 것으로 만드는 과정을 시작해보려 한다. 위 코드를 통해 코틀린의 각종 확장함수와 함수 표현식을 알 수 있다.

위의 코드는 프로그래머스 최용건님의 코드이다. 안에 내용을 안과 밖을 구분해서 분석해보자.

targets.map { str ->
str.map { c -> keymap.map { it.indexOf(c) + 1 }
                .filterNot { it < 1 }
                .let { list ->
                    if (list.isEmpty()) -1
                    else list.minOf { it }
                }

분석해보자면 .map으로 타겟 배열을 스트링 그리고 문자로 나눠서 그 문자가 keymap배열의 몇번째 인덱스에 있는지 확인한다.

이 후 .filterNot을 통해 인덱스가 1보다 작은 것들은 빼고 배열형태로 반환한다.

그리고 리스트안에 만약 문자가 없으면 -1 을 보내고 여러개 있는데 그 중 우리는 최솟값을 찾는 것이기에 minOf를 통해 작은 값을 보낸다.

targets.map { str ->

				...
                
}.let{ if(it.contains(-1)) -1 else it.sum() }

나온 리스트안에 -1이 포함되어있으면 -1을 내보내고 아니라면 리스트안에 원소들을 모두 .sum()을 통해 합한다.

내가 생각하기엔 코틀린스럽다는 말이 이제 조금 와닿고 있다. 아무래도 이 문제에 최적화된 코드는 아니지만 문제가 좀 더 꼬여있을 때를 생각하면 좀 더 확장성 있게 잘 짠 코드인 것 같다.

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

class Solution {
    fun solution(s: String): Int {
        var answer: Int = 0
        var string = s.toList()
        var countA = 0
        var countB = 0
        for (i in 0 until string.size) {
            val firstChar = string[0]
            if (string[i] == firstChar) {
                countA++
                if (countA == countB) {
                    break
                }
            } else if(string[i] != firstChar){
                if (countA == countB) {
                    break
                }
                countB++
            } else {
                answer = 1
                return answer
            }
        }
        if(countA == 1) {
            answer = (s.length/2) + (s.length%2)
        } else {
            val lastS = s.length - countA - countB
            answer = (lastS / countA) + 2
        }
        return answer
    }
}

코드를 분석해보면 알겠지만 이건 문제 파악을 잘못해서 생긴 코드다. 첫글자만 가지고 전체 문자열을 판단하는 것으로 생각하고 코드를 짜서 봤더니 테케는 통과했지만 제출케이스에선 주르륵 빨간불이 들어왔다. 

도무지 이해가 안되서 내용을 다시 천천히 살펴본 결과,, 문자열 분리 후 다시 첫 글자를 가져와서 판단하는 것이었다.

문제를 똑바로 읽자... 제발... 1시간 넘게 내다 버렸다...

class Solution {
    fun solution(s: String): Int {
        var firstChar = s[0]
        var countA = 0
        var countB = 0
        var result = 0
        var reset = false

        s.forEachIndexed { index, char ->
            if (reset) {
                firstChar = char
                reset = false
            }

            if (char == firstChar) countA ++
            if (char != firstChar) countB ++

            if (countA == countB || index == s.lastIndex) {
                result += 1
                reset = true
            }
        }
        return result
    }
}

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

class Solution {
    fun solution(n: Int, lost: IntArray, reserve: IntArray): Int {
        var answer = 0
        var rent = reserve.toMutableList()
        var need = lost.toMutableList()
        var count = 0
        lost.map {
            if (reserve.contains(it)) {
                rent.remove(it)
                need.remove(it)
            }
        }
        need.sort()
        for (i in need) {
            if (rent.contains(i - 1)) {
                count++
                rent.remove(i - 1)
                continue
            }
            else if (rent.contains(i + 1)) {
                count++
                rent.remove(i + 1)
                continue
            }
            else {
                continue
            }
        }
        answer = n - need.size + count 
        return answer
    }
}

문제는 그리 어려운 문제가 아니었으나,, 반례 때문에 좀 헤맸다.. 내 코드에서는 테스트 13, 14번의 케이스가 lost 배열을 정렬해주어야 풀린다.  

테스트 13, 14 의 반례는 4 [4,2] [3,5] 이다.

우선 체육복 여분을 가져온 학생이 도난을 당한 경우를 제하고 도난 당한 학생 배열을 정렬해준 뒤 도난 당한 학생의 값보다 작은 여분 가져온 학생 배열을 우선적으로 찾아주는 방식으로 했다. 시간은 20ms 안쪽으로 나왔다.

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

이번 문제는 풀지 못했다... 가면 갈수록 어려워지고 있다. 다른 분의 코드를 보면서도 이해가 가지 않아 분석을 하면서 공부를하고 실력을 키우는 방향으로 잡았다.

import kotlin.math.min

class Solution {
    fun solution(X: String, Y: String): String {
        var answer: String = ""

        for (ch in (9 downTo 0).toList().map { it.toString() }) {
            answer += ch.repeat(
            min(
            	X.count { it.toString() == ch },
            	Y.count { it.toString() == ch }
               	)
           )
        }
        if (answer.isEmpty()) answer = "-1"
        if (answer.toList().distinct() == listOf('0')) answer = "0"

        return answer
    }
}

우선 이 코드의 방식은 9 부터 0 까지의 숫자로 X와 Y에서 등장하는 횟수를 구한 뒤 둘의 최솟값으로 반환하여 answer에 넣어주는 방식이다.

이제 한줄 한줄 분석해보자.

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

문제를 어떻게 풀어야 할지 막막한 문제였다,,, 결국에 힌트를 보게 되었고 괜찮은 코드를 보았다.

class Solution {
    fun solution(babbling: Array<String>): Int {
    	var answer: Int = 0

        for (i in babbling.indices) {
            if (babbling[i].contains("ayaaya") ||
                babbling[i].contains("yeye") ||
                babbling[i].contains("woowoo") ||
                babbling[i].contains("mama"))
            {
                continue
            }
            babbling[i] = babbling[i].replace("aya", " ")
            babbling[i] = babbling[i].replace("ye", " ")
            babbling[i] = babbling[i].replace("woo", " ")
            babbling[i] = babbling[i].replace("ma", " ")
            babbling[i] = babbling[i].replace(" ", "")

            if (babbling[i].isEmpty()) answer++
        }
        return answer
    }
}

보다보니 호텔 예약 프로그램을 코딩할 때 문자열에 숫자를 포함시키지 않기 위해서 Regex라는 정규 표현식을 사용했던 기억이 났다. 그걸 적용해볼 수 있겠다. 생각이 들어 적용시켜보았다. but 역시 나만 그렇게 생각한게 아니였고 이미 획기적으로 코드량을 줄인 코드가 있었다. 한번 같이 보면서 regex 정규 표현식을 공부해보면 좋을 것 같다.

class Solution {
    fun solution(babbling: Array<String>): Int {
        var answer: Int = 0
        var regexA = "aya|ye|woo|ma".toRegex()
        var regexB = "ayaaya|yeye|woowoo|mama".toRegex()
        answer = babbling.map{it.replace(regexB,"x")}.map{it.replace(regexA,"")}.count{it.isEmpty()}
        return answer
    }
}

이렇게 바꾸니 속도도 이전 코드보다 약 20%가량 더 빨라진 것 같다.

정규 표현식(Regex)

-> Regular Expression의 약자로 특정한 규칙을 가진 문자열의 집합을 표현하기 위해 사용하는 형식 언어

이해가 확 와닿지는 않는다,,, 쉽게 말하자면 주로 어떤 문자열에서 특정한 조건의 문자열을 찾고 싶을 때 쓴다.

예를 들어서 회원가입이나 로그인을 받을 때 아이디나 비밀번호에서 최소 10자리에 숫자, 문자, 특수문자 각각 몇개씩 포함해서 작성해라! 에 따른 유효성 검사를 할 때도 사용가능하고 위에 문제처럼 해당 문자를 찾아 원하는 처리를 하고 싶을 때 자주 사용된다.

정규 표현식의 내용을 정리하려 했으나 그것 보다는 이해를 위한 영상 추천과 잘 정리해둔 블로그를 남겨 놓는게 더 좋을 것 같다는 생각이 들어 밑에 남겨두겠다.

정규 표현식 완전 처음이라면 영상

https://youtu.be/t3M6toIflyQ?si=7C24u9qSMgDXZvpQ

알고 있지만 문법을 확인하고 싶다면 밑에 블로그

https://yoon-dailylife.tistory.com/113