whats the best way to remove a duplicates, inclusively, in a list? ```1 1 2 3 4``` should become ``...

# getting-started

[Nick]

whats the best way to remove a duplicates, inclusively, in a list?

1
1
2
3
4

should become

2
3
4

I was thinking maybe using either filter or groupBy

[Russell Stewart]

You can just use distinct() or distinctBy().

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/distinct.html

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/distinct-by.html

[Nick]

that would return

1
2
3
4

[Russell Stewart]

Oh, I'm sorry. My mistake.

[Nick]

np

[Nick]

.groupingBy { it }.eachCount().filterValues {
        it == 1
    }.keys

would work, but maybe there's a better way?

[Adam S]

groupingBy { it }.eachCount() is a nice shortcut

val list = listOf(1, 1, 2, 3, 4)

val counts: Map<Int, Int> = list.groupingBy { it }.eachCount()
println("counts $counts")

val singles: Set<Int> = counts.filterValues { it == 1 }.keys

println("singles $singles")

https://pl.kotl.in/enySBykmC

[Adam S]

oh you got there first haha

[Adam S]

an alternative, using fold() https://pl.kotl.in/gkH-ClMAW

val list = listOf(1, 1, 2, 3, 4)

val singles = list.fold(emptySet<Int>()) { acc, i ->
  when (i) {
    in acc -> acc - i
    else   -> acc + i
  }
}

println("singles $singles")

[phldavies]

You'd need to also track those you've discarded or listOf(1,1,2,3,4,1) would result in listOf(1,2,3,4) again:

val list = listOf(1,1,2,3,4,1)

fun main() {
   val result = list.fold(emptySet<Int>() to emptySet<Int>()) { (kept, rejected), v -> 
       when(v) {
           in kept -> (kept - v) to (rejected + v)
           in rejected -> kept to rejected
           else -> (kept + v) to rejected
       }
   }.first
   
   println(result)
}

[Adam S]

ah good point, thanks

[Adam S]

some tail recursion, for fun

https://pl.kotl.in/DSbnvQTKb

fun main() {
  val list = listOf(1, 1, 2, 3, 4, 1)

  val singles = list.removeDuplicates()

  println("singles $singles")
}

tailrec fun Collection<Int>.removeDuplicates(
  valid: Set<Int> = emptySet(),
  seen: Set<Int> = emptySet(),
): Set<Int> {
  return when (val first = firstOrNull()) {
    null    -> valid
    in seen -> (this - first).removeDuplicates(valid - first, seen + first)
    else    -> (this - first).removeDuplicates(valid + first, seen + first)
  }
}

[Wout Werkman]

fun <T> List<T>.duplicates(): List<T> = filterNot(mutableSetOf<T>()::add)

assert(listOf(2, 3, 4), list - list.duplicates())

[Kevin Del Castillo]

Feeling some AoC vibes here 👀