Find the last element of a list.

Find the last but one element of a list.

Find the kth element of a list. The first element in the list is number 1.

Find the number of elements of a list.

Add 1 for each element by induction.

Find the number of elements of a list.

Cheat by using length.

Find the number of elements of a list.

Map elements to 1 and return their sum.

Find the number of elements of a list.

Add 1 for each element by induction, but tail recursively.

Reverse a list.

Find out whether a list is a palindrome. A palindrome can be read forward or backward; e.g. "xamax".

Transform a list, possibly holding lists as elements, into a "flat" list by replacing each list with its elements recursively.

Recursively flatten lists and concatenate them together.

Transform a list, possibly holding lists as elements, into a "flat" list by replacing each list with its elements recursively.

Build the list starting from the last one, prepending each element one at a time.

Eliminate consecutive duplicates of list elements.

If a list contains repeated elements, they should be replaced with a single copy of the element. The order of the elements should not be changed.

Pack consecutive duplicates of list elements into sublists. If a list contains repeated elements, they should be placed in separate sublists.

Extract consecutive duplicates from the list, and repeat.

Pack consecutive duplicates of list elements into sublists. If a list contains repeated elements, they should be placed in separate sublists.

Cheat by using group.

Use the pack function to implement the so-called run-length encoding data compression method.

Consecutive duplicates of elements are encoded as tuples (n, e), where n is the number of duplicates of the element e.

Modify the encode function in such a way that if an element has no duplicates it is simply copied into the result list. Only elements with duplicates are transferred as (Multiple n x) values.

Given a run-length code list generated by encodeModified, construct its uncompressed version.

Duplicates each element as appropriate and concatenates them together.

Given a run-length code list generated by encodeModified, construct its uncompressed version.

Prepend each element as many times as required, starting from the last element prepended to an empty list, and all the way to the first element.

Implement the so-called run-length encoding data compression method directly. I.e., do not explicitly create the sublists containing the duplicates, as with pack, but only count them.

As with encodeModified, simplify the result list by replacing the singletons (Multiple 1 x) by (Single x).

Duplicate the elements of a list.

Replicate the elements of a list a given number of times.

Drop every nth element from a list.

Split a list into two parts; the length of the first part is given.

Extract a slice from a list.

Given two indices, i and k, the slice is the list containing the elements between the i'th and k'th element of the original list, with both limits included. Start counting the elements with 1.

Go through individual elements in the list, dropping them and then keeping some of the rest.

Extract a slice from a list.

Given two indices, i and k, the slice is the list containing the elements between the i'th and k'th element of the original list, with both limits included. Start counting the elements with 1.

drop and then take.

Rotate a list n places to the left.

Remove the kth element from a list. Return the element removed and the residue list.

Insert an element at a given position into a list.

Create a list containing all integers within a given range.

Extract a given number of randomly selected elements from a list.

Also return a new random number generator so that callers can avoid reusing a sequence of random numbers.

Draw \(n\) different random numbers from the set \( \{ k \,|\, 1 \leq k \leq m \} \).

Generate a random permutation of the elements of a list.

Generate the combinations of \(k\) distinct objects chosen from the \(n\) elements of a list.

Given a list with the sizes of each group and list of items, write a function to return the list of disjoint groups.

We suppose that a list contains elements that are lists themselves. Write a function to sort the elements of this list according to their length, i.e., short lists first and longer lists later.

Again, we suppose that a list contains elements that are lists themselves. But this time, write a function to sort the elements of this list according to their length frequency, i.e., lists with rare lengths are placed first, others with a more frequent length come later.

Write a function to compute the \(n\)th Fibonacci number.

Computes the \(n\)th Fibonacci number with \(O(\log n)\) multiplications. Takes advantage of matrix multiplication and exponentiation.

Determine whether a given integer number is prime.

Checks whether the integer is even or if there is a divisor among odd integers not greater than its square root.

Determine whether a given integer number is prime.

Uses an Erastothenes sieve to construct a list of primes up to at least the square root of the integer, and searches for a divisor among them.

Determine whether a given integer number is prime.

From a list of all prime numbers, search for a divisor.

Determine the greatest common divisor of two positive integer numbers. Use Euclid's algorithm.

Determine whether two positive integer numbers are coprime. Two numbers are coprime if their greatest common divisor equals 1.

Calculate Euler's totient function \(\phi(m)\).

Accumulates count of numbers that are coprime.

Calculate Euler's totient function \(\phi(m)\).

Filters through numbers that are coprime and count them.

Determine the prime factors of a given positive integer. Construct a list containing the prime factors in ascending order.

Determine the prime factors of a given positive integer. Construct a list containing the prime factors and their multiplicity.

Calculate Euler's totient function \(\phi(m)\) using Euler's product formula.

Construct the list of highly totient numbers.

Given a range of integers by its lower and upper limit, inclusive, construct a list of all prime numbers in that range.

Construct the list of all prime numbers.

Find two prime numbers that sum up to a given even integer.

Given a range of integers by its lower and upper limit, return a list of all Goldbach compositions for the even numbers in the range.

Compute the multiplicative inverse \(x\) of a given integer \(a\) and modulus \(n\) lying in the range \(0 \leq x < n\).

Uses the extended Euclidean algorithm and the fact that \(ax \equiv 1 \pmod{n}\) if \(ax+ny=1\).

Determine whether a Gaussian integer is divisible by another.

Determine whether a Gaussian integer is a Gaussian prime.

Using Fermat's two-square theorem, it can be shown that a Gaussian integer \(a+bi\) is prime if and only if it falls into one of the following categories:

• |a| is prime and \(|a| \equiv 3 \mod 4\), if \(b=0\).
• |b| is prime and \(|b| \equiv 3 \mod 4\), if \(a=0\).
• \( a^2 + b^2 \) is prime, if \( a \neq 0 \) and \( b \neq 0 \).

Use this property to determine whether a Gaussian integer is a Gaussian prime.

Truth tables for logical expressions with two operands.

Evaluates a logic circuit.

Returns a logic circuit composed of NAND gates which computes a given a binary boolean function. The logic circuit should be in a form which evaluateCircuit can evaluate.

Generalizes table in a way that the logical expression may contain any number of logical variables.

Returns the n-bit Gray code.

Given a list of symbols and their number of occurrences, construct a list of the symbols and their Huffman encoding.

The characters '0' and '1' will represent the 0 and 1 bits in the encoding.

Flip a given number of boolean values in the boolean list randomly.

Construct an error-correcting encoding of the given Boolean list.

Uses a reptition code of length 3.

The inverse of errorCorrectingEncode. Recover the original Boolean list from its encoding. There could be an error in the encoding.

Return the conjunctive normal form of a boolean formula. The value returned should always be a conjunction of disjunctions.

Determines whether the formula is valid given the axioms.

A binary tree.

A Tree of type a consists of either an Empty node, or a Branch containing one value of type a with exactly two subtrees of type a.

Notes

Define a shorthand function for constructing a leaf node.

A leaf node in Tree is a branch with two empty subtrees.

Define as the tree as shown in the following.

Define as a binary tree consisting of only a single root node with value 'a'.

Define as an empty binary tree.

Define as the following tree with integer values.

Constructs completely balanced binary trees for a given number of nodes.

Check whether a given binary tree is symmetric.

Construct a binary search tree from a list of ordered elements.

Return a binary search tree with an element added to another binary search tree.

Construct all symmetric, completely balanced binary trees with a given number of nodes.

Construct a list of all height-balanced binary trees with the given maximum height.

Construct all the height-balanced binary trees with a given number of nodes.

Collect the leaves of a binary tree in a list. A leaf is a node with no successors.

Collect the internal nodes of a binary tree in a list.

Collect the nodes at a given level in a list

Construct a complete binary tree with the given number of nodes.

Write a function to return whether a tree is a complete binary tree.

Lay out a binary tree using in-order positions.

Lay out a binary tree with constance distance at each level.

Lay out a binary tree compactly.

Somebody represents binary trees as strings of the following form:

a(b(d,e),c(,f(g,)))

Write a function to generate this string representation from a binary tree.

Write a function to construct a tree from the string representation.

Return the in-order sequence of a binary tree.

Return the pre-order sequence of a binary tree.

Given the in-order and pre-order sequences of a binary tree, return the original binary tree.

The values in each node of the binary tree will be distinct, in which case the tree is determined unambiguously.

Convert a dotstring representation into its corresponding binary tree.

Convert a binary tree to its dotstring representation.

We suppose that the nodes of a multiway tree contain single characters. The characters in the node string are in depth-first order of the tree. The special character ^ is inserted whenever the move is a backtrack to the previous level during tree traversal. Note that the tree traversal will also backtrack from the root node of the tree.

Write a function to construct the MultiwayTree when the string is given.

Construct the node string from a MultiwayTree.

Determine the internal path length of a tree.

We define the internal path length of a multiway tree as the total sum of the path lengths from the root to all nodes of the tree. By this definition, multitree5 has an internal path length of 9.

Construct the post-order sequence of the tree nodes.

An s-expression is commonly represented as a list of items between parentheses. In particular, s-expressions can be nested, e.g., (a b (c d) e (f g)). It is used by programming languages such as Lisp and Scheme.

A possible way to represent a multiway tree with an s-expression is for the first element in a list to represent the root of the tree, and the rest of the elements in the list would be its children. As a special case, a multiway tree with no children is represented without parentheses.

Write a function which will return this s-expression representation of a multiway tree as a string.

Write a function which will convert an s-expression, representing a multiway tree as in treeToSexp, into a MultiwayTree.

Implementation of askGoldbach' without do notation.

Implementation of maybeGoldbach' with do notation.

Rewrite of maybeGoldbach to return an Either value.

Returns all the one-dimensional random walk paths with \(n\) steps starting from position 0.

Starting from a positive integer \(n\), we can have a sequence of numbers such that at each step, the next number is \(3n+1\) if \(n\) is odd, or \(\frac{n}{2}\) if \(n\) is even. The Collatz conjecture states that this sequence will always end at 1 after a finite number of steps.

Using the Writer monad, count the number of these steps for a given positive integer \(n\).

Use monad transformers to evaluate postfix notation.

Returns Nothing when there is an error. Also returns the history of the evaluation.

Functions to convert between the different graph representations Lists, Adjacency, Paths, and G.

Convert graph to the Lists representation.

Convert graph to the Adjacency representation.

Convert graph to the Paths representation.

Convert graph to the G representation.

Write a function that, given two vertexes a and b in a graph, returns all the acyclic paths from a to b.

Finds all cycles in the graph which include the given vertex.

Construct all spanning trees of a given graph.

Write a function which returns whether a graph is a tree using spanningTrees.

Write a function which returns whether a graph is connected using spanningTrees.

Write a function which constructs the minimum spanning tree of a given weighted graph. While the weight of an edge could be encoded in the graph represention itself, here we will specify the weight of each edge in a separate map.

Determine whether two graphs are isomorphic.

Builds up a bijection from a starting vertex to its neighbors, expanding until it encounters an inconsistency or until there are no more vertexes to expand to.

Determine whether two graphs are isomorphic.

This tests all bijections of vertexes from one graph to another to see if any are identical.

Determine whether two graphs are isomorphic.

Tests bijections which are limited to matching vertexes with the same degree, and looks for any which results in one graph becoming identical to the other.

Color a graph using Welch-Powell's algorithm. Uses distinct integers to represent distinct colors, and returns the association list between vertexes and their colors.

Write a function that generates a depth-first order graph traversal sequence. The starting point should be specified, and the output should be a list of nodes that are reachable from this starting point in depth-first order.

Write a function that splits a graph into its connected components.

Write a function that finds out whether a given graph is bipartite.

Solve the extended eight queens problem for arbitrary \(n\).

Represent the positions of the queens as a list of numbers from 1 to \(n\).

Returns a knight's tour ending at a particular square. Represents the squares by their coordinates with the tuple \((x,y)\), where \(1 \leq x \leq N\) and \(1 \leq y \leq N\). A tour will be a list of these tuples of length \(N \times N\).

The same as knightsTour, except return a circular tour. I.e., the knight must be able to jump from the last position in the tour to the first position in the tour. Starts the tour from \((1,1)\).

Gracefully label a tree graph.

This implementation builds up a partial graceful labeling, adding one vertex at a time. It gives up and tries another if a partial labeling cannot be extended.

Gracefully label a tree graph.

This implementation tries all permutations of vertex labels and checks if any are a graceful labeling.

Given a list of integer numbers, find a correct way of inserting the arithmetic signs such that the result is a correct equation.

Generate \(k\)-regular graphs with \(n\) vertexes.

Return non-negative integers in full words.

Identifiers in the Ada programming language have the syntax described by the diagram below.

Write a function which checks whether a given string is a legal identifier.

Returns a solution for a given Sudoku puzzle.

Both will be expressed as a list of 9 rows. Each row will be a list of 9 numbers from 0 to 9, where 0 signifies a blank spot.

Solve a nonogram.

Solve a crossword puzzle.