RosettaCodeData/Conf/task.yaml

100 doors:
24 game:
24 game/Solve:
99 Bottles of Beer:

A+B:
Abstract type:
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:
Align columns:
Anagrams:
Anagrams/Deranged anagrams:
Animate a pendulum:
Animation:
Anonymous recursion:
Apply a callback to an array:
Arbitrary-precision integers (included):
Arena storage pool:
Arithmetic evaluation:
Arithmetic-geometric mean:
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:
Best shuffle:
Binary digits:
Binary search:
Binary strings:
Bitcoin/address validation:
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:
Catalan numbers:
Catmull–Clark subdivision surface:
Character codes:
Character matching:
Chat server:
Check Machin-like formulas:
Check that file exists:
Checkpoint synchronization:
Cholesky decomposition:
Classes:
Closest-pair problem:
Collections:
Color of a screen pixel:
Color quantization:
Colour bars/Display:
Colour pinstripe/Display:
Colour pinstripe/Printer:
Combinations:
Combinations with repetitions:
Command-line arguments:
Comments:
Compare sorting algorithms' performance:    #'
Compile-time calculation:
Compound data type:
Concurrent computing:
Conditional structures:
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):
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 to HTML translation:
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:
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 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 Brainf***:
Execute HQ9+:
Execute SNUSP:
Exponentiation operator:
Extend your language:
Extreme floating point values:

Factorial:
Factors of a Mersenne number:
Factors of an integer:
Fast Fourier transform:
Fibonacci n-step number sequences:
Fibonacci sequence:
File IO:
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 missing permutation:
First class environments:
First-class functions:
First-class functions/Use numbers analogously:
Five weekends:
FizzBuzz:
Flatten a list:
Flow-control structures:
Floyd's triangle:           #'
Forest fire:
Fork:
Formal power series:
Formatted numeric output:
Forward difference:
Four bit adder:
Fractal tree:
Function composition:
Function definition:
Function frequency:
Function prototype:

Galton box animation:
Gamma function:
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:
Haversine formula:
Hello world/Graphical:
Hello world/Line printer:
Hello world/Newline omission:
Hello world/Standard error:
Hello world/Text:
Hello world/Web server:
Here document:
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:
Identity matrix:
Image convolution:
Image noise:
Include a file:
Increment a numerical string:
Infinity:
Inheritance/Multiple:
Inheritance/Single:
Input loop:
Integer comparison:
Integer sequence:
Interactive programming:
Introspection:
Inverted index:
Inverted syntax:

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

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:
Letter frequency:
Levenshtein distance:
Linear congruential generator:
List comprehensions:
Literals/Floating point:
Literals/Integer:
Literals/String:
Logical operations:
Long multiplication:
Longest common 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:
Luhn test of credit card numbers:
LZW compression:

Mad Libs:
Main step of GOST 28147-89:
Man or boy test:
Mandelbrot set:
Map range:
Matrix arithmetic:
Matrix multiplication:
Matrix transposition:
Matrix-exponentiation operator:
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:
Multifactorial:
Multiple distinct objects:
Multiple regression:
Multiplication tables:
Multiplicative order:
Multisplit:
Mutex:
Mutual recursion:

N-queens problem:
Named parameters:
Narcissist:
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:
OLE Automation:
One of n lines in a file:
One-dimensional cellular automata:
OpenGL:
Operator precedence:
Optional parameters:
Order two numerical lists:
Ordered Partitions:
Ordered words:

Palindrome detection:
Pangram checker:
Parallel calculations:
Parametric polymorphism:
Parametrized SQL statement:
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:
Percentage difference between images:
Perfect numbers:
Permutation test:
Permutations:
Permutations by swapping:
Permutations/Derangements:
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:
Quine:

Random number generator (device):
Random number generator (included):
Random numbers:
Range expansion:
Range extraction:
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:
Repeat a string:
Resistor mesh:
Respond to an unknown method call:
Return multiple values:
Reverse 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:
Rosetta Code/Count examples:
Rosetta Code/Find unimplemented tasks:
Rosetta Code/Fix code tags:
Rosetta Code/Rank languages by popularity:
Rot-13:
Run-length encoding:
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:
Semordnilap:
Send an unknown method call:
Send email:
Sequence of non-squares:
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:
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:
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:
Stem-and-leaf plot:
String case:
String comparison:
String concatenation:
String interpolation (included):
String length:
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 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:
Thiele's interpolation formula:         #'
Tic-tac-toe:
Time a function:
Tokenize a string:
Top rank per group:
Topic variable:
Topological sort:
Topswops:
Towers of Hanoi:
Trabb Pardo–Knuth algorithm:
Tree traversal:
Trigonometric functions:
Truncatable primes:
Truncate a file:
Twelve statements:

Unbias a random generator:
Undefined values:
Unicode strings:
Unicode variable names:
Universal Turing machine:
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:
Voronoi diagram:

Walk a directory/Non-recursively:
Walk a directory/Recursively:
Web scraping:
Window creation:
Window creation/X11:
Window management:
Wireworld:
Word wrap:
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:
Zig-zag matrix: