mutableList와 groupBy, Let, fold

// 기존 내 풀이
for (i in clothes) {
        if (hashMap[i[1]] == null) {
            val data = mutableListOf<String>()
            data.add(i[0])
            hashMap[i[1]] = data
        } else {
            hashMap[i[1]]!!.add(i[0])
        }

        println(hashMap)

    }
    
    
    
 //간략히 하기
 
  for(i in clothes) {
            val data = i[1]
            clothHash[key]?.let { value -> clothHash.put(data, i[0]) } ?: clothHash.put(data, i[0])
        }

mutablelist 는 list와 collection 익스텐드 받아서 만든것.

동적으로 할당되는 것으로 

list는 읽기 전용으로 

mutablelist는 읽기와 쓰기 전용으로 만들어짐

 

프로그래머스 문제에서 해쉬 레벨2 문제해결중에 내가 사용한 코드는

[

fun solution(clothes: Array<Array<String>>): Int {
    var answer = 1
    val hashMap = mutableMapOf<String, MutableList<String>>()
    for (i in clothes) {
        if (hashMap[i[1]] == null) {
            val data = mutableListOf<String>()
            data.add(i[0])
            hashMap[i[1]] = data
        } else {
            hashMap[i[1]]!!.add(i[0])
        }

        println(hashMap)

    }
    for (i in hashMap.keys) {
        answer *= ((hashMap[i]!!.size)+1)
    }


    return answer -1
}

 

 

하나하나 맵에 있는 키를 만들어서 그 키에 맞는 리스트에 벨류를 넣는 방식으로 만들었으나 더 좋은 기능들이 많았음..

 

 

 

1. groupBy,values

 

 

kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/group-by.html

val words = listOf("a", "abc", "ab", "def", "abcd")
val byLength = words.groupBy { it.length }

println(byLength.keys) // [1, 3, 2, 4]
println(byLength.values) // [[a], [abc, def], [ab], [abcd]]

val mutableByLength: MutableMap<Int, MutableList<String>> = words.groupByTo(mutableMapOf()) { it.length }
// same content as in byLength map, but the map is mutable
println("mutableByLength == byLength is ${mutableByLength == byLength}") // true

list 를 공통사항을 기준으로 map을 만들어 준다

groupByTo를 사용하여 읽기와 쓰기 동시에 하는 동적리스트인 mutableMap으로도 반환 받을 수 있다.

 

values는 말 그대로 키에 대응하는 값들만을 출력함

 

 

2. fold , reduce

 

 ---fold

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.
Returns the specified initial value if the collection is empty.
Params:
operation - function that takes current accumulator value and an element, and calculates the next accumulator value.

public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

자료 데이터를 축적해서 초기값을 시작으로 결과값을 반환해준다.

 

---reduce 

초기값을 설정해주는 fold와 달리 최초의 값이 초기값이 된다.

public inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S {
    val iterator = this.iterator()
    if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")
    var accumulator: S = iterator.next()
    while (iterator.hasNext()) {
        accumulator = operation(accumulator, iterator.next())
    }
    return accumulator
}

 

 

3.let()

 

Calls the specified function block with this value as its argument and returns its result.
For detailed usage information see the documentation for scope functions .

@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

   1) 불필요한 선언을 막을 수 있다.

   2) 코드 길이 줄일 수 있다. -> 내 답안에 적용시

 
 //간략화
 for(i in clothes) {
            val data = i[1]
            clothHash[data]?.let { value -> clothHash.put(data, i[0]) } ?: clothHash.put(data, i[0])
        }