100 doors:
24 game:
24 game/Solve:
9 billion names of God the integer:
99 Bottles of Beer:

A+B:
ABC Problem:
Abstract type:
Abundant, deficient and perfect number classifications:
Accumulator factory:
Ackermann function:
Active Directory/Connect:
Active Directory/Search for a user:
Active object:
Add a variable to a class instance at runtime:
Address of a variable:
AKS test for primes:
Align columns:
Aliquot sequence classifications:
Almost prime:
Amb:
Amicable pairs:
Anagrams:
Anagrams/Deranged anagrams:
Animate a pendulum:
Animation:
Anonymous recursion:
Append a record to the end of a text file:
Apply a callback to an array:
Arbitrary-precision integers (included):
Arena storage pool:
Arithmetic evaluation:
Arithmetic-geometric mean:
Arithmetic-geometric mean/Calculate Pi:
Arithmetic/Complex:
Arithmetic/Integer:
Arithmetic/Rational:
Array concatenation:
Arrays:
Assertions:
Associative array/Creation:
Associative array/Iteration:
Atomic updates:
Average loop length:
Averages/Arithmetic mean:
Averages/Mean angle:
Averages/Mean time of day:
Averages/Median:
Averages/Mode:
Averages/Pythagorean means:
Averages/Root mean square:
Averages/Simple moving average:

Balanced brackets:
Balanced ternary:
Benford's law: #'
Bernoulli numbers:
Best shuffle:
Binary digits:
Binary search:
Binary strings:
Bitcoin/address validation:
Bitcoin/public point to address:
Bitmap:
Bitmap/Bresenham's line algorithm: #'
Bitmap/Bézier curves/Cubic:
Bitmap/Bézier curves/Quadratic:
Bitmap/Flood fill:
Bitmap/Histogram:
Bitmap/Midpoint circle algorithm:
Bitmap/PPM conversion through a pipe:
Bitmap/Read a PPM file:
Bitmap/Read an image through a pipe:
Bitmap/Write a PPM file:
Bitwise IO:
Bitwise operations:
Boolean values:
Box the compass:
Break OO privacy:
Brownian tree:
Bulls and cows:
Bulls and cows/Player:

Caesar cipher:
Calendar:
Calendar - for "REAL" programmers:
Call a foreign-language function:
Call a function:
Call a function in a shared library:
Call an object method:
Canny edge detector:
Carmichael 3 strong pseudoprimes:
Case-sensitivity of identifiers:
Casting out nines:
Catalan numbers:
Catalan numbers/Pascal's triangle: #'
Catamorphism:
Catmull–Clark subdivision surface:
Character codes:
Chat server:
Check Machin-like formulas:
Check that file exists:
Checkpoint synchronization:
Chinese remainder theorem:
Cholesky decomposition:
Circles of given radius through two points:
Classes:
Closest-pair problem:
Closures/Value capture:
Collections:
Color of a screen pixel:
Color quantization:
Colour bars/Display:
Colour pinstripe/Display:
Colour pinstripe/Printer:
Combinations:
Combinations and permutations:
Combinations with repetitions:
Comma quibbling:
Command-line arguments:
Comments:
Compare sorting algorithms' performance: #'
Compile-time calculation:
Compound data type:
Concurrent computing:
Conditional structures:
Conjugate transpose:
Constrained genericity:
Constrained random points on a circle:
Continued fraction:
Continued fraction/Arithmetic/Construct from rational number:
Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N):
Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N1, Contined Fraction N2):
Convert decimal number to rational:
Conway's Game of Life: #'
Copy a string:
Count in factors:
Count in octal:
Count occurrences of a substring:
Count the coins:
CRC-32:
Create a file:
Create a file on magnetic tape:
Create a two-dimensional array at runtime:
Create an HTML table:
Create an object at a given address:
CSV data manipulation:
CSV to HTML translation:
Currying:
Cut a rectangle:

Date format:
Date manipulation:
Day of the week:
Deal cards for FreeCell:
Death Star:
Deconvolution/1D:
Deconvolution/2D+:
Deepcopy:
Define a primitive data type:
Delegates:
Delete a file:
Detect division by zero:
Determine if a string is numeric:
Determine if only one instance is running:
Digital root:
Digital root/Multiplicative digital root:
Dinesman's multiple-dwelling problem: #'
Dining philosophers:
Discordian date:
Distributed programming:
DNS query:
Documentation:
Dot product:
Doubly-linked list/Definition:
Doubly-linked list/Element definition:
Doubly-linked list/Element insertion:
Doubly-linked list/Traversal:
Dragon curve:
Draw a clock:
Draw a cuboid:
Draw a sphere:
Dutch national flag problem:
Dynamic variable names:

Echo server:
Element-wise operations:
Empty directory:
Empty program:
Empty string:
Enforced immutability:
Entropy:
Enumerations:
Environment variables:
Equilibrium index:
Ethiopian multiplication:
Euler method:
Evaluate binomial coefficients:
Even or odd:
Events:
Evolutionary algorithm:
Exceptions:
Exceptions/Catch an exception thrown in a nested call:
Executable library:
Execute a Markov algorithm:
Execute a system command:
Execute Brain****:
Execute HQ9+:
Execute SNUSP:
Exponentiation operator:
Extend your language:
Extensible prime generator:
Extreme floating point values:

Factorial:
Factors of a Mersenne number:
Factors of an integer:
Fast Fourier transform:
Fibonacci n-step number sequences:
Fibonacci sequence:
Fibonacci word:
Fibonacci word/fractal:
File input/output:
File modification time:
File size:
Filter:
Find common directory path:
Find largest left truncatable prime in a given base:
Find limit of recursion:
Find the last Sunday of each month:
Find the missing permutation:
First class environments:
First-class functions:
First-class functions/Use numbers analogously:
Five weekends:
FizzBuzz:
Flatten a list:
Flipping bits game:
Flow-control structures:
Floyd's triangle: #'
Forest fire:
Fork:
Formal power series:
Formatted numeric output:
Forward difference:
Four bit adder:
Fractal tree:
Fractran:
Function composition:
Function definition:
Function frequency:
Function prototype:

Galton box animation:
Gamma function:
Gaussian elimination:
Generate Chess960 starting position:
Generate lower case ASCII alphabet:
Generator/Exponential:
Generic swap:
Globally replace text in several files:
Go Fish:
Gray code:
Grayscale image:
Greatest common divisor:
Greatest element of a list:
Greatest subsequential sum:
Greyscale bars/Display:
Guess the number:
Guess the number/With feedback:
Guess the number/With feedback (player):
GUI component interaction:
GUI enabling/disabling of controls:
GUI/Maximum window dimensions:

Hailstone sequence:
Hamming numbers:
Handle a signal:
Happy numbers:
Harshad or Niven series:
Hash from two arrays:
Hash join:
Haversine formula:
Hello world/Graphical:
Hello world/Line printer:
Hello world/Newbie:
Hello world/Newline omission:
Hello world/Standard error:
Hello world/Text:
Hello world/Web server:
Here document:
Heronian triangles:
Hickerson series of almost integers:
Higher-order functions:
History variables:
Hofstadter Figure-Figure sequences:
Hofstadter Q sequence:
Hofstadter-Conway $10,000 sequence:
Holidays related to Easter:
Honeycombs:
Horizontal sundial calculations:
Horner's rule for polynomial evaluation: #'
Host introspection:
Hostname:
Hough transform:
HTTP:
HTTPS:
HTTPS/Authenticated:
HTTPS/Client-authenticated:
Huffman coding:

I before E except after C:
IBAN:
Identity matrix:
Image convolution:
Image noise:
Include a file:
Increment a numerical string:
Infinity:
Inheritance/Multiple:
Inheritance/Single:
Input loop:
Integer comparison:
Integer overflow:
Integer sequence:
Interactive programming:
Introspection:
Inverted index:
Inverted syntax:
Iterated digits squaring:

Jensen's Device: #'
Josephus problem:
Joystick position:
JSON:
Jump anywhere:

K-d tree:
K-means++ clustering:
Kaprekar numbers:
Keyboard input/Flush the keyboard buffer:
Keyboard input/Keypress check:
Keyboard input/Obtain a Y or N response:
Keyboard macros:
Knapsack problem/0-1:
Knapsack problem/Bounded:
Knapsack problem/Continuous:
Knapsack problem/Unbounded:
Knight's tour: #'
Knuth shuffle:
Knuth's algorithm S: #'

Langton's ant: #'
Largest int from concatenated ints:
Last Friday of each month:
Last letter-first letter:
Leap year:
Least common multiple:
Left factorials:
Letter frequency:
Levenshtein distance:
Linear congruential generator:
List comprehensions:
Literals/Floating point:
Literals/Integer:
Literals/String:
Logical operations:
Long multiplication:
Longest common subsequence:
Longest increasing subsequence:
Longest string challenge:
Look-and-say sequence:
Loop over multiple arrays simultaneously:
Loops/Break:
Loops/Continue:
Loops/Do-while:
Loops/Downward for:
Loops/For:
Loops/For with a specified step:
Loops/Foreach:
Loops/Infinite:
Loops/N plus one half:
Loops/Nested:
Loops/While:
LU decomposition:
Lucas-Lehmer test:
Ludic numbers:
Luhn test of credit card numbers:
LZW compression:

Machine code:
Mad Libs:
Magic squares of odd order:
Main step of GOST 28147-89:
Make directory path:
Man or boy test:
Mandelbrot set:
Map range:
Matrix arithmetic:
Matrix multiplication:
Matrix transposition:
Matrix-exponentiation operator:
Maximum triangle path sum:
Maze generation:
Maze solving:
MD4:
MD5:
MD5/Implementation:
Median filter:
Memory allocation:
Memory layout of a data structure:
Menu:
Metaprogramming:
Metered concurrency:
Metronome:
Middle three digits:
Miller-Rabin primality test:
Minesweeper game:
Modular exponentiation:
Modular inverse:
Monte Carlo methods:
Monty Hall problem:
Morse code:
Mouse position:
Move-to-front algorithm:
Multifactorial:
Multiple distinct objects:
Multiple regression:
Multiplication tables:
Multiplicative order:
Multisplit:
Munching squares:
Mutual recursion:

N'th: #'
N-queens problem:
Named parameters:
Narcissist:
Narcissistic decimal number:
Natural sorting:
Nautical bell:
Non-continuous subsequences:
Non-decimal radices/Convert:
Non-decimal radices/Input:
Non-decimal radices/Output:
Nth root:
Null object:
Number names:
Number reversal game:
Numeric error propagation:
Numerical integration:
Numerical integration/Gauss-Legendre Quadrature:

Object serialization:
Odd word problem:
Old lady swallowed a fly:
OLE Automation:
One of n lines in a file:
One-dimensional cellular automata:
OpenGL:
Operator precedence:
Optional parameters:
Order disjoint list items:
Order two numerical lists:
Ordered Partitions:
Ordered words:

Palindrome detection:
Pangram checker:
Paraffins:
Parallel calculations:
Parametric polymorphism:
Parametrized SQL statement:
Parse an IP Address:
Parsing/RPN calculator algorithm:
Parsing/RPN to infix conversion:
Parsing/Shunting-yard algorithm:
Partial function application:
Pascal's triangle: #'
Pascal's triangle/Puzzle: #'
Pattern matching:
Penney's game: #'
Percentage difference between images:
Percolation/Bond percolation:
Percolation/Mean cluster density:
Percolation/Mean run density:
Percolation/Site percolation:
Perfect numbers:
Permutation test:
Permutations:
Permutations by swapping:
Permutations/Derangements:
Permutations/Rank of a permutation:
Pernicious numbers:
Phrase reversals:
Pi:
Pick random element:
Pig the dice game:
Pig the dice game/Player:
Pinstripe/Display:
Pinstripe/Printer:
Play recorded sounds:
Playing cards:
Plot coordinate pairs:
Pointers and references:
Polymorphic copy:
Polymorphism:
Polynomial long division:
Polynomial regression:
Power set:
Pragmatic directives:
Price fraction:
Primality by trial division:
Prime decomposition:
Priority queue:
Probabilistic choice:
Problem of Apollonius:
Program name:
Program termination:
Pythagorean triples:

QR decomposition:
Quaternion type:
Queue/Definition:
Queue/Usage:
Quickselect algorithm:
Quine:

Random number generator (device):
Random number generator (included):
Random numbers:
Range expansion:
Range extraction:
Ranking methods:
Rate counter:
Ray-casting algorithm:
RCRPG:
Read a configuration file:
Read a file line by line:
Read a specific line from a file:
Read entire file:
Real constants and functions:
Record sound:
Reduced row echelon form:
Regular expressions:
Remove duplicate elements:
Remove lines from a file:
Rename a file:
Rendezvous:
Rep-string:
Repeat a string:
Resistor mesh:
Respond to an unknown method call:
Return multiple values:
Reverse a string:
Reverse words in a string:
RIPEMD-160:
Rock-paper-scissors:
Roman numerals/Decode:
Roman numerals/Encode:
Roots of a function:
Roots of a quadratic function:
Roots of unity:

# XXX - These break the parser currently:
# Rosetta Code/Count examples:
# Rosetta Code/Find bare lang tags:
# Rosetta Code/Find unimplemented tasks:
# Rosetta Code/Fix code tags:
# Rosetta Code/Rank languages by popularity:

Rot-13:
RSA code:
Run-length encoding:
Runge-Kutta method:
Runtime evaluation:
Runtime evaluation/In an environment:

S-Expressions:
Safe addition:
Same Fringe:
Scope modifiers:
Scope/Function names and labels:
Search a list:
Secure temporary file:
SEDOLs:
Self-describing numbers:
Self-referential sequence:
Semiprime:
Semordnilap:
Send an unknown method call:
Send email:
Sequence of non-squares:
Sequence of primes by Trial Division:
Set:
Set consolidation:
Set of real numbers:
Set puzzle:
Seven-sided dice from five-sided dice:
SHA-1:
SHA-256:
Shell one-liner:
Short-circuit evaluation:
Show the epoch:
Sierpinski carpet:
Sierpinski triangle:
Sierpinski triangle/Graphical:
Sieve of Eratosthenes:
Simple database:
Simple windowed application:
Simulate input/Keyboard:
Simulate input/Mouse:
Singleton:
Singly-linked list/Element definition:
Singly-linked list/Element insertion:
Singly-linked list/Traversal:
Sleep:
SOAP:
Sockets:
Sokoban:
Solve a Hidato puzzle:
Solve a Holy Knight's tour: #'
Solve a Hopido puzzle:
Solve a Numbrix puzzle:
Solve the no connection puzzle:
Sort an array of composite structures:
Sort an integer array:
Sort disjoint sublist:
Sort stability:
Sort using a custom comparator:
Sorting algorithms/Bead sort:
Sorting algorithms/Bogosort:
Sorting algorithms/Bubble sort:
Sorting algorithms/Cocktail sort:
Sorting algorithms/Comb sort:
Sorting algorithms/Counting sort:
Sorting algorithms/Gnome sort:
Sorting algorithms/Heapsort:
Sorting algorithms/Insertion sort:
Sorting algorithms/Merge sort:
Sorting algorithms/Pancake sort:
Sorting algorithms/Permutation sort:
Sorting algorithms/Quicksort:
Sorting algorithms/Radix sort:
Sorting algorithms/Selection sort:
Sorting algorithms/Shell sort:
Sorting algorithms/Sleep sort:
Sorting algorithms/Stooge sort:
Sorting algorithms/Strand sort:
Soundex:
Sparkline in unicode:
Special characters:
Special variables:
Speech synthesis:
Spiral matrix:
SQL-based authentication:
Stable marriage problem:
Stack:
Stack traces:
Stair-climbing puzzle:
Standard deviation:
Start from a main routine:
State name puzzle:
Statistics/Basic:
Stem-and-leaf plot:
Stern-Brocot sequence:
String append:
String case:
String comparison:
String concatenation:
String interpolation (included):
String length:
String matching:
String prepend:
Strip a set of characters from a string:
Strip block comments:
Strip comments from a string:
Strip control codes and extended characters from a string:
Strip whitespace from a string/Top and tail:
Substring:
Substring/Top and tail:
Subtractive generator:
Sudoku:
Sum and product of an array:
Sum digits of an integer:
Sum multiples of 3 and 5:
Sum of a series:
Sum of squares:
Sutherland-Hodgman polygon clipping:
Symmetric difference:
Synchronous concurrency:
System time:

Table creation/Postal addresses:
Take notes on the command line:
Temperature conversion:
Terminal control/Clear the screen:
Terminal control/Coloured text:
Terminal control/Cursor movement:
Terminal control/Cursor positioning:
Terminal control/Dimensions:
Terminal control/Display an extended character:
Terminal control/Hiding the cursor:
Terminal control/Inverse video:
Terminal control/Positional read:
Terminal control/Preserve screen:
Terminal control/Ringing the terminal bell:
Terminal control/Unicode output:
Ternary logic:
Test a function:
Text processing/1:
Text processing/2:
Text processing/Max licenses in use:
Textonyms:
The ISAAC Cipher:
The Twelve Days of Christmas:
Thiele's interpolation formula: #'
Tic-tac-toe:
Time a function:
Tokenize a string:
Top rank per group:
Topic variable:
Topological sort:
Topswops:
Total circles area:
Towers of Hanoi:
Trabb Pardo–Knuth algorithm:
Tree traversal:
Trigonometric functions:
Truncatable primes:
Truncate a file:
Twelve statements:

Ulam spiral (for primes):
Unbias a random generator:
Undefined values:
Unicode strings:
Unicode variable names:
Universal Turing machine:
Unix/ls:
Update a configuration file:
URL decoding:
URL encoding:
Use another language to call a function:
User input/Graphical:
User input/Text:

Vampire number:
Van der Corput sequence:
Variable size/Get:
Variable size/Set:
Variable-length quantity:
Variables:
Variadic function:
Vector products:
Verify distribution uniformity/Chi-squared test:
Verify distribution uniformity/Naive:
Video display modes:
Vigenère cipher:
Vigenère cipher/Cryptanalysis:
Visualize a tree:
Vogel's approximation method: #'
Voronoi diagram:

Walk a directory/Non-recursively:
Walk a directory/Recursively:
Web scraping:
Window creation:
Window creation/X11:
Window management:
Wireworld:
Word wrap:
World Cup group stage:
Write float arrays to a text file:
Write language name in 3D ASCII:
Write to Windows event log:

Xiaolin Wu's line algorithm: #'
XML/DOM serialization:
XML/Input:
XML/Output:
XML/XPath:

Y combinator:
Yahoo! search interface:
Yin and yang:

Zebra puzzle:
Zeckendorf arithmetic:
Zeckendorf number representation:
Zero to the zero power:
Zhang-Suen thinning algorithm:
Zig-zag matrix: