Kotlin: combine certain elements in list in a functional way - list

Question

Recently I was asked what Kotlin stdlib functions I could recommend to handle a certain problem: combine certain meetings in a list that have the same start/end time.
Let's say a meeting is given by this data class:
data class Meeting(val startTime: Int, val endTime: Int)
fun main() {
val meetings = listOf(
Meeting(10, 11),
Meeting(12, 15), // this can be merged with
Meeting(15, 17) // this one
)
println(combine(meetings))
// should print: [Meeting(startTime=10, endTime=11), Meeting(startTime=12, endTime=17)]
}
fun combine(meetings: List<Meeting>): List<Meeting> {
// TODO: elegant, functional way to do this?
}
I already solved this problem using fold, but I didn't feel it was the right use for it (a simple forEach should have been enough):
fun combine(meetings : List<Meeting>) : List<Meeting> {
return meetings.fold(mutableListOf<Meeting>()) { combined: MutableList<Meeting>, meeting: Meeting ->
val lastMeeting = combined.lastOrNull()
when {
lastMeeting == null -> combined.add(meeting)
lastMeeting.endTime == meeting.startTime -> {
combined.remove(lastMeeting)
combined.add(Meeting(lastMeeting.startTime, meeting.endTime))
}
else -> combined.add(meeting)
}
combined
}.toList()
}
Also, another solution with forEach instead of fold:
fun combine(meetings: List<Meeting>): List<Meeting> {
val combined = mutableListOf<Meeting>()
meetings.forEachIndexed { index, meeting ->
val lastMeeting = combined.lastOrNull()
when {
lastMeeting == null -> combined.add(meeting)
lastMeeting.endTime == meeting.startTime ->
combined[combined.lastIndex] = Meeting(lastMeeting.startTime, meeting.endTime)
else -> combined.add(meeting)
}
}
return combined.toList()
}
However, I feel there must be a more elegant, functional way with less mutability to solve this. How would you approach this?
Oh, and before I forget: of course I have some unit tests for you to play around with! 😇
#Test
fun `empty meeting list returns empty list`() {
val meetings = emptyList<Meeting>()
assertEquals(emptyList<Meeting>(), combine(meetings))
}
#Test
fun `single meeting list returns the same`() {
val meetings = listOf(Meeting(9, 10))
assertEquals(meetings, combine(meetings))
}
#Test
fun `3 different meetings`() {
val meetings = listOf(Meeting(9, 10), Meeting(11, 12), Meeting(13, 14))
assertEquals(meetings, combine(meetings))
}
#Test
fun `2 meetings that can be merged`() {
val meetings = listOf(Meeting(9, 10), Meeting(10, 11))
assertEquals(listOf(Meeting(9, 11)), combine(meetings))
}
#Test
fun `3 meetings that can be merged`() {
val meetings = listOf(Meeting(9, 10), Meeting(10, 11), Meeting(11, 13))
assertEquals(listOf(Meeting(9, 13)), combine(meetings))
}
And here's a Kotlin Playground link to get started.
Thanks a lot for your help! 😊

Answer 1

Recursive and immutable.
fun combine(meetings: List<Meeting>): List<Meeting> {
return if (meetings.isEmpty()) meetings
else combineRecurse(emptyList(), meetings.first(), meetings.drop(1))
}
fun combineRecurse(tail: List<Meeting>, head: Meeting, remaining: List<Meeting>): List<Meeting> {
val next = remaining.firstOrNull()
return when {
next == null -> tail + head
next.startTime == head.endTime -> combineRecurse(tail, Meeting(head.startTime, next.endTime), remaining.drop(1))
else -> combineRecurse(tail + head, next, remaining.drop(1))
}
}
The recursive function takes 3 arguments:
tail: Processed meetings that cannot be combined anymore
head: The meeting we're currently working on and trying to extend as much as possible
remaining: Unprocessed meetings

Answer 2

I find the solution with fold most elegant, also it doesn't allocate any excess objects. However, I was able to simplify it:
fun combine(meetings : List<Meeting>) : List<Meeting> {
return meetings.fold(mutableListOf()) { combined: MutableList<Meeting>, meeting: Meeting ->
val prevMeeting = combined.lastOrNull()
if (prevMeeting == null || prevMeeting.endTime < meeting.startTime) {
combined.add(meeting)
} else {
combined[combined.lastIndex] = Meeting(prevMeeting.startTime, meeting.endTime)
}
combined
}
}
Note that this doesn't have to search through the list to remove the previous meeting. It just replaces the previous meeting with the combination of the meetings.
It does need one mutable list, because this solution should be efficient.

Answer 3

Here's a functional way. The idea is to get all the meeting endpoints in a list, then compare pairs of adjacent endTime and startTime and filter out those that are equal.
Then group the result into pairs and make the resulting list of meetings from them.
fun combine(meetings: List<Meeting>): List<Meeting> {
return meetings
.zipWithNext { current, next -> listOf(current.endTime, next.startTime) }
.filterNot { (end, start) -> end == start }
.flatten()
.let { listOf(meetings.first().startTime) + it + listOf(meetings.last().endTime) }
.chunked(2) { (start, end) -> Meeting(start, end) }
}
It works with non-empty lists of meetings; handling an empty one is a matter of an additional if (meetings.isEmpty()) return meetings check in the beginning.
I don't find it, however, more elegant because it requires significantly more object allocations for a big list of meetings. Turning meetings into a sequence with the .asSequence() function in the beginning of the operation chain might help a bit, but not that much.

Answer 4

Honestly, I believe this would be better handled on map creation/insertion rather than attempting to condense it later on. However, this seems to work while avoiding the use of fold and other functions that you seem to prefer not to use.
Also, depending on the size of the original meetings list, it might be worth creating a list of the extended meetings (opposite of stripped) and use that instead of meetings in findLastLinkedMeeting. Not sure if itd make much of difference though.
fun combine(): List<Meeting> {
val stripped = meetings.filter { meeting -> meetings.none { isContinuation(it, meeting) } }
return stripped.map { stripped ->
val fromMeeting = findLastLinkedMeeting(stripped)
if (fromMeeting == stripped) stripped else Meeting(stripped.startTime, fromMeeting.endTime)
}
}
private tailrec fun findLastLinkedMeeting(fromMeeting: Meeting): Meeting {
val nextMeeting = meetings.find { toMeeting -> isContinuation(fromMeeting, toMeeting) }
return if (nextMeeting != null) findLastLinkedMeeting(nextMeeting) else fromMeeting
}
private fun isContinuation(fromMeeting: Meeting, toMeeting: Meeting) =
fromMeeting.endTime == toMeeting.startTime

Answer 5

Using mutability inside a "functional" call is fair, as long as we don't expose it.
This is very similar to your first version, with a few arguably minor differences.
Aggregation function factored out.
Aggregration function is almost in single-expression form.
Interesting case of when is only a single expression.
fun combine(meetings: List<Meeting>): List<Meeting> {
fun add(ms: MutableList<Meeting>, m: Meeting) : MutableList<Meeting> {
ms.lastOrNull().let {
when {
it == null ->
ms.add(m)
it.endTime == m.startTime ->
ms[ms.lastIndex] = Meeting(it.startTime, m.endTime)
else ->
ms.add(m)
}
}
return ms
}
return meetings.fold(mutableListOf(), ::add)
}
Going one step further, we can use reduce instead of fold, at the expense of potentially introducing many short-lived lists (but never many at a time due to using a sequence; I'd hope the JIT would optimize that part) but adding the potential for parallelization:
fun combine(meetings: List<Meeting>): List<Meeting> {
fun add(ml: MutableList<Meeting>, mr: MutableList<Meeting>) : MutableList<Meeting> {
val leftLast = ml.lastOrNull()
val rightFirst = mr.firstOrNull()
when {
leftLast == null || rightFirst == null || leftLast.endTime != rightFirst.startTime ->
ml.addAll(mr)
else -> {
// assert(leftLast.endTime == rightFirst.startTime)
ml[ml.lastIndex] = Meeting(leftLast.startTime, rightFirst.endTime)
mr.removeAt(0)
ml.addAll(mr)
}
}
return ml
}
return meetings.asSequence().map { mutableListOf(it) }.reduce(::add)
}
Of course, the same principle can be applied to immutable lists:
fun combine(meetings: List<Meeting>): List<Meeting> {
fun add(ml: List<Meeting>, mr: List<Meeting>) : List<Meeting> {
val leftLast = ml.lastOrNull()
val rightFirst = mr.firstOrNull()
return when {
leftLast == null || rightFirst == null || leftLast.endTime != rightFirst.startTime ->
ml + mr
else -> {
// assert(leftLast.endTime == rightFirst.startTime)
ml.dropLast(1) + Meeting(leftLast.startTime, rightFirst.endTime) + mr.drop(1)
}
}
}
return meetings.asSequence().map { listOf(it) }.reduce(::add)
}
This is probably the most functional-style-ish variant, at the potential added cost of more object creations. For actual performance considerations we'd have to benchmark, of course.