어쩌다 개발자

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

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/42840

class Solution {
    fun solution(answers: IntArray): IntArray {
        var answer = intArrayOf()
        val numArr = arrayOf(intArrayOf(1,2,3,4,5),intArrayOf(2,1,2,3,2,4,2,5),intArrayOf(3,3,1,1,2,2,4,4,5,5))
        val score = IntArray(3)

        for (i in 0 until answers.size) {
            if(numArr[0][i]==answers[i%5] ) {
                score[0]++
            }
            if(numArr[1][i]==answers[i%8] ) {
                score[1]++
            }
            if(numArr[2][i]==answers[i%10] ) {
                score[2]++
            }
        }
        if(score[0] == score[1] && score[1] == score[2]) {
            answer = intArrayOf(1,2,3)
        } else {
            var temp = arrayListOf<Int>()
            val maxScore = maxOf(score[0], maxOf(score[1], score[2]))
            if (maxScore == score[0]) temp.add(1)
            if (maxScore == score[1]) temp.add(2)
            if (maxScore == score[2]) temp.add(3)
            answer = temp.toIntArray()
        }
        return answer
    }
}

앞선 테스트 1,2는 통과했지만 무식하게 이런식으로 짜니 제출한 결과는,, 런타임 에러 잔뜩

좀 더 단순하게 만들어보려 했으나 시간이 너무 많이 투자됐다,, 잘하신 분의 코드를 보자.

class Solution {
    fun solution(answers: IntArray): IntArray {
        val userAnswers = arrayOf(
            intArrayOf(1,2,3,4,5), intArrayOf(2,1,2,3,2,4,2,5), intArrayOf(3,3,1,1,2,2,4,4,5,5))
        val cnt = IntArray(3)
        val answer = mutableListOf<Int>()
        
        userAnswers.forEachIndexed { i, userAns -> 
            cnt[i] = answers.filterIndexed { j, ans -> ans == userAns[j % userAns.size] }.count()
        }
        cnt.forEachIndexed{ idx, i -> if(cnt.max() == i) answer.add(idx + 1) }
        
        return answer.toIntArray()
    }
}
출처: https://yline.tistory.com/107 [Y_LINE's_Repository:티스토리]

나와 비슷하게 배열안에 배열을 넣어 푸셨다. forEach 와 indexed를 잘 활용하여 푸신 것 같다.