알고리즘 정리

toInt, toIntOrNull : 정수형 변환

문자열을 정수형으로 변환해주는 함수.
만약 "a123"처럼 정수로 변환해줄 수 없는 문자(a)가 들어있을 경우 toInt는 NumberFormatException를 반환하지만 toIntOrNull는 null을 반환한다.

val s1 = "1234"
val s2 = "a1234"
println(s1.toInt())
println(s1.toIntOrNull())
println(s2.toIntOrNull())
//println(s2.toInt()) //NumberFormatException

1234
1234
null

✊ 숫자로만 구성되어있는지 검사하기 : toIntNull

if(s.toIntOrNull() == null){
    println("숫자가 아닌 것이 포함되어 있음")
    return false
}

숫자로만 구성되어있지 않으면 null을 반환한다

step 숫자 : 증가값 지정

//increaseStep(7)
 
fun increaseStep(n: Int) {
    println("0부터 ${n}까지 2만큼 증가")
    for(i in 0..n step 2)
        println("i: $i")
}

0부터 7까지 2만큼 증가
i: 0
i: 2
i: 4
i: 6

downTo 숫자 : 감소값 지정

//decreaseDownTo(7)

fun decreaseDownTo(n: Int){
    println("${n}부터 2까지 감소")
    for(i in n downTo 2)
        println("i: $i")
    println("-----------------------")

    println("${n}부터 2까지 2만큼 감소")
    for(i in 6 downTo 2 step 2)
        println("i: $i")
}

7부터 2까지 감소
i: 7
i: 6
i: 5
i: 4
i: 3
i: 2
-----------------------
7부터 2까지 2만큼 감소
i: 6
i: 4
i: 2

✊ 짝수 합 더하기 : step(2)

//evenOrOddSum(6)

fun evenOrOddSum(n: Int){
    println("0부터 ${n}까지 짝수의 합")
    println((0..n step(2)).sum())
    println("-----------------------")
    println("0부터 ${n}까지 홀수의 합")
    println((1..n step(2)).sum())
}

0부터 6까지 짝수의 합
12
-----------------------
0부터 6까지 홀수의 합
9

sum, average : array 총 합, 평균 구하기

//arrayFunction(intArrayOf(1,2,3,4,5))

fun arrayFunction(numbers: IntArray){
    println("IntArray 함수")
    println(numbers.sum())
    println(numbers.average())
}

IntArray 함수
15
3.0

//arrayFunction(doubleArrayOf(1.1,2.2,3.3,4.4,5.5))

fun arrayFunction(numbers: DoubleArray){
    println("DoubleArray 함수")
    println(numbers.sum())
    println(numbers.average())
}

DoubleArray 함수
16.5
3.3

✊ 자릿수 더하기

//solution(123)

fun solution(n: Int) {

    println(n.toString().sumOf { it.toInt() }) // (X)
    println(n.toString().sumOf { it.toString().toInt() }) // (O)
    println(n.toString().map { it.toString().toInt() }.sum()) // (O)

    n.toString().forEach {
        println(it.javaClass)
    } //char
    n.toString().forEach {
        println(it.toString().javaClass)
    } //String

}

150
6
6
char
char
char
class java.lang.String
class java.lang.String
class java.lang.String

첫 번째 코드처럼 각 자리수의 합을 더하면 안되는 이유

n의 각 항목인 it이 char인 것을 알 수 있는데 char를 toInt하면 해당 문자의 ASCII 코드를 나타내는 정수로 변환해서 123이 들어왔을 경우 1,2,3에 해당하는 값이 49,50,51로 변환이 돼서 결과가 150이 나온다.

그래서 char인 문자를 string으로 바꾸고 Int로 바꿔야 한다!

✊ 약수의 합

<과정>
1. 12가 들어왔을 때 제곱근인 3까지 구함
 → [1,2,3]
2. 이 숫자들을 12로 나눔
 → [12,6,4]
3. 이 리스트에 있는 값들을 다 더하기
 → [1,2,3,4,6,12]

import kotlin.math.sqrt

//findDivisor(12)
fun findDivisor(n: Int){

    var sum = 0
    val endNumber = sqrt(n.toDouble())
    val divisorList = mutableListOf<Int>()

    for(i in 1..endNumber.toInt()){
        if(n % i == 0){
            divisorList.add(i)
        }
    }

    sum = divisorList.sum()

    for(divisor in divisorList){
        if(n % divisor == 0){
            sum += divisor
        }
    }
    println(sum)
}

first, firstOrNull : 첫 번째 데이터 리턴

람다 함수로 조건을 주고 해당 조건을 만족하는 가장 첫 번째 데이터를 추출

• first()는 해당 조건에 만족하는 데이터가 없는 경우 NoSuchElementException을 발생한다.
• firstOrNull()을 활용하면 해당 조건에 만족하는 데이터가 없는 경우 null을 반환한다.

//firstLast(intArrayOf(1,3,5,24,8))
fun firstLast(intArray: IntArray){
    println(intArray.first())
    println(intArray.last())
    println(intArray.first{ it % 2 == 0 })
    println(intArray.last{ it % 2 == 0 })
//    println(intArray.first{ it % 11 == 0 }) //NoSuchElementException
    println(intArray.firstOrNull{ it % 11 == 0 })
}

1
8
24
8
null

last, lastOrNull : 마지막 데이터 리턴

람다 함수로 조건을 주고 해당 조건을 만족하는 가장 마지막 데이터를 추출한다.

//firstLast(listOf("Duke", "Leonardo", "Sara", "James", "Mino"))
fun firstLast(stringArray: List<String>){
    println(stringArray.first())
    println(stringArray.last())
    println(stringArray.first{ it.length > 4})
//    println(stringArray.first{ it.length > 8}) //NoSuchElementException
    println(stringArray.lastOrNull{ it.length > 8})
}

Duke
Mino
Leonardo
null

✊ 1로 나눠떨어지는 가장 작은 수 찾기

val n = 10
println((1..n).first{n % it == 1})

3

✊ 숫자를 리스트로 바꾼 후 정렬(내림차순, 오름차순)

val n = 1234
println(n.toString().map { it.toString().toInt() }.sorted())
println(n.toString().map { it.toString().toInt() }.sortedDescending())

[1, 2, 3, 4]
[4, 3, 2, 1]

indexOf : 함수는 주어진 요소의 인덱스를 반환

요소가 컬렉션 내에 없으면 -1을 반환
컬렉션 타입들과 함께 쓸 수 있다

//kimforEachIndex(arrayOf("Jane", "Kim"))
fun kimforEachIndex(seoul: Array<String>): String {
    var answer = ""
    println("김서방은 ${seoul.indexOf("Kim")}에 있다")
    println("김서방은 ${seoul.indexOf("NaN")}에 있다")
    return answer
}

김서방은 1에 있다
김서방은 -1에 있다

repeat : 어떤 문자열을 주어진 횟수만큼 반복

repeat(5){
    answer += "*"
}

*****

padStart, padEnd : 남는 공간을 특정 문자로 채워야 할 때

"345"라는 문자가 있을 때 앞에 '0' 3개를 채워서 "000345"로 만들고 싶을 때

//총 공간이 6만큼 있고 남는 부분만큼 0으로 채우기
var padWithChar1 = "345".padStart(6,'0')
println("'$padWithChar1'")
padWithChar1 = "345".padEnd(6,'0')
println("'$padWithChar1'")
println("--------------------------------")

//총 공간이 5만큼 있고 남는 부분만큼 .으로 채우기
var padWithChar2 = "a".padStart(5, '.')
println("'$padWithChar2'")
padWithChar2 = "a".padEnd(5, '.')
println("'$padWithChar2'")
println("--------------------------------")

//총 공간이 5만큼 있고 남는 부분만큼 공백으로 채우기(default는 공백)
var padWithSpace = "125".padStart(5)
println("'$padWithSpace'")
padWithSpace = "125".padEnd(5)
println("'$padWithSpace'")
println("--------------------------------")

'000345'
'345000'
--------------------------------
'....a'
'a....'
--------------------------------
'  125'
'125  '
--------------------------------

take, takeLast : 컬렉션/문자열의 시작/끝부터 n 개의 요소를 선택

val cities = listOf("Seoul", "Tokyo", "Beijing", "NYC", "London", "Singapore")
val city = "SEOUL"

println("컬렉션: $cities")
println("take: ${cities.take(2)}")
println("takeLast: ${cities.takeLast(3)}")
println("take: ${city.take(4)}")
println("takeLast: ${ city.takeLast(4)}")

컬렉션: [Seoul, Tokyo, Beijing, NYC, London, Singapore]
take: [Seoul, Tokyo]
takeLast: [NYC, London, Singapore]
take: SEOU
takeLast: EOUL

takeWhile, takeLastWhile : 리스트의 시작부터 조건을 만족하는 요소들을 선택

조건에 맞지 않는 요소가 나타나면 즉시 순회를 중단하고 결과를 반환

리스트의 일부분만을 효율적으로 선택할 때 유용

val cities = listOf("Seoul", "Tokyo", "Beijing", "NYC", "London", "Singapore")

println("컬렉션: $cities")
println(cities.takeWhile { city -> city.length <= 5 })
println( cities.takeLastWhile { city -> city.length > 5 })

컬렉션: [Seoul, Tokyo, Beijing, NYC, London, Singapore]
[Seoul, Tokyo] //Beijing(lenght > 5)이 나오면 리스트 순회 중단
[London, Singapore]

contains : 해당 요소가 컬렉션 내에 존재하는지 검사

contains 함수는 List, Set, Array 및 다른 컬렉션 타입에서 사용할 수 있으며, 해당 요소가 컬렉션 내에 존재하면 true를, 그렇지 않으면 false를 반환합니다.
contains 함수는 내부적으로 equals 메소드를 사용하여 주어진 요소와 컬렉션의 각 요소를 비교한다.

filter, filterNot : 컬렉션에서 특정 조건을 만족하는 요소들을 선택하거나 제외하는 데 사용

val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }  // [2, 4]
println(evenNumbers)
val notEvenNumbers = numbers.filterNot { it % 2 == 0 }  // [1, 3, 5]
println(notEvenNumbers)

[2, 4]
[1, 3, 5]

✊ 두 컬렉션을 비교해 포함되어 있는 부분 걸러내기

numbers에 있는 숫자와 intArray에 있는 숫자 중 겹치는 부분 걸러내기

val numbers = intArrayOf(1,2,6,7,8,0)
val intArray = intArrayOf(0,1,2,3,4,5,6,7,8,9)

println(intArray.filterNot{numbers.contains(it)})
println(intArray.filter{numbers.contains(it)})

[3, 4, 5, 9]
[0, 1, 2, 6, 7, 8]

N진법 변환하기

toInt : 10진수로 변환

println("1111".toInt(2))   //2진수인 1111을 10진수로 변환
println("1111".toInt(8))   //8진수인 1111을 10진수로 변환
println("1111".toInt(10))  //10진수인 1111을 10진수로 변환

15    //1111(2) -> 15(10)  
585   //1111(8) -> 585(10) 
1111  //1111(10) -> 15(10) 

N진수로 변환하기 : 정수.toString(N)

println(Integer.toBinaryString(15)) //10진수 15를 2진수로 바꾸기
println(15.toString(2)) //10진수 15를 2진수로 바꾸기
println("1111".toInt(2)) //2진수 1111를 10진수로 바꾸기
println("-----------------------------------------------------")
println(Integer.toOctalString(585)) //10진수 585를 8진수로 바꾸기
println(585.toString(8)) //10진수 585를 8진수로 바꾸기
println("1111".toInt(8)) //8진수 1111를 10진수로 바꾸기
println("-----------------------------------------------------")
println(Integer.toHexString(4369)) //10진수 4369를 16진수로 바꾸기
println(4369.toString(16)) //10진수 4369를 16진수로 바꾸기
println("1111".toInt(16)) //16진수 1111를 10진수로 바꾸기

1111
1111
15
-----------------------------------------------------
1111
1111
585
-----------------------------------------------------
1111
1111
4369

대문자/소문자 판별 : isUpperCase, isLowerCase

대문자/소문자 변환 : toUpperCase, toLowerCase

println("A는 소문자입니까? ${'A'.isLowerCase()}")
println("A는 대문자입니까? ${'A'.isUpperCase()}")
println("A를 소문자로 바꾸면? ${'A'.toLowerCase()}")
println("a를 대문자로 바꾸면? ${'A'.toUpperCase()}")

A는 소문자입니까? false
A는 대문자입니까? true
A를 소문자로 바꾸면? a
a를 대문자로 바꾸면? A

✊ 알파벳 리스트에 담기

val uppercase = ('A'..'Z').toList()
val lowercase = ('a'..'z').toList()
println(uppercase)
println(lowercase)

[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]
[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]

Key와 Value의 값을 저장하기 위한 Collection : mapOf

//key와 value 값을 to로 설정
val correctMap = mapOf<String, Int>("key1" to 1, "key2" to 2, "key3" to 3) 

//값을 입력하지 않을 때는 타입 추론이 안되기 때문에 타입을 꼭 명시해야 한다.
// val wrongMap = mapOf() 

✊ 문자로 쓰인 숫자를 숫자로 바꾸기

ex) one4seveneight -> 1478
숫자는 가만히 놔두고 문자만 숫자로 바꿔야 하기 때문에 각 문자에 맞는 숫자로 replace 하면 된다.

val s = "one4seveneight"
val numToWordMap  = mapOf(
    "zero" to 0,
    "one" to 1,
    "two" to 2,
    "three" to 3,
    "four" to 4,
    "five" to 5,
    "six" to 6,
    "seven" to 7,
    "eight" to 8,
    "nine" to 9,
    "ten" to 10,
    "eleven" to 11
)

var numberList = s

numToWordMap.forEach { word, number -> //word는 key, number는 value 값
    if(numberList.contains(word)) 
        numberList = numberList.replace(word, number.toString())
}
println(numberList)

1478

mapOf를 선언했을 때 forEach를 사용하면 key, value 값을 사용하기 편하다.

✊ 소수 구하기

fun isPrime(x: Int): Boolean {
    for (i in 2 until x) { //2부터 x-1까지 반복
        if (x % i == 0) return false //x가 한 번이라도 나누어 떨어지면 소수가 아님
    }
    return true	//모두 반복해도 나누어 떨어지지 않으면 소수
}

break

ForEach

(추가하기)
기본 사용법

암시적 label 사용법