Traverse a graph using the A* alorithm.

See traverse for more details.

Much much faster version of not-any? for long-arrays.

Usually faster than the assoc-in built-in.

Usually faster than the assoc-in built-in.

Traverse a graph using the BFS alorithm.

See traverse for more details.

Find a number between lo and hi which gives target as a result of applying func to it.

Slightly faster than ((comp count str) n).

An alternative to (count (filter ...)).

Create a hashmap representation of a grid from a 2D vector, where preds is a map from a predicate (set, function, character) to its name, e.g. {\# :walls}.

The resulting hashmap has the following keys:

• :height
• :width
• :size - if height and width are the same, otherwise nil
• each predicate defined in the preds parameter:
• if a predicate was a character, returns a set of points
• otherwise, returns a map of points to matching characters

Create a hashmap representation of a grid from a 2D vector, where each coordinate is represented as x + multi*y (default multi: 1000) and where preds is a map from a predicate (set, function, character) to its name, e.g. {\# :walls}.

The resulting hashmap has the following keys:

• :height
• :width
• :size - if height and width are the same, otherwise nil
• each predicate defined in the preds parameter:
• if a predicate was a character, returns an int-set of point hashes
• otherwise, returns an int-map of point hashes to matching characters

Traverse a graph using the DFS alorithm.

See traverse for more details.

Four diagonal neighbours of a 2D point.

If pred is specified, returns only those neighbours that satisfy it.

Traverse a graph using the Dijkstra’s alorithm.

See traverse for more details.

Check if n is divisible by n.

Similar to the count-if function above, but allows for a more elaborate predicate, i.e. everything that the doseq built-in does.

An easier-to-type way to create an empty queue.

Find first element of a collection which satisfies the predicate.

Returns the index of the first element which satisfies the predicate.

Greatest common divisor.

Get an element in y row, x col of a vector representation of a grid.

Returns default on a point which is out of bounds, or nil if not specified.

Create a seq of [idx el] pairs from a coll.

If start is provided, it is used as a first index, otherwise 0.

Check if a 3D point (x, y, z) is inside of a cube of a given size.

Check if a point (x, y) is inside of a square/rectangle of a given size.

Extracts all integers from a string. It can ignore - if negative=false, e.g. for ranges 23-45.

Least common multiple.

Assumes left-hand coord system (positive y goes down).

Manhattan distance of a 2D point or between two 2D points.

Manhattan distance of a 3D point or between two 3D points.

Map a function to a collection and find a maximum value of the results.

Parallel map a function to a collection and find a maximum value of the results.

Six neighbours of a 3D point, two in each direction.

Four neighbours of a 2D point.

If pred is specified, returns only those neighbours that satisfy it.

Eight neighbours of a 2D point.

If pred is specified, returns only those neighbours that satisfy it.

A faster version of not-any?.

Parse input string, based on parse-fn, which can be a custom function or one of the following:

• :int - parse a single integer
• :ints- get all integers
• :digits - extract all single digits
• :chars - make a list of chars
• :words - make a list of words

Parse each line of input by applying parse-fn to it.

We can pass any function as parse-fn or use one of the following:

• :int - parse a single integer
• :ints- get all integers
• :digits - extract all single digits
• :chars - make a list of chars
• :words - make a list of words

Split input into paragraphs (separated by a blank line). Parse each paragraph based on parse-fn.

Map a function to a collection and take a product of the results.

Multiply each coordinate of a 2D point by magnitude.

Sum of two 2D points.

Difference between two 2D points.

Multiply each coordinate of a 3D point by magnitude.

Sum of two 3D points.

Difference between two 3D points.

Read contents of an input file.

Assumes:

• inputs are in the sibling ../inputs directory
• inputs have .txt extension
• if passing a single digit as a parameter, it zero-pads it

Assumes left-hand coord system (positive y goes down).

Convert a map/set representation of a grid to a printable string of points.

Sign of a number.

Extracts digits from a string. Ignores non-digit characters.

Map a function to a collection and take a sum of the results.

Map a function (which takes two arguments idx and el) to a collection and take a sum of the results.

Parallel map a function to a collection and take a sum of the results.

Transform a matrix of rows into a matrix of columns.

General graph traversal function. Not very performant. Not very pretty.

The simplest version needs just :start, :end and :walls keys, and either :nb-num (number of neighbours to consider) or a custom :nb-func.

The list of possible keys passed in the options map is quite large:

[start end walls size size-x size-y
 nb-func nb-num nb-cond end-cond
 cost-fn heuristic steps-limit
 allow-revisits? side-effect]

It’s best to read the function’s source code to understand what each does.

Usually faster than the update-in built-in.