프로그래밍

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
val dimen2 = Array(101){IntArray(101)} // 2차원
val dimen3 = Array(101){Array(101){IntArray(101)} } // 3차원
fun main() = with(BufferedReader(InputStreamReader(System.`in`))){
    println("초기값 : ${dimen3[100][3][2]}") // 0
    dimen3[100][3][2]=12
    println(dimen3[100][3][2]) // 12
}

코틀린에서는 C++에서처럼

int dimen2[100][100] 이런식으로 간단하게 배열 선언이 불가능합니다.

 val dimen2 = Array(101){IntArray(101)} 

그래서 위와 같은 방법을 이용합니다.

IntArray(101)은 Java의 Primitive 타입 배열 new int[101] 과 동일한 배열을 생성하며

이것을 101개 생성하는것이 Array(101){IntArray(101)}  입니다.

101개를 모두 IntArray(101)로 초기화 하겠다는 의미입니다.

Array<IntArray> 타입인데 타입추론을 해주므로 <IntArray>는 생략해도 됩니다.

3차원배열을 선언할때도 동일하게 선업하면 됩니다. 

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
fun main() = with(BufferedReader(InputStreamReader(System.`in`))){

    val mp = HashMap<Int,Int>() // 순서가 필요한 경우 TreeMap 사용

    mp[1]=1 // 데이터 삽입시
    mp[2]=2
    mp[3]=3

    mp[1]=(mp[1]?:0)+1 // 기존 데이터를 이용한 수정시 (예를 들어 1증가) null체크를 위해 엘비스 연산자 사용

    for((key,value) in mp){
        println("key:$key value:$value")
    }
//    출력
//    key:1 value:2
//    key:2 value:2
//    key:3 value:3
}

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
fun main() = with(BufferedReader(InputStreamReader(System.`in`))){

    val mp = HashMap<Int,Int>() // 순서가 필요한 경우 TreeMap 사용

    mp[1]=1 // 데이터 삽입시
    mp[2]=2
    mp[3]=3

    mp[1]=(mp[1]?:0)+1 // 기존 데이터를 이용한 수정시 (예를 들어 1증가) null체크를 위해 엘비스 연산자 사용

    for((key,value) in mp){
        println("key:$key value:$value")
    }
//    출력
//    key:1 value:2
//    key:2 value:2
//    key:3 value:3
}

코틀린에서 map을 사용하는 예시입니다.

C++처럼 mp[1]++ 이런 연산은 안되고 엘비스 연산자를 이용해

mp[1]=(mp[1]?:0)+1 이렇게 해주어야 하는것이 불편하네요. 

var default_pq = PriorityQueue<Int>()
default_pq.add(5)
default_pq.add(3)
default_pq.add(7)
println("default")
while(!default_pq.isEmpty()){
println(default_pq.poll())
}
// default
// 3
// 5
// 7

var reverse_pq = PriorityQueue<Int>{a,b-> b.compareTo(a)}
reverse_pq.add(5)
reverse_pq.add(3)
reverse_pq.add(7)

println("reverse")
while(!reverse_pq.isEmpty()){
println(reverse_pq.poll())
}
// reverse
// 7
// 5
// 3

var pq = PriorityQueue<T>()

와 같이 우선순위큐를 생성할 수 있습니다.

C++과 다르게 comparator 전달 없이 생성하면 pop시에 작은 수부터 나오게 됩니다.

 큰 수부터 나오게 하기 위해서는 두번째 예와 같이 람다 comparator를 전달해주면 됩니다.

sortWith + 사용자정의 comparator

    var arr1 = mutableListOf(5,4,2,7,1)
    arr1.sortWith{a,b-> b.compareTo(a)} // [7, 5, 4, 2, 1]


    var arr2 = mutableListOf<Pair<Int,Int>>(Pair(1,3),Pair(2,5),Pair(2,4),Pair(6,2))
    arr2.sortWith{ a, b ->
        var k:Int = a.first.compareTo(b.first)
        when(k){
            0 -> a.second.compareTo(b.second)
            else -> k
        }
    } // [(1, 3), (2, 4), (2, 5), (6, 2)]
   
    println(arr1.toString())
    println(arr2.toString())

알고리즘 문제를 풀 때 문제에 따라 사용자 정의 comparator를 전달해서 정렬을 해야하는 경우가 종종 있습니다.

C++에서와 비슷하게 코틀린에서도 컬렉션 sortWith 메소드에 Comparator 구현체를 전달하면 사용자가 원하는 방식으로 정렬을 할 수 있습니다.

Pair도 역시 C++과 비슷한 방식으로 정렬이 가능합니다.

sortWith + compareBy / sortedBy

fun main(){

    var arr1 = mutableListOf<Pair<Int,Int>>(Pair(6,2),Pair(2,5),Pair(2,4),Pair(1,3))
    arr1.sortWith(compareBy({it.first},{it.second}))

    var arr2 = mutableListOf<Pair<Int,Int>>(Pair(6,2),Pair(2,5),Pair(2,4),Pair(1,3))
    var parr2 = arr2.sortedBy{it.second}.sortedBy{it.first}

    println(arr1.toString())  // [(1, 3), (2, 4), (2, 5), (6, 2)]
    println(parr2.toString()) // [(1, 3), (2, 4), (2, 5), (6, 2)]
}

우와 같이 sortWith에 comparator를 return해주는 compareBy를 전달하는 방법도 있습니다.

compareBy({1순위로 비교할 프로퍼티},{2순위로 비교할 프로퍼티}....) 처럼 넣어주면 됩니다.

위 예제에서는 it.frst, it.second를 순서로 전달함으로써 first를 우선으로 비교하고, 같으면 second로 비교해서 오름차순으로 정렬하라는 의미입니다.

sortedBy를 이용하는 방법도 있습니다.

sortedBy{비교할 프로퍼티} 으로 써주면 적어준 프로퍼티 기준으로 오름차순 정렬합니다.

arr2에서 해주는 것과 같이 pair의 second부터 정렬해주고, first를 정렬하면 first를 1순위, second를 2순위로 비교해서 정렬하는 것과 같은 효과입니다.