어쩌다 개발자

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
    }
}

그냥 간단하게 텍스트뷰를 누르면 웹뷰에 연결되어서 걸려있는 url로 넘어가는 기능을 하나 넣어보고 싶었다.

우선 간단하게 사용법을 알아보자.

XML파일코드

<WebView
    android:id="@+id/webView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:visibility="gone"
    />

위젯에서 웹뷰를 가져와서 해당 레이아웃을 가득차게 만들어주고 가려준다.

val webView = findViewById<WebView>(R.id.webView)

액티비티 파일에서 웹뷰 객체를 만든다.

// WebView 설정
val webSettings: WebSettings = webView.settings
webSettings.javaScriptEnabled = true // JavaScript 활성화
// WebViewClient를 설정하여 새 창이 아니라 현재 WebView에서 링크가 열리도록 함
webView.webViewClient = WebViewClient()

웹뷰를 사용하기 위해선 WebSettings, webViewClient 클래스를 import해야한다.

blogTextView.setOnClickListener {
    val url = "https://happenedtodeveloper.tistory.com/" // 원하는 링크 주소로 변경
    webView.visibility = WebView.VISIBLE
    webView.loadUrl(url)
}

githubTextView.setOnClickListener {
    val url = "https://github.com/Bladepark" // 원하는 링크 주소로 변경
    webView.visibility = WebView.VISIBLE
    webView.loadUrl(url)
}

TextView가 클릭되면 gone에서 visible로 바꿔주고 url을 로드해서 웹뷰가 동작하도록 만들어준다.

해봤는데 이런 net::ERR_CACHE_MISS 에러가 뜬다면 현재 프로젝트에 인터넷을 쓸 수 있는 권한이 설정되어있지 않은거다.

프로젝트의 manifests 파일에 가서 <uses_permission android:name="android.permission.INTERNET"/> 코드로 인터넷 권한을 설정해주면 된다.

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에 넣어주는 방식이다.

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