CODEWITHSUNDEEP
kotlin
Hamid Ghasemi
Hamid Ghasemi

Reputation: 892

How to sum multiple elements after grouping in Kotlin

I have a list of objects A (alist).

A { 
  val b : Int
  val c1 : Int
  val c2 : Int
  val d1 : Int
  val d2 : Int
}

and I want to group them by b and calculate sum of c1+c2 and d1+d2 on each group and put the results in list of E objects elist.

E {
  val sum_of_c_types : Int
  val sum_of_d_types : Int
}

How do I achieve in kotlin using any collection inbuilt function?

note:

I know I can do it with reduce function and create temporary A objects, but this is important to dont use temporary A object in code.

Upvotes: 5

Views: 13332

Answers (3)

s1m0nw1
s1m0nw1

Reputation: 81869

I've solved it by using a sequence of groupBy, map and sumBy. It's probably not the cleanest solution I guess.

data class A(val b: Int,
             val c1: Int,
             val c2: Int,
             val d1: Int,
             val d2: Int)

data class E(val sumC: Int, val sumD: Int)

fun main(args: Array<String>) {
    val alist = listOf(A(1, 2, 1, 4, 5), A(1, 3, 4, 6, 3), A(2, 2, 2, 2, 2), A(3, 1, 2, 1, 2))
    val grouped: Map<Int, E> = alist.groupBy(A::b).mapValues {
        E(it.value.sumBy { it.c1 + it.c2 }, it.value.sumBy { it.d1 + it.d2 })
    }
    grouped.forEach {
        println("Group b=${it.key}: ${it.value}")
    }
}

Results in:

Group b=1: E(sumC=10, sumD=18)
Group b=2: E(sumC=4, sumD=4)
Group b=3: E(sumC=3, sumD=3)

Edit:

With Grouping (using groupingBy instead of groupBy), it looks even better because you don't have to handle map entities:

 val grouped = alist.groupingBy(A::b).aggregate { _, acc: E?, e, _ ->
        E((acc?.sumC ?: 0) + e.c1 + e.c2, (acc?.sumD ?: 0) + e.d1 + e.d2)
    }

Upvotes: 8

Boris Treukhov
Boris Treukhov

Reputation: 17774

I think it's just grouping with folding

fun group(a: List<A>) = a.groupingBy(A::b).fold(E(0, 0),
        { acc, elem ->
            E(acc.sum_of_c_types + elem.c1 + elem.c2,
                    acc.sum_of_d_types + elem.d1 + elem.d2)
        })

Upvotes: 5

Hamid Ghasemi
Hamid Ghasemi

Reputation: 892

I solved it by following code:

alist.groupby { b }. mapValues {
   it.value.map {
      E(it.c1+it.c2, it.d1+it.d2)
   }.reduce { 
      acc, e -> E(acc.sum_of_c_types + e.sum_of_c_types, acc.sum_of_d_types + e.sum_of_d_types)
   }.values

Upvotes: 1

Related Questions