[프로그래머스][Kotlin][LV0][코딩 기초 트레이닝] 문제 모음 // 04/21 추가// 04/25 추가 // 04/30 추가

안드로이드 스튜디오를 공부하다가 오랜만에 프로그래머스에 접속하였는데 문제들이 조금 업데이트 되어있어, 풀어봤습니다. 기초라서 그런지 뭔가 처음부터 복습한다는 느낌을 받았습니다.
기초문제들이 많이 추가 되어 아직 다 풀지는 못하였지만, 해당 게시글에 추가하는 형태로 작성 할 수 있도록 하겠습니다.


ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ추가
코드 작성 시 그냥 생각나는대로 작성하여 최적화된 코드가 아님을 말씀드립니다.
 

문제명 나머지 구하기
class Solution {
    fun solution(num1: Int, num2: Int) = num1 % num2
}

문제명 두 수의 차
class Solution {
    fun solution(num1: Int, num2: Int) = num1 - num2
}

문제명 두 수의 곱
class Solution {
    fun solution(num1: Int, num2: Int) = num1 * num2
}

문제명 나이 출력
class Solution {
    fun solution(age: Int) = 2022 - age + 1
}

문제명 몫 구하기
class Solution {
    fun solution(num1: Int, num2: Int) = num1/num2
}

문제명 두 수의 합
class Solution {
    fun solution(num1: Int, num2: Int) = num1 + num2
}

문제명 숫자 비교하기
class Solution {
    fun solution(num1: Int, num2: Int): Int {
        if(num1 != num2) return -1
        else return 1
    }
}

문제명 각도기
class Solution {
    fun solution(angle: Int): Int {
        when(angle){
            in 1 .. 89 -> return 1
            90 -> return 2
            in 91 .. 179 -> return 3
            180 -> return 4
        }
        return 0
    }
}

문제명 두 수의 나눗셈
class Solution {
    fun solution(num1: Int, num2: Int): Int {
        var answer = (num1.toDouble() / num2.toDouble() * 1000).toInt()
        return answer
    }
}

문제명 배열의 평균값
class Solution {
    fun solution(numbers: IntArray): Double {
        var answer: Double
        var sum = 0
        for(i in numbers){
            sum += i
        }
        answer = sum.toDouble() / numbers.size.toDouble()
        return answer
    }
}

혹은
class Solution {
    fun solution(numbers: IntArray): Double {
        var answer: Double = numbers.average().toDouble()
        return answer
    }
}

문제명 중복된 숫자 개수
class Solution {
    fun solution(array: IntArray, n: Int) = array.count{e -> e == n}
}

문제명 짝수의 합
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        for(i in 0 .. n){
            if(i%2 == 0) answer += i
        }
        return answer
    }
}

문제명 양꼬치
class Solution {
    fun solution(n: Int, k: Int): Int {
        val bonus = n / 10
        var answer = n * 12000 + k * 2000 - bonus * 2000
        return answer
    }
}

문제명 머쓱이보다 키 큰 사람
class Solution {
    fun solution(array: IntArray, height: Int) = array.count{e -> e > height}
}

문제명 편지
class Solution {
    fun solution(message: String): Int {
        var answer = message.length * 2
        return answer
    }
}

문제명 배열 원소의 길이
class Solution {
    fun solution(strlist: Array<String>): IntArray {
        var answer = mutableListOf<Int>()
        for(i in strlist){
            answer.add(i.length)
        }
        return answer.toIntArray()
    }
}

문제명 문자열안에 문자열
class Solution {
    fun solution(str1: String, str2: String): Int {
        var answer: Int = 0
        if(str1.contains(str2)) answer = 1
        else answer = 2
        return answer
    }
}

문제명 피자 나눠 먹기(3)
class Solution {
    fun solution(slice: Int, n: Int): Int {
        var answer: Int = 0
        while(slice * answer < n){
            answer++
        }
        return answer
    }
}

문제명 피자 나눠 먹기(1)
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        while(answer < n){
            answer += 7
        }
        return answer/7
    }
}

문제명 배열 두배 만들기
class Solution {
    fun solution(numbers: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        for(num in numbers){
            answer += num * 2
        }
        return answer
    }
}

문제명 배열 뒤집기
class Solution {
    fun solution(num_list: IntArray): IntArray = num_list.reversed().toIntArray()
}

문제명 아이스 아메리카노
class Solution {
    fun solution(money: Int): IntArray {
        var answer: IntArray = intArrayOf()
        answer += money/5500
        answer += money%5500
        return answer
    }
}

문제명 문자열 뒤집기
class Solution {
    fun solution(my_string: String) = my_string.reversed()
}

문제명 배열 자르기 
class Solution {
    fun solution(numbers: IntArray, num1: Int, num2: Int): IntArray {
        var answer = mutableListOf<Int>()
        for(i in num1 .. num2){
            answer.add(numbers[i])
        }
        return answer.toIntArray()
    }
}

문제명 최댓값 만들기(1)
class Solution {
    fun solution(numbers: IntArray): Int {
        var answer: Int = 0
        val num = numbers.sorted()
        answer = num[num.size-1] * num[num.size-2]
        return answer
    }
}

문제명 삼각형의 완성조건(1)
class Solution {
    fun solution(sides: IntArray): Int {
        var answer: Int = 0
        if(sides.sum()-sides.maxOrNull()!! * 2 > 0) answer = 1
        else answer = 2
        return answer
    }
}

문제명 제곱수 판별하기
import kotlin.math.*
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        if(sqrt(n.toDouble()).toInt() * sqrt(n.toDouble()).toInt() == n) answer = 1
        else answer = 2
        return answer
    }
}

문제명 자릿수 더하기
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        var temp = n.toString()
        for(i in temp){
            answer += i.toString().toInt()
        }
        return answer
    }
}

문제명 가장 큰 수 찾기
class Solution {
    fun solution(array: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        answer += array.maxOrNull()!!
        answer += array.indexOf(array.maxOrNull()!!)
        return answer
    }
}

문제명 짝수는 싫어요
class Solution {
    fun solution(n: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in 1 .. n){
            if(i%2 != 0) answer += i
        }
        return answer
    }
}

문제명 N의 배수 고르기
class Solution {
    fun solution(n: Int, numlist: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        for(num in numlist){
            if(num % n == 0 && num >= n) answer += num
        }
        return answer
    }
}

문제명 약수 구하기
class Solution {
    fun solution(n: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in 1 .. n){
            if(n % i == 0) answer += i
        }
        return answer
    }
}

문제명 문자 반복 출력하기
class Solution {
    fun solution(my_string: String, n: Int): String {
        var answer: String = ""
        for(i in 0 .. my_string.length-1){
            for( j in 1 .. n){
                answer += my_string[i]
            }
        }
        return answer
    }
}

문제명 세균 증식
class Solution {
    fun solution(n: Int, t: Int) = 2*n*t
}

문제명 순서쌍의 개수
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        for(i in 1 .. n){
            if(n % i == 0) answer++
        }
        return answer
    }
}

문제명 점의 위치 구하기
class Solution {
    fun solution(dot: IntArray): Int {
        var answer: Int = 0
        
        if(dot[0] > 0){
            if(dot[1]>0) answer = 1
            else answer = 4
        } else {
            if(dot[1]<0) answer = 3
            else answer = 2
        }
        
        return answer
    }
}

문제명 개미 군단
class Solution {
    fun solution(hp: Int): Int {
        var answer: Int 
        var hp5 = hp/5
        var hp3 = (hp % 5) / 3
        var hp1 = (hp % 5) % 3
        answer = hp5 + hp3 + hp1
        return answer
    }
}

문제명 특정 문자 제거하기
class Solution {
    fun solution(my_string: String, letter: String) = my_string.replace(letter,"")
}

문제명 옷가게 할인 받기
class Solution {
    fun solution(price: Int): Int {
        var answer: Double = 0.0
        when(price){
            in(0 until 100000) -> answer = price.toDouble()
            in(100000 until 300000) -> answer = price.toDouble() * 0.95
            in(300000 until 500000) -> answer = price.toDouble() * 0.9
            else -> answer = price.toDouble() * 0.8
            
        }
        return answer.toInt()
    }
}

중앙값 구하기
class Solution {
    fun solution(array: IntArray): Int {
        var answer = array.toList().sorted()
        return answer[answer.size/2]
    }
}

문제명 배열의 유사도
class Solution {
    fun solution(s1: Array<String>, s2: Array<String>): Int {
        var answer: Int = 0
        for(chk in s1){
            answer += s2.count{e-> e == chk}
        }
        return answer
    }
}

문제명 숨어있는 숫자의 덧셈(1)
class Solution {
    fun solution(my_string: String): Int {
        var answer: Int = 0
        for(chk in my_string){
            if(chk.toInt()-48 in 0 .. 9) answer += chk.toInt()-48
        }
        return answer
    }
}

문제명 모음 제거
class Solution {
    fun solution(my_string: String) = my_string.replace("a","")
        .replace("e","")
        .replace("i","")
        .replace("o","")
        .replace("u","")
}

문제명 공 던지기
class Solution {
    fun solution(numbers: IntArray, k: Int): Int {
        var answer: Int = 0
        var tempList = numbers.toMutableList()
        while(k*2 >= tempList.size){
            tempList += numbers.toMutableList()
        }
        answer = tempList[(k-1)*2]
        return answer
    }
}

문제명 숨어있는 숫자의 덧셈(2)
class Solution {
    fun solution(my_string: String): Int {
        var answer: Int = 0
        var temp = ""
        for( check in my_string){
            if(check.toInt()-48 in 0 .. 9){
                temp += check.toString()
            } else {
                if(temp != ""){
                    answer += temp.toInt()
                    temp = ""
                }
            }
        }
        if(temp != ""){
            answer += temp.toInt()
        }
        return answer
    }
}

문제명 소인수분해
class Solution {
    fun solution(n: Int): IntArray {
        var answer = mutableSetOf<Int>()
        var checkN = n
        var count = 2
        while(checkN+1 > count){
            if(checkN % count == 0){
                checkN /= count
                answer.add(count)
            } else {
                count++
            }
        }
        return answer.toIntArray()
    }
}

문제명 영어가 싫어요
class Solution {
    fun solution(numbers: String): Long {
        var answer = numbers
        val tempList = listOf("zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine")
        var count = 0
        tempList.forEach{
            answer = answer.replace(it, count.toString())
            count++
        }
        return answer.toLong()
    }
}

문제명 구슬을 나누는 경우의 수
import java.math.BigInteger
class Solution {
    fun solution(balls: Int, share: Int): Int {
        var answer: BigInteger = factorial(balls) / ( factorial(balls-share) * factorial(share) )
        return answer.toInt()
    }
    fun factorial(n : Int) : BigInteger {
        if(n == 0){
            return 1.toBigInteger()
        } else {
            return n.toBigInteger() * factorial(n-1)
        }
    }
}

// 해당 알고리즘은 재귀함수의 사용법과 BigInteger의 개념을 알아야 풀 수 있는 문제였습니다.
// 필자의 경우 낮은 수의 팩토리얼만 생각하다가 통과가 안되어 범위를 확인해보니 INT 및 LONG의
// 범위를 넘어가는 것을 확인 후 BigInteger를 사용하여 통과하였습니다.

문제명 외계어 사전
class Solution {
    fun solution(spell: Array<String>, dic: Array<String>): Int {
        var answer: Int = 0
        var swith = 0
        dic.forEach{
            var count = 0
            for(i in 0 .. spell.size-1){
                if(it.count{e -> e.toString() == spell[i]} == 1) count++
            }
            if(count == spell.size) swith++
        }
        if(swith > 0) answer = 1 else answer = 2
        return answer
    }
}

문제먕 문자열 계산하기
class Solution {
    fun solution(my_string: String): Int {
        var answer: Int = 0
        var pm = mutableListOf<String>()
        var num = mutableListOf<Int>()
        var temp = ""
        my_string.forEach{
            if(it.toInt()-48 in 0 .. 9){
                temp += it
            } else if(it == '+' || it == '-'){
                pm.add(it.toString())
                num.add(temp.toInt())
                temp = ""
            }
        }
        num.add(temp.toInt())
        
        answer += num[0]
        var count = 0
        for(i in 1 .. num.size-1){
            if(pm[count] == "+"){
                answer += num[i]
                count++
            } else {
                answer -= num[i]
                count++
            }
        }
        
        return answer
    }
}

문제명 캐릭터의 좌표
class Solution {
    fun solution(keyinput: Array<String>, board: IntArray): IntArray {
        var answer = IntArray(2,{0})
        keyinput.forEach{
            when(it){
                "up" -> if(answer[1] < board[1]/2 ){
                                answer[1] += 1
                            }
                "down" -> if(answer[1] > (board[1]/2) * -1 ){
                                answer[1] -= 1
                            }
                "right" -> if(answer[0] < board[0]/2 ){
                                answer[0] += 1
                            }
                "left" -> if(answer[0] > (board[0]/2) * -1 ){
                                answer[0] -= 1
                            }
            }
        }
        return answer
    }
}

문제명 삼각형의 완성조건(2)
class Solution {
    fun solution(sides: IntArray): Int {
        var answer: Int = 0
        val max = sides.sum()-1
        val min = sides.maxOrNull()!! - sides.minOrNull()!! + 1
        answer = max - min + 1
        
        return answer
    }
}

문제명 직사각형 넓이 구하기
class Solution {
    fun solution(dots: Array<IntArray>): Int {
        var len = dots[0][0]
        var high = dots[0][1]
        for(i in 1 .. dots.size-1){
            if(dots[i][0] != len && dots[i][1] != high){
                len = if(len > dots[i][0] ) len - dots[i][0] else dots[i][0] - len

                high = if(high > dots[i][1] ) high - dots[i][1] else dots[i][1] - high

                break
            }
        }

        return len * high
    }
}

문제명 유한소수 판별하기
class Solution {
    fun solution(a: Int, b: Int): Int {
        var answer: Int = 0
        var temp2 = a
        if(a > b) {
            temp2 -= b
        }
        if(temp2 % b == 0){
            return 1
        } 
        var temp : Int = b
        for(i in 2 .. temp2){
            if(temp2 % i == 0 && b % i == 0) {
                temp = b / i
            } else continue
        }
        while(temp != 1){
            if(temp % 2 == 0){
                temp /= 2
            } else if(temp >= 5 && temp % 5 == 0){
                temp /= 5
            } else {
                break
            }
        }
        if(temp == 1) answer = 1 else answer = 2
        return answer
    }
}

문제명 로그인 성공?
class Solution {
    fun solution(id_pw: Array<String>, db: Array<Array<String>>): String {
        var loginList = mutableListOf<String>()
        db.forEach{
            if(it[0] == id_pw[0]){
                loginList.add("wrong pw")
                if(it[1] == id_pw[1]){
                    loginList.add("login")
                }
            } else loginList.add("fail")
        }
        if(loginList.contains("login")){
            return "login"
        } else if(loginList.contains("wrong pw")){
            return "wrong pw"
        } else return "fail"
        return ""
    }
}

문제명 옹알이(1)
class Solution {
    fun solution(babbling: Array<String>): Int {
        var answer: Int = 0
        val soundList = listOf<String>("aya", "ye", "woo", "ma")
        babbling.forEach{
            var temp = it
            for(i in 0 .. soundList.size-1){
                temp = temp.replace(soundList[i],"0")
            }
            if(temp.replace("0","") == "") answer++
        }
        return answer
    }
}

문제명 컨트롤 제트
class Solution {
    fun solution(s: String): Int {
        var checkList = mutableListOf<Int>()
        s.split(" ").forEach{
            if(it == "Z"){
                if(checkList.isEmpty()){
                    checkList.add(0)
                }
                checkList.remove(checkList.last())
            } else {
                checkList.add(it.toInt())
            }
        }
        return checkList.sum()
    }
}

문제명 문자열 밀기
class Solution {
    fun solution(A: String, B: String): Int {
        var answer: Int = -1
        var temp = A
        if(A == B) return 0
        for(i in 0 .. A.length){
            temp = temp[temp.length-1] + temp.slice(0 .. temp.length-2)
            if(temp == B) {
                answer = i+1
                break
            }
        }
        return answer
    }
}

문제명 등수 매기기
class Solution {
    fun solution(score: Array<IntArray>): IntArray {
        var answer: IntArray = intArrayOf()
        var aveList = mutableListOf<Double>()
        
        score.forEach{
            aveList.add( (it[0]+it[1]).toDouble() / 2.0 )
        }
        
        aveList.sortDescending()
        
        score.forEach{
            answer += aveList.indexOf( (it[0]+it[1]).toDouble() / 2.0 ) + 1 
        }
        
        return answer
    }
}

문제명 치킨 쿠폰
class Solution {
    fun solution(chicken: Int): Int {
        var answer: Int = 0
        var cupon = chicken
        var tempCupon = 0
        while(cupon >= 10){
            answer += cupon/10
            cupon = cupon/10 + cupon%10
        }
        return answer
    }
}

문제명 특이한 정렬
class Solution {
    fun solution(numlist: IntArray, n: Int): IntArray {
        var answer: IntArray = intArrayOf()
        if(numlist.contains(n)) answer += n
        var plusCount = 1
        var minCount = 1
        while(answer.size != numlist.size){
            if(numlist.contains(n + plusCount) && n + plusCount < 10001){
                answer += n + plusCount
            }
            if(numlist.contains(n - minCount) && n - minCount > 0){
                answer += n - minCount
            }
            plusCount++
            minCount++
        }
        return answer
    }
}
//상기 코드의 경우 범위가 크지 않아 매우 무식한 방법으로 해결해 보았습니다.

문제명 저주의 숫자 3
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        for(i in 1 .. n){
            answer++
            while(answer.toString().contains("3") == true || answer % 3 == 0){
                answer++
            }
        }
        return answer
    }
}

문제명 최빈값 구하기
class Solution {
    fun solution(array: IntArray): Int {
        var answer: Int = 0
        val countList = array.toSet()
        var maxCheckMap = mutableMapOf<Int,Int>()
        countList.forEach{
            maxCheckMap.put(it,array.count{e -> e == it})
        }
        val maxValue = maxCheckMap.values.toList().maxOrNull()!!
        if(maxCheckMap.values.toList().count{e -> e == maxValue} != 1) {
            answer = -1
        } else {
            maxCheckMap.forEach{
                if(it.value == maxValue) answer = it.key
            }
        }
        return answer
    }
}

문제명 다음에 올 숫자
class Solution {
    fun solution(common: IntArray): Int {
        var answer: Int = 0
        if(common[1]-common[0] == common[2]-common[1]){
            answer = common.last() + (common[1] - common[0])
        } else {
            answer = common.last() * (common[1] / common[0])
        }
        return answer
    }
}

문제명 OX 퀴즈
class Solution {
    fun solution(quiz: Array<String>): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        quiz.forEach{
            if(it.split(" ")[1] == "+"){
                if(it.split(" ")[0].toInt() + it.split(" ")[2].toInt() == it.split(" ")[4].toInt()){
                    answer += "O"
                } else {
                    answer += "X"
                }
            } else {
                if(it.split(" ")[0].toInt() - it.split(" ")[2].toInt() == it.split(" ")[4].toInt()){
                    answer += "O"
                } else {
                    answer += "X"
                }
            }
        }
        
        return answer
    }
}

문제명 다항식 더하기
class Solution {
    fun solution(polynomial: String): String {
        var answer: String = ""
        var xList = mutableListOf<String>()
        var numList = mutableListOf<Int>()
        polynomial.replace("+","").split(" ").forEach{
            if(it.contains("x")){
                xList.add(it)
            } else if(it != ""){
                numList.add(it.toInt())
            }
        }
        var countX = 0
        if(xList.isNotEmpty()){
            xList.forEach{
                countX += if(it.split("x")[0] != "") it.split("x")[0].toInt() else 1
            }
        }
        if(countX != 0){
            if(countX == 1){
                answer += "x"
            } else{
                answer += countX.toString()+"x"
            }   
        } 
        var num = numList.sum()
        if(num != 0){
            if(answer.contains("x")){
                answer +=" + "
            }
            answer += num.toString()
        }
        return answer
    }
}

문제명 분수의 덧셈
class Solution {
    fun solution(denum1: Int, num1: Int, denum2: Int, num2: Int): IntArray {
        var answer1 = (denum1*num2) + (num1*denum2) //분자
        var answer2 = num1*num2 //분모
        var answer : IntArray = intArrayOf(answer1,answer2)
        val check = if(answer1 >= answer2) answer2 else answer1
        for(i in 2 .. check){
            if(answer1 % i == 0 && answer2 % i == 0){
                answer[0] = answer1/i
                answer[1] = answer2/i
            }
        }        
        return answer
    }
}

문제명 연속된 수의 합
class Solution {
    fun solution(num: Int, total: Int): IntArray {
        var answer = mutableListOf<Int>()
        var start = (total/num) - (num/2) -1
        var check = 0
        while(true){
            for(i in 0 .. num-1){
                check += (start + i)
            }
            if(check == total){
                for(i in 0 .. num-1){
                    answer += (start + i)
                }
                break
            } else {
                check = 0
                start++
            }
        }
        return answer.toIntArray()
    }
}

문제명 안전지대
class Solution {
    fun solution(board: Array<IntArray>): Int {
        var answer: Int = 0
        var checkList = mutableListOf<IntArray>()
        checkList.add(IntArray(board.size+2,{2}))
        board.forEach{
            val tempIntArray = IntArray(1,{2}) + it + IntArray(1,{2})
            checkList.add(tempIntArray)
        }
        checkList.add(IntArray(board.size+2,{2}))
        for(i in 1 .. board.size){
            for(j in 1 .. board.size){
                if(board[i-1][j-1] != 1) {
                    continue
                } else {
                    if(checkList[i-1][j-1] != 1) checkList[i-1][j-1] =2
                    if(checkList[i-1][j] != 1) checkList[i-1][j] = 2
                    if(checkList[i-1][j+1] != 1) checkList[i-1][j+1] = 2
                    if(checkList[i][j-1] != 1) checkList[i][j-1] = 2
                    if(checkList[i][j+1] != 1) checkList[i][j+1] = 2
                    if(checkList[i+1][j-1] != 1) checkList[i+1][j-1] = 2
                    if(checkList[i+1][j] != 1) checkList[i+1][j] = 2
                    if(checkList[i+1][j+1] != 1) checkList[i+1][j+1] = 2
                }
            }
        }
        checkList.forEach{
            answer += it.count{ e -> e == 0}
        }
        return answer
    }
}

// 해당 문제는 비유하자면 색종이의 변마다 줄을 추가하여 index 오류를 해결함과 동시에
// 편하게 코드를 작성 및 이해를 쉽게 할 수 있도록 하였습니다.(필자 피셜)

 
2023.04.21 추가 문제

// 문제명: 정수 부분
class Solution {
    fun solution(flo: Double) = flo.toInt()
}

// 문제명: 문자열 출력하기
fun main(args: Array<String>) {
    val s1 = readLine()!!
    print(s1)
}

// 문제명 a와 b 출력하기
fun main(args: Array<String>) {
    val (a, b) = readLine()!!.split(' ').map(String::toInt)
    println("a = $a")
    println("b = $b")
}

// 문자열 반복해서 출력하기
fun main(args: Array<String>) {
	val input = readLine()!!.split(' ')
    val s1 = input[0]
    val a = input[1]!!.toInt()
    repeat(a){
        print(s1)
    }
}

// 문제명 대소문자 바꿔서 출력하기
fun main(args: Array<String>) {
    val s1 = readLine()!!
    var temp = ""
    s1.forEach{
        if(it in ('A'..'Z')) temp += it.toLowerCase()
        else temp += it.toUpperCase()
    }
    print(temp)
}

// 문제명 특수문자 출력하기

fun main(args: Array<String>) { // 무식한 방법이지만....ㅋㅋㅋㅋ
   print(Char(33)) // !
   print(Char(64)) // @
   print(Char(35)) // #
   print(Char(36)) // $
   print(Char(37)) // %
   print(Char(94)) // ^
   print(Char(38)) // &
   print(Char(42)) // *
   print(Char(40)) // (
   print(Char(92)) // \
   print(Char(39)) // '
   print(Char(34)) // "
   print(Char(60)) // <
   print(Char(62)) // >
   print(Char(63)) // ?
   print(Char(58)) // :
   print(Char(59)) // ;
}

// 혹은
fun main(args: Array<String>) {
    println("!@#$%^&*(\\'\"<>?:;")
}

//문제명 덧셈식 출력하기
fun main(args: Array<String>) {
    val (a, b) = readLine()!!.split(' ').map(String::toInt)
    println("$a + $b = ${a+b}")
}

//문제명: 문자열 붙여서 출력하기
fun main(args: Array<String>) {
		val input = readLine()!!.split(' ')
    val s1 = input[0]
    val s2 = input[1]
    print(s1+s2)
}

//문제명 문자열 돌리기
fun main(args: Array<String>) {
    val s1 = readLine()!!
    s1.forEach{
        println(it)
    }
}

// 문제명 홀짝 구분하기
fun main(args: Array<String>) {
    val a = readLine()!!.toInt()
    if(a%2 == 0) {
        print("$a is even")
    } else {
         print("$a is odd")
    }
}

//문제명 문자열 겹쳐쓰기
class Solution {
    fun solution(my_string: String, overwrite_string: String, s: Int): String {
        var answer: String = ""
        var end = s+overwrite_string.length-1
        var start = 0
        for(i in 0 .. my_string.length-1){
            if(i in (s .. end)){
                answer += overwrite_string[start].toString()
                start++
            } else {
                answer += my_string[i].toString()
            }
            
        }
        return answer
    }
}

// 문제명 문자열 섞기
class Solution {
    fun solution(str1: String, str2: String): String {
        var answer: String = ""
        for(i in 0 .. str1.length-1){
            answer += str1[i].toString()
            answer += str2[i].toString()
        }
        return answer
    }
}

//문제명 문자 리스트를 문자열로 변환하기
class Solution {
    fun solution(arr: Array<String>): String {
        var answer: String = arr.joinToString("")
        return answer
    }
}

// 문제명 문자열 곱하기
class Solution {
    fun solution(my_string: String, k: Int): String {
        var answer: String = ""
        repeat(k){
            answer += my_string
        }
        return answer
    }
}

//문제명 더 크게 합치기
class Solution {
    fun solution(a: Int, b: Int): Int {
        var answer: Int = 0
        val ab = a.toString()+b.toString()
        val ba = b.toString()+a.toString()
        if(ab.toInt() > ba.toInt()) answer = ab.toInt()
        else answer = ba.toInt()
        return answer
    }
}

// 문제명 두 수의 연산값 비교하기
class Solution {
    fun solution(a: Int, b: Int): Int {
        val ab = (a.toString()+b.toString()).toInt()
        val twoab = 2*a*b
        return Math.max(ab,twoab)
    }
}

// 문제명 n의 배수
class Solution {
    fun solution(num: Int, n: Int) = if(num%n == 0) 1 else 0
}

// 문제명 공배수
class Solution {
    fun solution(number: Int, n: Int, m: Int):Int 
    = if(number%n == 0 && number%m == 0) 1 else 0
}

// 문제명 홀짝에 따라 다른 값 반환하기
class Solution {
    fun solution(n: Int): Int {
        var answer: Int = 0
        when(n%2){
            0 -> {
                for(i in 2 .. n step 2){
                    answer += i*i
                }
            }
            1 -> {
                for(i in 1 .. n step 2){
                    answer += i
                }
            }
        }
        return answer
    }
}

// 문제명 조건 문자열
class Solution {
    fun solution(ineq: String, eq: String, n: Int, m: Int): Int {
        var answer: Int = 0
        
        when(ineq){
            ">" -> {
                if(n > m) answer += 1
            }
            "<" -> {
                if(n < m) answer += 1
            }
        }
        
        when(eq){
            "!" -> {
                if(n == m) answer *= 0
            }
            "=" -> {
                if(n == m) {
                    if(answer == 0 )answer += 1
                    answer *= 1
                }
            }
        }
        
        return answer
    }
}

// 문제명 flag에 따라 다른 값 반환하기
class Solution {
    fun solution(a: Int, b: Int, flag: Boolean): Int = if(flag)a+b else a-b
}

// 문제명 코드 처리하기
class Solution {
    fun solution(code: String): String {
        var answer: String = ""
        var mode = true // true는 모드 0
        for(i in 0 .. code.length-1){
            if(code[i] == '1') {
                mode = !mode
                continue
            }
            if(mode){ // 모드 0
                if(i%2 == 0) answer += code[i].toString()
            }else { // 모드 1
                if(i%2 == 1) answer += code[i].toString()
            }
        }
        if(answer == "") answer += "EMPTY"
        return answer
    }
}

//문제명 등차수열의 특정한 항만 더하기
class Solution {
    fun solution(a: Int, d: Int, included: BooleanArray): Int {
        var answer: Int = 0
        var num = a-d
        included.forEach{
            num += d
            if(it) answer += num
        }
        return answer
    }
}

// 문제명 주사위 게임2
class Solution {
    fun solution(a: Int, b: Int, c: Int): Int {
        var answer: Int = 0
        var arr = IntArray(7){0}
        arr[a]++
        arr[b]++
        arr[c]++
        
        var count = arr.maxOrNull()!!
        when(count){
            1 ->{
                answer += (a+b+c)
            }
            2 ->{
                answer += (a+b+c) * ((a*a) + (b*b) + (c*c)) 
            }
            3 ->{
                answer += (a+b+c) * ((a*a) + (b*b) + (c*c)) * ((a*a*a) + (b*b*b) + (c*c*c))
            }
        }
        
        return answer
    }
}

// 문제명 원소들의 곱과 합
class Solution {
    fun solution(num_list: IntArray): Int {
        var answer: Int = 0
        var num1 = 1
        var num2 = 0
        num_list.forEach{
            num1 *= it
            num2 += it
        }
        num2 *= num2
        if(num1 < num2) answer = 1
        return answer
    }
}

// 문제명 이어 붙인 수
class Solution {
    fun solution(num_list: IntArray): Int {
        var answer: Int = 0
        var num1 = ""
        var num2 = ""
        num_list.forEach{
            if(it % 2 == 0){
                num2 += it.toString()
            } else {
                num1 += it.toString()
            }
        }
        answer = num1.toInt() + num2.toInt()
        return answer
    }
}

// 문제명 마지막 두 원소
class Solution {
    fun solution(num_list: IntArray): IntArray {
        var answer = IntArray(num_list.size+1){0}
        if(num_list[num_list.size-1] > num_list[num_list.size-2]){
            answer[num_list.size] = num_list[num_list.size-1] - num_list[num_list.size-2]
        } else {
            answer[num_list.size] = num_list[num_list.size-1]*2
        }
        for(i in 0 .. num_list.size-1){
            answer[i] = num_list[i]
        }
        return answer
    }
}

// 문제명 수 조작하기1
class Solution {
    fun solution(n: Int, control: String): Int {
        var answer: Int = n
        control.forEach{
            when(it){
                'w' ->{
                    answer++
                }
                's' ->{
                    answer--
                }
                'd' ->{
                    answer += 10
                }
                'a' ->{
                    answer -= 10
                }
            }
        }
        return answer
    }
}

// 문제명 수 조작하기2
class Solution {
    fun solution(numLog: IntArray): String {
        var answer: String = ""
        var num: Int = numLog[0]
        
        for(i in 1 .. numLog.size-1){
            if(num - numLog[i] == -1) {
                answer += "w"
                num = numLog[i]
            }
            if(num - numLog[i] == 1) {
                answer += "s"
                num = numLog[i]
            }
            if(num - numLog[i] == -10){
                answer += "d"
                num = numLog[i]
            } 
            if(num - numLog[i] == 10){
                answer += "a"
                num = numLog[i]
            } 
        }
        
        return answer
    }
}

// 문제명 수열과 구간 쿼리3
class Solution {
    fun solution(arr: IntArray, queries: Array<IntArray>): IntArray {
        var answer = arr
        queries.forEach {
            var temp = answer[it[0]]
            answer[it[0]] = answer[it[1]]
            answer[it[1]] = temp
        }
        return answer
    }

}

// 문제명 수열과 구간 쿼리 2
class Solution {
    fun solution(arr: IntArray, queries: Array<IntArray>): IntArray {
        var answer: IntArray = intArrayOf()
        queries.forEach{
            var temp = arr.sliceArray(it[0] .. it[1]).sortedArray()
            var num = -1
            for(i in 0 .. temp.size-1){
                if(temp[i] > it[2]){
                    num = temp[i]
                    break
                }
            }
            answer += num
        }
        return answer
    }
}

// 문제명 수열과 구간 쿼리 4
import java.util.*

class Solution {
    fun solution(arr: IntArray, queries: Array<IntArray>): IntArray {
        var answer = arr
        queries.forEach{
            for(i in 0 .. arr.size-1) {
                if(i in (it[0] .. it[1])){
                    if(i % it[2] == 0 ) answer[i]++
                }
            }
        }
        return answer
    }
}

// 문제명 배열 만들기2
class Solution {
    fun solution(l: Int, r: Int): IntArray {
        var answer = ArrayList<Int>()

        for(i in l .. r){
            if(i % 5 == 0){
                if(i.toString().filter{ e-> e=='5'|| e =='0'}.toInt() == i) answer.add(i)
            }
        }

        if(answer.isEmpty())answer.add(-1)
        
        return answer.toIntArray()
    }
}

// 문제명 카운트 업
class Solution {
    fun solution(start: Int, end: Int): IntArray {
        var answer = IntArray(end+1-start){i: Int -> i+start}
        return answer
    }
}

// 문제명 콜라츠 수열 만들기
class Solution {
    fun solution(n: Int): IntArray {
        var answer = ArrayList<Int>()
        answer.add(n)
        var num = n
        while(num != 1){
            if(num % 2 == 0){
                num /= 2
                answer.add(num)
            } else {
                num = (num * 3)+1
                answer.add(num)
            }
        }
        return answer.toIntArray()
    }
}

// 문제명 배열 만들기 4
class Solution {
    fun solution(arr: IntArray): IntArray {
        var stk = ArrayList<Int>()
        
        var i = 0
        while(i < arr.size){
            if(stk.isEmpty()){
                stk.add(arr[i])
                i++
            } else {
                if(stk.last() < arr[i]){
                    stk.add(arr[i])
                    i++
                } else {
                    stk.removeLast()
                }
            }
        }
        
        return stk.toIntArray()
    }
}

//문제명 간단한 논리 연산
class Solution {
    fun solution(x1: Boolean, x2: Boolean, x3: Boolean, x4: Boolean): Boolean {
        var answer: Boolean = up(down(x1,x2),down(x3,x4))
        return answer
    }
    
    fun up(a: Boolean, b: Boolean):Boolean{ // 꺽인 부분이 위
        if(a && b)return true
        return false
    }
    fun down(a: Boolean, b: Boolean):Boolean{ // 꺽인 부분이 아래
        if(!a && !b )return false
        return true
    }
    
}

// 혹은
class Solution {
    fun solution(x1: Boolean, x2: Boolean, x3: Boolean, x4: Boolean): Boolean {
        return (x1 || x2) && (x3 || x4)
    }
}

// 문제명 주사위 게임3
import java.lang.Math.abs

class Solution {
    fun solution(a: Int, b: Int, c: Int, d: Int): Int {
        var answer: Int = 0
        var arr = IntArray(7){0}
        arr[a]++
        arr[b]++
        arr[c]++
        arr[d]++
        var max = arr.maxOrNull()

        when(max){

            4 -> answer = 1111*a
            3 -> {
                val p = arr.indexOf(3)
                val q = arr.indexOf(1)
                answer = ((10*p)+q) * ((10*p)+q)
            }

            2 -> {
                var p = 0
                var q = 0
                for(i in 1 .. arr.size-1){
                    if(arr[i] == 2){
                        if(p == 0) p = i
                        else q = i
                    }
                }
                if(q != 0) answer = (p+q) * abs(p-q)
                
                else {
                    var r = 0
                    for(i in 1 .. arr.size-1){
                        if(arr[i] == 1){
                            if(q == 0 )q = i
                            else r = i
                        }
                    }
                    answer = q*r
                }
            }

            1 -> {
                answer = 0
                for(i in 1 .. arr.size-1){
                    if(arr[i] != 0) {
                        answer = i
                        break
                    }
                }
            }

        }

        return answer
    }
}

// 문제명 글자 이어 붙여 문자열 만들기
class Solution {
    fun solution(my_string: String, index_list: IntArray): String {
        var answer: String = ""
        index_list.forEach{
            answer += my_string[it]
        }
        return answer
    }
}

// 문제명 9로 나눈 나머지

class Solution {
    fun solution(number: String): Int {
        var answer: Int = 0
        number.forEach{
            answer += it.toInt()-48
        }
        return answer%9
    }
}

// 문제명 문자열 여러 번 뒤집기
class Solution {
    fun solution(my_string: String, queries: Array<IntArray>): String {
        var answer: String = my_string

        queries.forEach{
            val s = it[0]
            val e = it[1]
            answer = answer.substring(0 .. s-1) + answer.substring(s .. e).reversed() +  answer.substring(e+1 .. answer.length-1)
        }

        return answer
    }
}

// 문제명 배열 만들기5
class Solution {
    fun solution(intStrs: Array<String>, k: Int, s: Int, l: Int): IntArray {
        var answer: IntArray = intArrayOf()
        intStrs.forEach{
            if(it.substring(s .. s+l-1).toInt() > k) answer += it.substring(s .. s+l-1).toInt()
        }
        return answer
    }
}

// 문제명 부분 문자열 이 붙여 문자열 만들기
class Solution {
    fun solution(my_strings: Array<String>, parts: Array<IntArray>): String {
        var answer: String = ""
        for(i in 0 .. my_strings.size-1){
            answer += my_strings[i].substring(parts[i][0] .. parts[i][1])
        }
        return answer
    }
}

// 문제명 문자열의 뒤의 n글자
class Solution {
    fun solution(my_string: String, n: Int): String {
        var answer = my_string.substring(my_string.length-n,my_string.length)
        return answer
    }
}

//문제명 접미사 배열
class Solution {
    fun solution(my_string: String): Array<String> {
        var answer = ArrayList<String>()
        for(i in 0 .. my_string.length-1){
            answer.add(my_string.substring(i,my_string.length))
        }
        answer.sort()
        return answer.toTypedArray()
    }
}

// 문제명 접미사인지 확인하기
class Solution {
    fun solution(my_string: String, is_suffix: String): Int {
        var answer: Int = 0
        var temp = ArrayList<String>()
        for(i in 0 .. my_string.length-1){
            temp.add(my_string.substring(i,my_string.length))
        }
        if(temp.contains(is_suffix)) answer = 1
        return answer
    }
}

//문제명 문자열의 앞의 n글자
class Solution {
    fun solution(my_string: String, n: Int): String {
        var answer: String = my_string.substring(0,n)
        return answer
    }
}

//문제명 접두사인지 확인하기
class Solution {
    fun solution(my_string: String, is_prefix: String): Int {
        var answer: Int = 0
        var check = ""
        my_string.forEach{
            check += it.toString()
            if(is_prefix == check) answer = 1
        }
        return answer
    }
}

//문제명 문자열 뒤집기
class Solution {
    fun solution(my_string: String, s: Int, e: Int): String {
        var answer: String = my_string.substring(0,s)
        answer += my_string.substring(s .. e).reversed()
        answer += my_string.substring(e+1,my_string.length)

        return answer
    }
}

// 문제명 세로 읽기
class Solution {
    fun solution(my_string: String, m: Int, c: Int): String {
        var answer: String = ""
        var temp = ""
        for(i in 0 .. my_string.length-1){
            temp += my_string[i].toString()
            if(temp.length == m){
                answer += temp[c-1].toString()
                temp = ""
            }
        }
        return answer
    }
}

// 문제명 qr code
class Solution {
    fun solution(q: Int, r: Int, code: String): String {
        var answer: String = ""
        
        for(i in 0 .. code.length-1){
            if(i % q == r) answer += code[i].toString()
        }
        
        return answer
    }
}

// 문제명 문자 개수 세기
class Solution {
    fun solution(my_string: String): IntArray {
        var answer = IntArray(52){0}
        my_string.forEach{
            if(it in ('A' .. 'Z')) answer[it.toInt()-65]++
            else {
                answer[it.toInt()-71]++
            }
        }
        return answer
    }
}

// 문제명 배열 만들기1
class Solution {
    fun solution(n: Int, k: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in k .. n step k){
            answer += i
        }
        return answer
    }
}

//문제명 글자 지우기
class Solution {
    fun solution(my_string: String, indices: IntArray): String {
        var answer: String = ""
        for(i in 0 .. my_string.length-1){
            if(indices.contains(i))continue
            answer += my_string[i]
        }
        return answer
    }
}

//문제명 카운트 다운
class Solution {
    fun solution(start: Int, end: Int) = IntArray(start-end+1){i: Int -> start-i}
}

//문제명 가까운 1 찾기
class Solution {
    fun solution(arr: IntArray, idx: Int): Int {
        var answer: Int = -1
        for(i in idx .. arr.size-1){
            if(arr[i] == 1){
                answer = i
                break
            }
        }
        return answer
    }
}

// 문제명 리스트 자르기
class Solution {
    fun solution(n: Int, slicer: IntArray, num_list: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        when(n){
            1 -> {
                answer = num_list.sliceArray(0 .. slicer[1])
            }
            2 -> {
                answer = num_list.sliceArray(slicer[0] .. num_list.size-1)
            }
            3 -> {
                answer = num_list.sliceArray(slicer[0] .. slicer[1])
            }
            4 -> {
               for(i in slicer[0] .. slicer[1] step slicer[2]){
                    answer += num_list[i]
                }
            }
        }
        return answer
    }
}

// 문제명 첫 번째로 나오는 음수
class Solution {
    fun solution(num_list: IntArray): Int {
        var answer: Int = -1
        for(i in 0 .. num_list.size-1){
            if(num_list[i] < 0){
                answer = i
                break
            }
        }
        return answer
    }
}

// 문제명 배열 만들기3
class Solution {
    fun solution(arr: IntArray, intervals: Array<IntArray>): IntArray {
        var answer: IntArray = intArrayOf()
        intervals.forEach{
            for(i in it[0] .. it[1]){
                answer += arr[i]
            }
        }
        return answer
    }
}

//문제명 2의 영역
class Solution {
    fun solution(arr: IntArray): IntArray {
        var answer = ArrayList<Int>()
        var temp = ArrayList<Int>()
        for(i in 0 .. arr.size-1){
            if(arr[i] == 2) temp.add(i)
        }
        if(temp.isEmpty()) return intArrayOf(-1)
        if(temp.size == 1) return intArrayOf(2)

        val start = temp.first()
        val end = temp.last()

        for(i in start .. end){
            answer.add(arr[i])
        }

        return answer.toIntArray()
    }
}

//문제명 전국 대회 선발 고사
import java.util.PriorityQueue

class Solution {
    fun solution(rank: IntArray, attendance: BooleanArray): Int {
        var answer: Int = 0
        var pq = PriorityQueue<Info>(Comparator { o1, o2 -> o1.ranking.compareTo(o2.ranking)})
        for(i in 0 .. rank.size-1){
            if(attendance[i]){
                pq.add(Info(i,rank[i]))
            }
        }
        
        answer = (pq.poll().num*10000) + (pq.poll().num*100) + pq.poll().num
        
        return answer
    }
    data class Info(
        val num:Int,
        var ranking:Int
    )
}

----------------------------------------------------------------------04/25 추가

//문제명 n 번째 원소부터
class Solution {
    fun solution(num_list: IntArray, n: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in n-1 .. num_list.size-1){
            answer += num_list[i]
        }
        return answer
    }
}

// 문제명 순서 바꾸기
class Solution {
    fun solution(num_list: IntArray, n: Int): IntArray {
        var answer = num_list.slice(n .. num_list.size-1)+num_list.slice(0 .. n-1)
        return answer.toIntArray()
    }
}

// 또는
class Solution {
    fun solution(num_list: IntArray, n: Int): IntArray {
        var answer = intArrayOf()
        for(i in n .. num_list.size-1){
            answer += num_list[i]
        }
        for(i in 0 .. n-1){
            answer += num_list[i]
        }
        return answer
    }
}

// 문제명 왼쪽 오른쪽
class Solution {
    fun solution(str_list: Array<String>): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        var left = str_list.size
        var right = str_list.size

        for(i in 0 .. str_list.size-1){
            if(str_list[i] == "l"){
                left = i
                break
            }
            if(str_list[i] == "r"){
                right = i
                break
            }
        }

        if(left == 0 || right == str_list.size-1) return answer
        if(left == str_list.size && right == str_list.size) return answer
        
        if(left > right){
            for(i in right+1 .. str_list.size-1){
                answer += str_list[i]
            }
        } else {
            for(i in 0 .. left-1){
                answer += str_list[i]
            }
        }

        return answer
    }
}

// 문제명 n 번째 원소까지
class Solution {
    fun solution(num_list: IntArray, n: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in 0 .. n-1){
            answer += num_list[i]
        }
        return answer
    }
}

// 문제명 n개 간격의 원소들
class Solution {
    fun solution(num_list: IntArray, n: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in 0 .. num_list.size-1 step n){
            answer += num_list[i]
        }
        return answer
    }
}

// 문제명 홀수 vs 짝수
class Solution {
    fun solution(num_list: IntArray): Int {
        var odd = 0
        var even = 0
        var swicth = true
        num_list.forEach{
            if(swicth) {
                odd += it
                swicth = !swicth
            } else {
                even += it
                swicth = !swicth
            }
        }
        return Math.max(odd,even)
    }
}

// 문제명 5명씩
class Solution {
    fun solution(names: Array<String>): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        for(i in 0 .. names.size-1 step 5){
            answer += names[i]
        }
        return answer
    }
}

// 문제명 할 일 목록
class Solution {
    fun solution(todo_list: Array<String>, finished: BooleanArray): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        for(i in 0 .. todo_list.size-1){
            if(!finished[i]) answer += todo_list[i]
        }
        return answer
    }
}

// 문제명 n보다 커질 때 까지
class Solution {
    fun solution(numbers: IntArray, n: Int): Int {
        var answer: Int = 0
        var index = 0
        while(answer <= n){
            answer += numbers[index]
            index++
        }
        return answer
    }
}

//문제명 수열과 구간 쿼리1
class Solution {
    fun solution(arr: IntArray, queries: Array<IntArray>): IntArray {
        var answer = arr
        queries.forEach{
            for(i in it[0] .. it[1]){
                answer[i]++ 
            }
        }
        return answer
    }
}

// 문제명 조건에 맞게 수열 변환하기1
class Solution {
    fun solution(arr: IntArray): IntArray {
        var answer = ArrayList<Int>()
        arr.forEach{
            if(it >= 50 && it%2 == 0) answer.add(it/2)
            else if(it < 50 && it%2 == 1) answer.add(it*2)
            else answer.add(it)
        }
        return answer.toIntArray()
    }
}

//문제명 조건에 맞게 수열 변환하기 2
class Solution {
    fun solution(arr: IntArray): Int {
        var answer: Int = 0
        var temp1 = arr
        var temp2 = arrmake(arr)
        while(!temp1.contentEquals(temp2)){
            answer++
            temp1 = arrmake(temp1)
            temp2 = arrmake(temp2)
        }
        return answer
    }

    fun arrmake(arr: IntArray):IntArray{
        var result = IntArray(arr.size){0}
        for(i in 0 .. arr.size-1){
            if(arr[i] >= 50 && arr[i]%2 == 0) result[i] = arr[i]/2
            else if(arr[i] < 50 && arr[i]%2 == 1) result[i] = (arr[i]*2)+1
            else result[i] = arr[i]
        }
        return result
    }

}

// 문제명 1로 만들기
class Solution {
    fun solution(num_list: IntArray): Int {
        var answer: Int = 0
        for(i in num_list){
            var num = i
            while(num != 1){
                answer++
                if(num % 2 == 0) num/=2
                else num = (num-1)/2
            }
        }
        return answer
    }
}

// 문제명 길이에 따른 연산
class Solution {
    fun solution(num_list: IntArray): Int {
        var answer: Int = 0
        when(num_list.size){
            in(11 .. 20) -> {
                answer = num_list.sum()
            }
            else -> {
                var num = 1
                for(i in num_list){
                    num *= i
                }
                answer =num
            }
        }
        return answer
    }
}

//문제명 원하는 문자열 찾기
class Solution {
    fun solution(myString: String, pat: String): Int {
        var answer: Int = 0
        if(myString.lowercase().contains(pat.lowercase())) answer = 1
        return answer
    }
}

//문제명 대문자로 바꾸기
class Solution {
    fun solution(myString: String): String {
        var answer: String = myString.uppercase()
        return answer
    }
}

//문제명 소문자로 바꾸기
class Solution {
    fun solution(myString: String): String {
        var answer: String = myString.lowercase()
        return answer
    }
}

//문제명 배열에서 문자열 대소문자 변환하기
class Solution {
    fun solution(strArr: Array<String>): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        for(i in 0 .. strArr.size-1){
            if(i % 2 == 0) answer += strArr[i].lowercase()
            else answer += strArr[i].uppercase()
        }
        return answer
    }
}

//문제명 A 강조하기
class Solution {
    fun solution(myString: String): String {
        var answer: String = ""
        for(i in 0 .. myString.length-1){
            if(myString[i] == 'a') answer += "A"
            else if(myString[i] in ('B' .. 'Z')) answer += myString[i].lowercase()
            else answer += myString[i]
        }
        return answer
    }
}

//문제명 특정한 문자를 대문자로 바꾸기
class Solution {
    fun solution(my_string: String, alp: String): String {
        var answer: String = my_string.replace(alp,alp.uppercase())
        return answer
    }
}

//문제명 특정 문자열로 끝나는 가장 긴 부분 문자열 찾기
class Solution {
    fun solution(myString: String, pat: String): String {
        var index = myString.lastIndexOf(pat) + pat.length-1
        var answer: String = myString.slice(0 .. index)
        return answer
    }
}

//문제명: 문자열이 몇 번 등장하는지 세기
class Solution {
    fun solution(myString: String, pat: String): Int {
        var answer: Int = 0
        var arr1 = myString.toCharArray()
        var arr2 = pat.toCharArray()

        for(i in 0 .. arr1.size-arr2.size){
            var check = arr1.sliceArray(i .. i+arr2.size-1)
            if(check.contentEquals(arr2))answer++
        }

        return answer
    }
}

// 문제명 ad 제거하기
class Solution {
    fun solution(strArr: Array<String>): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        strArr.forEach{
            if(!it.contains("ad")) answer += it
        }
        return answer
    }
}

// 문제명 공백으로 구분하기 1
class Solution {
    fun solution(my_string: String): Array<String> {
        var answer = my_string.split(" ").toTypedArray()
        return answer
    }
}

// 문제명 공백으로 구분하기2
class Solution {
    fun solution(my_string: String): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        my_string.split(" ").forEach {
            if(it != " " && it != "")answer += it
        }
        return answer
    }
}

// 문제명 x 사이의 개수
class Solution {
    fun solution(myString: String): IntArray {
        var answer: IntArray = intArrayOf()
        var count = 0
        myString.forEach{
            if(it != 'x'){
                count++
            } else {
                answer += count
                count = 0
            }
        }
        answer += count
        return answer
    }
}

// 문제명 문자열 잘라서 정렬하기
class Solution {
    fun solution(my_string: String): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        my_string.split("x").forEach {
           if(!it.isBlank())answer += it
        }

        return answer.sortedArray()
    }
}

// 문제명 간단한 식 계산하기
class Solution {
    fun solution(binomial: String): Int {
        var answer: Int = 0
        val bin =  binomial.split(" ")
        val a = bin[0].toInt()
        val op = bin[1]
        val b = bin[2].toInt()
        if(op == "*"){
            answer = a * b
        } else if(op == "+"){
            answer = a + b
        } else {
            answer = a - b
        }
        return answer
    }
}

// 문제명 문자열 바꿔서 찾기
class Solution {
    fun solution(myString: String, pat: String): Int {
        var answer: Int = 0
        var change = ""
        myString.forEach{
            if(it == 'A') change += "B"
            else change += "A"
        }
        if(change.contains(pat)) answer = 1
        else answer = 0
        return answer
    }
}

// 문제명 rny_string
class Solution {
    fun solution(rny_string: String) = rny_string.replace("m","rn")
}

// 문제명 세 개의 구분자

class Solution {
    fun solution(myStr: String): Array<String> {
        var answer: Array<String> = arrayOf<String>()
        var temp = ""
        for(i in 0 .. myStr.length-1){
            if (myStr[i] == 'a' || myStr[i] == 'b' || myStr[i] == 'c'){
                if(temp != ""){
                    answer += temp
                    temp = ""
                }
            } else {
                temp += myStr[i]
            }
        }
        if(temp != ""){
            answer += temp
        }
        if(answer.isEmpty()) answer += "EMPTY"
        return answer
    }
}

// 문제명 배열의 원소 만큼 추가하기
class Solution {
    fun solution(arr: IntArray): IntArray {
        var answer: IntArray = intArrayOf()
        arr.forEach{
            val num = it
            repeat(num){
                answer += num
            }
        }
        return answer
    }
}

// 문제명 빈 배열에 추가, 삭제하기
class Solution {
    fun solution(arr: IntArray, flag: BooleanArray): IntArray {
        var answer = ArrayList<Int>()
        for(i in 0 .. flag.size-1){
            if(flag[i]){
                repeat(arr[i]*2){
                    answer.add(arr[i])
                }
            } else {
                repeat(arr[i]){
                    if(!answer.isEmpty()) answer.removeLast()
                }
            }
        }
        return answer.toIntArray()
    }
}

// 문제명 배열 만들기 6
class Solution {
    fun solution(arr: IntArray): IntArray {
        var stk = ArrayList<Int>()
        for(i in 0 .. arr.size-1){
            if(stk.isEmpty()){
                stk += arr[i]
            } else {
                if(stk.last() == arr[i]){
                    stk.removeLast()
                } else {
                    stk.add(arr[i])
                }
            }
        }
        if(stk.isEmpty()) stk.add(-1)
        return stk.toIntArray()
    }
}

// 문제명 무자위로 K개의 수 뽑기
class Solution {
    fun solution(arr: IntArray, k: Int): IntArray {
        var answer: IntArray = intArrayOf()
        for(i in 0 .. arr.distinct().size-1){
            if(answer.size >= k) break
            answer += arr.distinct()[i]
        }
        
        while(answer.size != k){
            answer += -1
        }

        return answer
    }
}

// 문제명 배열의 길이를 2의 거듭제곱으로 만들기
class Solution {
    fun solution(arr: IntArray): IntArray {
        var k = 1
        while(k < arr.size){
            k *= 2
        }
        var answer = IntArray(k){0}
        for(i in 0 .. arr.size-1){
            answer[i] = arr[i]
        }
        return answer
    }
}

// 문제명 배열 비교하기
class Solution {
    fun solution(arr1: IntArray, arr2: IntArray): Int {
        if(arr1.size != arr2.size){
            if(arr1.size > arr2.size) return 1
            else return -1
        } else {
            if(arr1.sum() > arr2.sum()) return 1
            else if(arr1.sum() < arr2.sum()) return -1
            else return 0
        }
        return 0
    }
}

// 문제명 문자역 묶기
import kotlin.math.max

class Solution {
    fun solution(strArr: Array<String>): Int {
        var answer: Int = 0
        var countMap = HashMap<Int,Int>()
        repeat(31) {
            countMap[it] = 0
        }
        strArr.forEach {
            countMap[it.length] = countMap[it.length]!! + 1
            answer = max(answer,countMap[it.length]!!)
        }
        return answer
    }
}

// 문제명 배열의 길이에 따라 다른 연산하기
class Solution {
    fun solution(arr: IntArray, n: Int): IntArray {
        var answer = arr
        if(arr.size % 2 == 1){
            for(i in 0 .. answer.size-1 step 2){
                answer[i] += n
            }
        } else {
            for(i in 1 .. answer.size-1 step 2){
                answer[i] += n
            }
        }
        return answer
    }
}

// 문제명 뒤에서 5등까지
class Solution {
    fun solution(num_list: IntArray): IntArray {
        var answer = IntArray(5){0}
        val arr = num_list.sorted()
        repeat(5){
            answer[it] = arr[it]
        }
        
        return answer
    }
}

// 문제명 뒤에서 5등 위로
class Solution {
    fun solution(num_list: IntArray): IntArray {
        var answer = num_list.sorted().slice(5 .. num_list.size-1).toIntArray()
        return answer
    }
}

// 문제명 문자열 정수의 합
class Solution {
    fun solution(num_str: String): Int {
        var answer: Int = 0
        num_str.forEach{
            answer += it.toInt()-48
        }
        return answer
    }
}

// 문제명 문자열을 정수로 변환하기
class Solution {
    fun solution(n_str: String) = n_str.toInt()
}

// 문제명 0 떼기
class Solution {
    fun solution(n_str: String) = n_str.toInt().toString()
}

// 문제명 두 수의 합
class Solution {
    fun solution(a: String, b: String): String {
        var answer: String = (a.toBigInteger()+b.toBigInteger()).toString()
        return answer
    }
}

// 문제명 문자열로 변환
class Solution {
    fun solution(n: Int) = n.toString()
}

//문제명 배열의 원소 삭제하기
class Solution {
    fun solution(arr: IntArray, delete_list: IntArray): IntArray {
        var answer = arr.toMutableList()
        delete_list.forEach{
            if(answer.contains(it)){
                answer.remove(it)
            }
        }
        return answer.toIntArray()
    }
}

// 문제명 부분 문자열인지 확인하기
class Solution {
    fun solution(my_string: String, target: String): Int {
        var answer: Int = 0
        if(my_string.contains(target)) answer = 1
        return answer
    }
}

//문제명 부분 문자열
class Solution {
    fun solution(str1: String, str2: String): Int {
        var answer: Int = 0
        if(str2.contains(str1)) answer = 1
        return answer
    }
}

// 문제명 꼬리 문자열
class Solution {
    fun solution(str_list: Array<String>, ex: String): String {
        var answer: String = ""
        str_list.forEach{
            if(!it.contains(ex))answer += it
        }
        return answer
    }
}

// 문제명 정수 찾기
class Solution {
    fun solution(num_list: IntArray, n: Int): Int {
        var answer: Int = 0
        if(num_list.contains(n)) answer = 1
        return answer
    }
}

// 문제명 주사위 게임1
import kotlin.math.abs

class Solution {
    fun solution(a: Int, b: Int): Int {
        var answer: Int = 0

        if(a % 2 == 1 && b % 2 == 1){
            answer = a*a + b*b
        } else if(a % 2 == 1 || b % 2 == 1){
            answer = 2 * (a + b)
        } else {
            answer = abs(a-b)
        }

        return answer
    }
}

// 문제명 날짜 비교하기
import java.time.LocalDate

class Solution {
    fun solution(date1: IntArray, date2: IntArray): Int {
        var answer: Int = 0

        var day1 = LocalDate.of(date1[0],date1[1],date1[2])

        var day2 = LocalDate.of(date2[0],date2[1],date2[2])
        
        if(day1 < day2) answer = 1
        
        return answer
    }
}

// 문제명 커피 심부름
class Solution {
    fun solution(order: Array<String>): Int {
        var answer: Int = 0
        order.forEach{
            
            if(it.contains("americano") || it.contains("anything")){
                answer += 4500
            } else {
                answer += 5000
            }
            
        }
        return answer
    }
}

//문제명 그림 확대
class Solution {
    fun solution(picture: Array<String>, k: Int): Array<String> {
        var answer = ArrayList<String>()
        for(i in 0 .. picture.size-1){
            var temp2 = ""
            for(j in 0 .. picture[i].length-1){
                repeat(k){
                    temp2 += picture[i][j]
                }
            }
            repeat(k){
                answer.add(temp2)
            }
        }

        return answer.toTypedArray()
    }
}

// 문제명 조건에 맞게 수열 변환하기 3
class Solution {
    fun solution(arr: IntArray, k: Int): IntArray {
        var answer = IntArray(arr.size){i: Int -> if(k % 2 == 0) arr[i]+k else arr[i]*k}
        return answer
    }
}

// 문제명 ㅣ로 만들기
class Solution {
    fun solution(myString: String): String {
        var answer: String = ""
        myString.forEach{
            if(it < 'l') answer += "l"
            else answer += it
        }
        return answer
    }
}

// 문제명 특별한 이차원 배열1
class Solution {
    fun solution(n: Int): Array<IntArray> {
        var answer = Array(n,{IntArray(n){0}})
        for(i in 0 .. n-1){
            for(j in 0 .. n-1){
                if(i == j) answer[i][j] = 1
            }
        }
        return answer
    }
}

// 문제명 특별한 이차원 배열2
class Solution {
    fun solution(arr: Array<IntArray>): Int {
        var answer: Int = 1
        for(i in 0 .. arr.size-1){
            for(j in 0 .. arr[i].size-1){
                if(arr[i][j] != arr[j][i]) {
                    answer = 0
                    break
                }
            }
        }
        return answer
    }
}

// 문제명 정사각형으로 만들기
class Solution {
    fun solution(arr: Array<IntArray>): Array<IntArray> {
        var answer = mutableListOf<IntArray>()
        
        val row = arr.size
        val col = arr[0].size
        
        if(row == col) return arr
        
        if(row > col){ // 1번 케이스
            // 0을 더한다.
            for(i in 0 .. arr.size-1){
                var temp = arr[i]
                for(i in 1 .. row-col){
                    temp += 0
                }
                answer.add(temp)
            }
        } else { // 2번 케이스
            arr.forEach{
                answer.add(it)
            }
            for(i in 1 .. col-row){
                answer.add(IntArray(col){0})
            }
        }
        
        return answer.toTypedArray()
    }
}