map-reduce-filter

Iterative Building Blocks

Iterative Building Blocks

Many of the code and algorithms we’ve written together have operated on sequential data, stored in either arrays or Lists. And we’ve seen and identified common patterns for working with this kind of data. Such as counting:

And searching:

And transforming:

And filtering:

And combining:

And while these are fine building blocks for creating larger programs, there is something a bit repetitive and dull about them. Every one has the same overall structure: the same loop, many have an if statement, etc. Shouldn’t there be a better, more compact way of expressing these kind of patterns?

map-reduce-filter

map-reduce-filter

Yes. There is. In Kotlin we refer to this as map-reduce-filter, which is also sometimes known as stream data processing.

map-reduce-filter allows us to work with sequential data by composing powerful programming primitives to great effect. These methods are built right in to all of the Kotlin collections—arrays, lists, and maps—that we’ve already been working with!

Let’s examine how to utilize common stream operations to replace the repetitive loop-based code we wrote above. First, let’s look at one of the most basic collection operations—map:

// Collection map

We can also filter streams using… filter. Let’s see how:

// filter

And, we can even reduce a Stream until a single value with reduce, a surprisingly powerful primitive.

// reduce

Why map-reduce-filter?

Why map-reduce-filter?

This programming pattern may seem alien to you at first. That’s not surprising. A famous silicon valley tech thought leader has pointed out that powerful programming ideas usually feel strange and even bizarre at first. But, as you come to appreciate them, not only do they become more natural, but the older less-powerful ways of doing things start to see even more limited.

Compared to for loops, map-reduce-filter pipelines are:

• More succint: the common parts of the various for-loop based patterns we’ve listed above have been factored out, leaving only the decision-making logic that changes depending on the application
• More composable: it is easier to reorder stream operations to accomplish different data processing tasks than it is to tease apart different parts of for loop
• More efficient: collection operators allow various kinds of operations (like map, for example) to be done in parallel, increasing the speed with which large collections can be processed

map-reduce-filter Example

map-reduce-filter Example

To wrap up, let’s have some fun working with one of our favorite data sets:

class Dog(val name: String, val age: Int)

Homework Restricted to Current CS 124 Students

A publicly-accessible version of this content is available at learncs.online.

Homework: Escape a Maze

Created By: Geoffrey Challen

/ Version: 2021.4.0

Let's get some more practice with algorithms by escaping from a maze! Implement a method named escape that accepts a single parameter, a Maze object with methods explained below. Your goal is to manipulate the maze until you reach the exit, and then return the maze when you are finished.

To navigate the maze, using the following Maze methods:

• isFinished(): returns true when you have reached the exit of the maze
• turnRight() rotates your character 90 degrees to the right
• turnLeft() rotates your character 90 degrees to the left
• canMove() returns true if you can move one cell forward, false otherwise. Your path may be blocked by a wall!
• move() moves your character one cell forward and increases the step counter

The passed Maze object represents a simply-connected or perfect maze: one that contains no loops. As a result, we suggest that you pursue a classic maze escape algorithm: wall following. Simply put, in a maze that contains no loops, as long as you continue following a wall you will eventually reach the exit. In a corn maze, you might implement this by simply maintaining contact with a wall (right or left) until you complete the maze. However, you'll need to think a bit about how to implement this algorithm to finish this problem.

WorkingPrevious

More Practice

Need more practice? Head over to the practice page.