코틀린 코테

reduce

class Solution {
    fun solution(num_list: IntArray): Int {
        val product = num_list.reduce { a, b -> a * b } // 원소들의 곱 계산
        val sum = num_list.reduce { a, b -> a + b}
        // val sum = num_list.sum()
        val squareOfSum = sum * sum // 합의 제곱 계산
    
    return if (product < squareOfSum) 1 else 0
    }
}

 

joinToString

class Solution {
    fun solution(num_list: IntArray): Int {
    
        //리스트 선언
        var even = mutableListOf<String>()
        var odd = mutableListOf<String>()
        
        //문자열로 짝수와 홀수 저장하기 add사용 
        for (i in num_list) {
            if(i % 2 == 0) {
                even.add(i.toString())
            } else {
                odd.add(i.toString())
            }
        }
        
        // 기준으로 문자열을 합친 후, Int로 변환하기
        val oddNumber = odd.joinToString("").toInt()
        val evenNumber = even.joinToString("").toInt()
        return oddNumber + evenNumber
    }
}

 

filter

arrayList.filter { it % 2 == 0 }

 

forEach , when

class Solution {
    fun solution(n: Int, control: String): Int {

        var answer = n

        control.forEach { 
            when(it){
                'w' -> answer += 1
                's' -> answer -= 1
                'd' -> answer += 10
                'a' -> answer -= 10
            }
        }

        return answer
    }
}

 

map

val numbers = arrayOf(1, 2, 3, 4, 5)
val squaredNumbers = numbers.map { it * it }
println(squaredNumbers) // 출력: [1, 4, 9, 16, 25]

 

slice

val list = listOf(1, 2, 3, 4, 5)
val sliced = list.slice(1..3)
println(sliced) // 출력: [2, 3, 4]

 

filter

val list = listOf(1, 2, 3, 4, 5)
val filtered = list.filter { it%2 == 0}
println(filtered) // 출력: [2, 4]

 

array와 List의 차이

• 배열(Array): 고정 크기의 데이터나 빠른 임의 액세스가 필요한 경우.
• 리스트(List): 크기가 동적으로 변경되거나 데이터에 순차적으로 액세스하는 경우.

var arr = mutableListOf<Int>()

return arr.toIntArray()

 

drop

리스트 또는 배열의 앞쪽에서 지정된 개수만큼의 요소를 제외한 나머지 요소들을 반환한다.

val list = listOf(1, 2, 3, 4, 5)
val result = list.drop(2) // [3, 4, 5]

 

indices

컬렉션의 모든 인덱스를 나타내는 IntRange를 반환합니다. 이는 주로 반복문과 함께 사용되어 컬렉션의 각 요소에 접근하는 데 유용합니다.

val fruits = listOf("apple", "banana", "cherry")

for (i in fruits.indices) {
    println("Fruit at index $i is ${fruits[i]}")
}

 

startsWith, endsWith,contains

class Solution {
    fun solution(my_string: String, is_prefix: String): Int = if (my_string.startsWith(is_prefix)) 1 else 0
}

 

indexOf() , lastIndexOf()

fun main() {
    val str = "Hello, Kotlin"
    
    // 문자 'o'의 첫 번째 위치를 찾음
    println(str.indexOf('o'))  // 출력: 4
    println(str.lastIndexOf('str')) 
}

 

mapIndexed

 

val numbers = listOf(10, 20, 30, 40, 50)
val modifiedNumbers = numbers.mapIndexed { index, value ->
    if (index % 2 == 0) {
        value * 2
    } else {
        value / 2
    }
}

println(modifiedNumbers)
// 출력: [20, 10, 60, 20, 100]

 

chunked

 

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val chunkedList = numbers.chunked(3)
    println(chunkedList)
    // 출력: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
}

 

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val chunkedTransformed = numbers.chunked(3) { chunk ->
        chunk.sum()
    }
    println(chunkedTransformed)
    // 출력: [6, 15, 24, 10]
}

 

fold(0) 누적합 0부터 시작

val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.fold(0) { acc, num -> acc + num }
// sum = 15

 

foldIndex(0)

class Solution {
    fun solution(absolutes: IntArray, signs: BooleanArray): Int {
        return absolutes.foldIndexed(0) { idx, acc, num ->
            acc + if (signs[idx]) num else -num
        }
    }
}

 

toCharArray()

class Solution {
    fun solution(s: String): String {
        var a = s.toCharArray()
        return a.sortedDescending().joinToString("")
    }
}