Exercise topics

Topics are a rough way of describing which language/library features or techniques an exercise touches on.

An exercise has a topic if it forces the user to use techniques or language/library features or if it strongly hints at doing so.

The "YAML:" lines contain the syntax best used when using the tag in a .yml file.

Please keep the following in alphabetical order for quick lookup and add any topics to the quick reference.

Quick reference

• Abstract Data Types
• Arithmetic
• Arrays
• Bitwise-operations
• Conditionals
• Linked lists
• Loops
• Mappings
• Message passing concurrency
• Objects
• Pattern matching
• Recursion
• Regular expressions
• Shared state concurrency

Full description

Abstract Data Types

YAML: "abstract data types"

Use of abstract data types, think Haskell's data keyword and Rust's enum.

Arithmetic

YAML: "arithmetic"

The exercise involves more than basic arithmetic. For example exercises related to prime numbers have this topic since prime numbers are not trivial calculus.

Arrays

YAML: "arrays"

Use of arrays. Arrays can be described as ordered collections in which access to every element takes an equal amount of time. Python's lists are thus arrays, not linked lists (which take less time for retrieving elements closer to the start).

Bitwise operations

YAML: "bitwise operations"

Use of bitwise operations such as bitwise and (& in many languages) and left shift (<<).

Conditionals

YAML: "conditionals"

Use of if-like constructs and switch-like constructs (such as Ruby's case).

Linked lists

YAML: "linked lists"

Use of (single or double) linked lists. In many functional and logic languages single linked lists are the common collection types. Note that Python's lists are not linked lists, they're more accurately described as arrays (and are usually implemented that way under the hood).

Mappings

YAML: "mappings"

Use of mappings. Mappings are associative data structures also known as dictionaries, maps, objects (in Javascript) and hashes (in Perl/Ruby). If you have a data structure that supports looking up a value by some string key it's a mapping.

Message passing concurrency

YAML: "message passing concurrency"

Use of message passing to implement concurrency (non-shared-state concurrency). For example Erlang messages and Go channels.

Objects

YAML: "objects"

Use of objects in an object-oriented sense. That is, objects encapsulate data so that the (only or preferred) way to manipulate the data is through methods on the object.

Pattern matching

YAML: "pattern matching"

Use of pattern matching constructs like match in Rust or function argument matching in Elixir/Haskell.

Loops

YAML: "loops"

Use of loop constructs like for and while.

Recursion

YAML: "recursion"

Use of directly or indirectly recursive calls. E.g. foo(n) calls foo(n-1).

Regular expressions

YAML: "regular expressions"

Use of regular expressions (regexes).

Shared state concurrency

YAML: "shared state concurrency"

Use of mutual exclusion locks (mutexes) or other synchronization mechanisms to allow multiple threads to access the same memory or resource.