Rosetta Code/List authors of task descriptions

Revision as of 20:41, 12 November 2017 by Thundergnat (talk | contribs) (Update table)

In this task, the goal is to compile an authorship list for task descriptions. A pseudocode example (in imperative style) that should accomplish this is as follows:

Rosetta Code/List authors of task descriptions is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

<lang pseudocode>for each task page

 grab page source, discard everything after the first ==section==.

Cache as $previous. Note $author.

 for each revision
   grab page source, discard everything after first ==section==.

Cache as $previous2. Note $author2

   compare $previous2 to $previous. If different, record $author to $list.
   replace $previous with $previous2
   replace $author with $author2</lang>

The following resources for HTTP interface information for MediaWiki may prove to be useful:

Conversely, some languages have libraries which abstract these interfaces into language-native idioms. Use of these abstractions is perfectly fine.


Please DO NOT add a full output for each programming language; just show a representative sample. One full list is useful. Multiple full lists just use space and bandwidth.

As of 2017-11-12 | Total: 1069 / Tasks: 867 / Draft Tasks: 202 / By 245 Authors
UserAuthored
    1. 2013-05-16 - Draft: Names to numbers
    2. 2013-05-16 - Draft: Solving coin problems
      1. 2009-11-12 - Task: Soundex
        1. 2015-05-04 - Task: Draw a rotating cube
          1. 2008-03-14 - Task: Sierpinski carpet
          2. 2008-03-14 - Task: Sierpinski triangle
            1. 2008-12-03 - Task: Top rank per group
              1. 2011-03-24 - Task: RSA code
                1. 2008-08-03 - Task: Zig-zag matrix
                  1. 2008-08-02 - Task: SEDOLs
                    1. 2007-04-07 - Task: Random numbers
                      1. 2007-04-07 - Task: Check that file exists
                      2. 2007-04-07 - Task: Create a file
                      3. 2007-04-07 - Task: Delete a file
                      4. 2007-04-07 - Task: File modification time
                      5. 2007-04-07 - Task: File size
                      6. 2007-04-07 - Task: Rename a file
                        1. 2007-09-18 - Task: Function definition
                          1. 2007-02-24 - Task: Compound data type
                          2. 2007-02-22 - Task: Copy a string
                          3. 2007-02-23 - Task: Enumerations
                          4. 2007-02-23 - Task: Increment a numerical string
                          5. 2007-02-23 - Task: Polymorphism
                          6. 2007-02-24 - Task: Stack
                            1. 2007-10-30 - Task: Singly-linked list/Traversal
                              1. 2008-03-07 - Task: Non-decimal radices/Convert
                                1. 2009-07-17 - Task: Sorting algorithms/Heapsort
                                  1. 2011-12-02 - Task: Haversine formula
                                    1. 2010-07-20 - Task: Discordian date
                                    2. 2010-07-20 - Task: Leap year
                                      1. 2010-09-21 - Task: Narcissist
                                        1. 2011-11-30 - Task: Paraffins
                                          1. 2011-06-09 - Draft: Aspect Oriented Programming
                                            1. 2007-12-09 - Task: Matrix multiplication
                                              1. 2012-03-05 - Task: Canny edge detector
                                                1. 2011-02-07 - Task: Ordered Partitions
                                                  1. 2009-03-31 - Task: Mandelbrot set
                                                    1. 2011-01-10 - Task: Levenshtein distance
                                                      1. 2008-05-07 - Task: Sorting algorithms/Bogosort
                                                      2. 2008-05-08 - Task: Sorting algorithms/Permutation sort
                                                        1. 2011-03-08 - Task: Create an HTML table
                                                          1. 2007-11-07 - Task: List comprehensions
                                                            1. 2007-11-06 - Task: Pattern matching
                                                              1. 2008-04-18 - Task: Reverse a string
                                                                1. 2011-05-04 - Task: Sorting algorithms/Strand sort
                                                                  1. 2011-10-28 - Task: Pythagoras tree
                                                                    1. 2007-02-13 - Task: Command-line arguments
                                                                      1. 2008-05-20 - Task: Sorting algorithms/Shell sort
                                                                        1. 2008-09-25 - Task: HTTP
                                                                          1. 2010-12-30 - Task: Record sound
                                                                            1. 2007-01-15 - Task: Window creation
                                                                              1. 2007-01-22 - Task: Associative array/Creation
                                                                              2. 2007-02-06 - Task: Fork
                                                                              3. 2007-01-23 - Task: Table creation/Postal addresses
                                                                                1. 2008-08-17 - Task: Factorial
                                                                                  1. 2010-11-23 - Task: Anonymous recursion
                                                                                  2. 2010-12-10 - Task: Chat server
                                                                                  3. 2012-04-24 - Draft: Chess player
                                                                                  4. 2010-08-27 - Task: Extend your language
                                                                                  5. 2011-06-30 - Task: First class environments
                                                                                  6. 2011-11-02 - Task: Function frequency
                                                                                  7. 2010-08-23 - Task: GUI component interaction
                                                                                  8. 2010-08-23 - Task: GUI enabling/disabling of controls
                                                                                  9. 2010-12-14 - Task: Maze generation
                                                                                  10. 2010-12-15 - Task: Maze solving
                                                                                  11. 2010-08-24 - Task: Morse code
                                                                                  12. 2010-12-15 - Task: Parallel calculations
                                                                                  13. 2011-01-11 - Task: Random number generator (device)
                                                                                    1. 2007-01-27 - Task: Classes
                                                                                    2. 2007-01-24 - Task: Walk a directory/Non-recursively
                                                                                    3. 2007-01-24 - Task: XML/DOM serialization
                                                                                      1. 2011-12-08 - Draft: Dijkstra's algorithm
                                                                                        1. 2014-01-20 - Task: Fractran
                                                                                        2. 2015-07-22 - Task: URL parser
                                                                                          1. 2010-04-11 - Task: Evaluate binomial coefficients
                                                                                            1. 2011-10-30 - Task: Langton's ant
                                                                                              1. 2016-12-03 - Draft: Diversity prediction theorem
                                                                                              2. 2016-09-22 - Task: Munchausen numbers
                                                                                              3. 2016-08-29 - Draft: Sattolo cycle
                                                                                              4. 2016-10-04 - Draft: Two Sum
                                                                                                1. 2017-04-05 - Task: Kronecker product
                                                                                                2. 2017-04-05 - Task: Kronecker product based fractals
                                                                                                  1. 2011-03-07 - Task: Cholesky decomposition
                                                                                                  2. 2011-06-08 - Task: Element-wise operations
                                                                                                  3. 2011-03-06 - Task: Euler method
                                                                                                  4. 2011-03-11 - Task: LU decomposition
                                                                                                  5. 2011-05-28 - Task: Numerical integration/Gauss-Legendre Quadrature
                                                                                                  6. 2011-06-17 - Task: QR decomposition
                                                                                                  7. 2017-03-05 - Task: UTF-8 encode and decode
                                                                                                    1. 2011-01-24 - Draft: Decision tables
                                                                                                    2. 2010-04-20 - Task: Find limit of recursion
                                                                                                    3. 2011-06-29 - Task: History variables
                                                                                                    4. 2011-06-05 - Task: Last letter-first letter
                                                                                                    5. 2010-03-15 - Task: Price fraction
                                                                                                    6. 2010-04-01 - Task: Take notes on the command line
                                                                                                    7. 2015-04-21 - Draft: Tasks without examples
                                                                                                      1. 2007-01-23 - Task: SOAP
                                                                                                        1. 2008-03-22 - Task: Pascal's triangle/Puzzle
                                                                                                        2. 2008-06-07 - Task: Power set
                                                                                                          1. 2010-05-07 - Task: Write to Windows event log
                                                                                                            1. 2013-10-14 - Draft: ASCII art diagram converter
                                                                                                            2. 2013-01-06 - Draft: Boids
                                                                                                            3. 2015-01-14 - Draft: Dice game probabilities
                                                                                                            4. 2014-10-28 - Draft: Free polyominoes enumeration
                                                                                                            5. 2013-08-02 - Task: Generate lower case ASCII alphabet
                                                                                                            6. 2014-08-23 - Task: Iterated digits squaring
                                                                                                            7. 2014-02-20 - Task: Maximum triangle path sum
                                                                                                            8. 2013-11-21 - Task: Nonogram solver
                                                                                                            9. 2015-04-25 - Task: Sum and Product Puzzle
                                                                                                            10. 2012-09-15 - Task: Total circles area
                                                                                                              1. 2015-10-22 - Task: Write entire file
                                                                                                                1. 2014-05-17 - Draft: Repeat
                                                                                                                  1. 2011-08-16 - Task: Call an object method
                                                                                                                    1. 2014-07-22 - Task: The ISAAC Cipher
                                                                                                                      1. 2008-12-06 - Task: Bitmap
                                                                                                                      2. 2008-12-06 - Task: Bitmap/Bézier curves/Cubic
                                                                                                                      3. 2008-12-06 - Task: Bitmap/Bézier curves/Quadratic
                                                                                                                      4. 2008-12-06 - Task: Bitmap/Bresenham's line algorithm
                                                                                                                      5. 2008-12-06 - Task: Bitmap/Midpoint circle algorithm
                                                                                                                      6. 2008-12-06 - Task: Bitmap/PPM conversion through a pipe
                                                                                                                      7. 2008-12-06 - Task: Bitmap/Write a PPM file
                                                                                                                      8. 2010-01-06 - Task: Catmull–Clark subdivision surface
                                                                                                                      9. 2013-03-28 - Draft: Check output device is a terminal
                                                                                                                      10. 2010-09-23 - Task: Equilibrium index
                                                                                                                      11. 2008-12-07 - Task: Image convolution
                                                                                                                      12. 2011-11-05 - Task: Last Friday of each month
                                                                                                                      13. 2008-08-08 - Task: LZW compression
                                                                                                                      14. 2008-12-07 - Task: Median filter
                                                                                                                      15. 2009-09-12 - Task: N-queens problem
                                                                                                                      16. 2008-11-13 - Task: Percentage difference between images
                                                                                                                      17. 2010-01-02 - Draft: Process SMIL directives in XML data
                                                                                                                      18. 2008-08-26 - Task: Shell one-liner
                                                                                                                      19. 2008-11-13 - Task: Window creation/X11
                                                                                                                        1. 2007-01-28 - Task: Sort an integer array
                                                                                                                        2. 2007-01-30 - Task: Sort using a custom comparator
                                                                                                                        3. 2007-02-04 - Task: SQL-based authentication
                                                                                                                          1. 2010-01-25 - Task: Sorting algorithms/Comb sort
                                                                                                                            1. 2017-01-14 - Task: MAC Vendor Lookup
                                                                                                                              1. 2015-09-26 - Task: Array length
                                                                                                                              2. 2015-10-07 - Draft: Type detection
                                                                                                                                1. 2015-10-09 - Task: Search a list of records
                                                                                                                                  1. 2014-08-09 - Task: Make directory path
                                                                                                                                    1. 2010-10-15 - Task: String matching
                                                                                                                                      1. 2016-06-15 - Task: Stream Merge
                                                                                                                                        1. 2007-05-28 - Task: Arithmetic/Integer
                                                                                                                                        2. 2007-03-12 - Task: Comments
                                                                                                                                        3. 2008-12-05 - Task: Constrained genericity
                                                                                                                                        4. 2007-02-27 - Task: Create a two-dimensional array at runtime
                                                                                                                                        5. 2008-01-20 - Task: Infinity
                                                                                                                                        6. 2008-04-27 - Task: Inheritance/Multiple
                                                                                                                                        7. 2007-03-31 - Task: Integer comparison
                                                                                                                                        8. 2007-11-18 - Task: Logical operations
                                                                                                                                        9. 2008-04-18 - Task: Loops/Downward for
                                                                                                                                        10. 2008-04-18 - Task: Loops/N plus one half
                                                                                                                                        11. 2007-01-25 - Task: Pointers and references
                                                                                                                                        12. 2009-07-08 - Task: Tree traversal
                                                                                                                                          1. 2007-11-13 - Task: Literals/String
                                                                                                                                          2. 2007-11-13 - Task: Special characters
                                                                                                                                            1. 2007-01-21 - Task: Determine if a string is numeric
                                                                                                                                              1. 2010-11-01 - Task: Literals/Floating point
                                                                                                                                              2. 2012-06-29 - Task: Matrix arithmetic
                                                                                                                                              3. 2011-07-09 - Task: Rosetta Code/Find bare lang tags
                                                                                                                                              4. 2013-01-17 - Draft: Untrusted environment
                                                                                                                                                1. 2017-05-10 - Draft: Word break problem
                                                                                                                                                  1. 2011-05-05 - Draft: IRC gateway
                                                                                                                                                    1. 2007-01-24 - Task: Towers of Hanoi
                                                                                                                                                      1. 2007-11-26 - Task: Sockets
                                                                                                                                                        1. 2008-10-10 - Task: Host introspection
                                                                                                                                                        2. 2011-05-27 - Task: K-means++ clustering
                                                                                                                                                          1. 2013-06-10 - Draft: Deming's Funnel
                                                                                                                                                            1. 2009-04-24 - Task: Run-length encoding
                                                                                                                                                              1. 2010-09-02 - Task: Constrained random points on a circle
                                                                                                                                                                1. 2014-01-24 - Task: Chinese remainder theorem
                                                                                                                                                                  1. 2011-08-27 - Task: Send an unknown method call
                                                                                                                                                                    1. 2007-10-07 - Task: 100 doors
                                                                                                                                                                    2. 2007-10-07 - Task: FizzBuzz
                                                                                                                                                                    3. 2007-06-08 - Task: HTTPS/Authenticated
                                                                                                                                                                    4. 2007-06-08 - Task: OpenGL
                                                                                                                                                                      1. 2014-06-12 - Task: 2048
                                                                                                                                                                      2. 2014-06-03 - Task: FTP
                                                                                                                                                                      3. 2017-05-03 - Task: Retrieve and search chat history
                                                                                                                                                                        1. 2011-07-17 - Task: Deepcopy
                                                                                                                                                                        2. 2011-05-06 - Task: Galton box animation
                                                                                                                                                                        3. 2011-08-12 - Task: Longest string challenge
                                                                                                                                                                        4. 2010-09-29 - Task: MD5/Implementation
                                                                                                                                                                        5. 2011-05-06 - Task: Sierpinski triangle/Graphical
                                                                                                                                                                        6. 2011-08-29 - Task: State name puzzle
                                                                                                                                                                          1. 2010-10-01 - Draft: Create an object/Native demonstration
                                                                                                                                                                          2. 2009-05-06 - Task: Happy numbers
                                                                                                                                                                          3. 2010-10-30 - Task: Strip block comments
                                                                                                                                                                          4. 2010-10-14 - Task: Variable-length quantity
                                                                                                                                                                            1. 2008-03-28 - Task: Formal power series
                                                                                                                                                                            2. 2008-03-27 - Task: Non-continuous subsequences
                                                                                                                                                                            3. 2007-11-08 - Task: Parametric polymorphism
                                                                                                                                                                              1. 2009-12-28 - Task: Accumulator factory
                                                                                                                                                                              2. 2009-08-07 - Task: Animate a pendulum
                                                                                                                                                                              3. 2009-06-14 - Task: Animation
                                                                                                                                                                              4. 2009-06-12 - Task: Averages/Median
                                                                                                                                                                              5. 2009-06-13 - Task: Averages/Mode
                                                                                                                                                                              6. 2009-06-16 - Task: Cumulative standard deviation
                                                                                                                                                                              7. 2009-05-13 - Task: Echo server
                                                                                                                                                                              8. 2010-11-22 - Task: Generator/Exponential
                                                                                                                                                                              9. 2010-01-21 - Task: Hough transform
                                                                                                                                                                              10. 2009-06-01 - Task: HTTPS
                                                                                                                                                                              11. 2009-06-01 - Task: HTTPS/Client-authenticated
                                                                                                                                                                              12. 2009-06-28 - Task: Named parameters
                                                                                                                                                                              13. 2009-06-09 - Task: Non-decimal radices/Input
                                                                                                                                                                              14. 2009-06-03 - Task: Respond to an unknown method call
                                                                                                                                                                              15. 2012-10-15 - Draft: Rosetta Code/Tasks sorted by average lines of code
                                                                                                                                                                              16. 2011-04-24 - Task: Speech synthesis
                                                                                                                                                                              17. 2009-05-18 - Task: Stack traces
                                                                                                                                                                              18. 2010-03-23 - Task: Sutherland-Hodgman polygon clipping
                                                                                                                                                                              19. 2010-10-16 - Task: Terminal control/Ringing the terminal bell
                                                                                                                                                                              20. 2009-08-09 - Task: Verify distribution uniformity/Chi-squared test
                                                                                                                                                                              21. 2009-09-09 - Task: Wireworld
                                                                                                                                                                                1. 2008-11-20 - Task: Abstract type
                                                                                                                                                                                2. 2008-11-02 - Task: Active object
                                                                                                                                                                                3. 2009-03-22 - Task: Arena storage pool
                                                                                                                                                                                4. 2008-12-07 - Task: Bitmap/Histogram
                                                                                                                                                                                5. 2008-12-07 - Task: Bitmap/Read a PPM file
                                                                                                                                                                                6. 2009-08-11 - Task: Call a foreign-language function
                                                                                                                                                                                7. 2010-08-10 - Task: Checkpoint synchronization
                                                                                                                                                                                8. 2009-06-08 - Task: Create an object at a given address
                                                                                                                                                                                9. 2008-11-01 - Task: Dining philosophers
                                                                                                                                                                                10. 2009-06-10 - Task: Events
                                                                                                                                                                                11. 2008-12-07 - Task: Grayscale image
                                                                                                                                                                                12. 2009-06-11 - Task: Loops/Nested
                                                                                                                                                                                13. 2008-10-25 - Task: Polymorphic copy
                                                                                                                                                                                14. 2009-02-17 - Task: Rendezvous
                                                                                                                                                                                15. 2009-08-12 - Task: Safe addition
                                                                                                                                                                                16. 2009-08-11 - Task: Use another language to call a function
                                                                                                                                                                                  1. 2007-10-18 - Task: Sieve of Eratosthenes
                                                                                                                                                                                    1. 2011-02-27 - Task: Multisplit
                                                                                                                                                                                      1. 2015-03-03 - Task: JortSort
                                                                                                                                                                                        1. 2012-10-22 - Task: Create a file on magnetic tape
                                                                                                                                                                                          1. 2017-01-20 - Draft: Solve a Rubik's Cube
                                                                                                                                                                                            1. 2013-05-02 - Task: AVL tree
                                                                                                                                                                                              1. 2013-12-09 - Task: Poker hand analyser
                                                                                                                                                                                                1. 2016-10-19 - Task: Compiler/AST interpreter
                                                                                                                                                                                                2. 2016-10-22 - Task: Compiler/code generator
                                                                                                                                                                                                3. 2016-08-14 - Task: Compiler/lexical analyzer
                                                                                                                                                                                                4. 2016-09-28 - Task: Compiler/syntax analyzer
                                                                                                                                                                                                5. 2016-10-22 - Task: Compiler/virtual machine interpreter
                                                                                                                                                                                                  1. 2016-04-11 - Task: Babbage problem
                                                                                                                                                                                                  2. 2016-09-19 - Draft: French Republican calendar
                                                                                                                                                                                                    1. 2014-10-17 - Draft: I.Q. Puzzle
                                                                                                                                                                                                      1. 2012-01-03 - Draft: Find URI in text
                                                                                                                                                                                                      2. 2011-11-09 - Draft: Make a backup file
                                                                                                                                                                                                      3. 2011-11-28 - Task: Order two numerical lists
                                                                                                                                                                                                      4. 2011-11-02 - Draft: Readline interface
                                                                                                                                                                                                      5. 2011-11-22 - Draft: Rosetta Code/Run examples
                                                                                                                                                                                                      6. 2011-11-17 - Draft: Run as a daemon or service
                                                                                                                                                                                                      7. 2011-10-15 - Task: S-Expressions
                                                                                                                                                                                                      8. 2011-11-01 - Task: Simple database
                                                                                                                                                                                                      9. 2012-01-05 - Draft: Text to HTML
                                                                                                                                                                                                        1. 2015-10-09 - Task: Floyd-Warshall algorithm
                                                                                                                                                                                                          1. 2007-12-11 - Task: Arithmetic evaluation
                                                                                                                                                                                                          2. 2007-12-21 - Draft: Proof
                                                                                                                                                                                                            1. 2010-04-05 - Task: Sorting algorithms/Pancake sort
                                                                                                                                                                                                              1. 2007-01-21 - Task: Collections
                                                                                                                                                                                                                1. 2015-11-05 - Draft: Tetris
                                                                                                                                                                                                                  1. 2013-11-25 - Task: Hash join
                                                                                                                                                                                                                  2. 2013-12-31 - Task: Machine code
                                                                                                                                                                                                                    1. 2016-03-02 - Task: Archimedean spiral
                                                                                                                                                                                                                    2. 2016-03-01 - Task: Barnsley fern
                                                                                                                                                                                                                    3. 2010-12-11 - Task: Best shuffle
                                                                                                                                                                                                                    4. 2016-03-01 - Task: Chaos game
                                                                                                                                                                                                                    5. 2016-03-06 - Task: Julia set
                                                                                                                                                                                                                    6. 2016-03-16 - Task: Magic squares of doubly even order
                                                                                                                                                                                                                    7. 2016-03-16 - Task: Magic squares of singly even order
                                                                                                                                                                                                                    8. 2016-04-22 - Draft: Penrose tiling
                                                                                                                                                                                                                    9. 2015-04-21 - Task: Pentagram
                                                                                                                                                                                                                    10. 2016-03-27 - Draft: Pentomino tiling
                                                                                                                                                                                                                    11. 2016-04-25 - Draft: Perceptron
                                                                                                                                                                                                                    12. 2016-03-08 - Task: Plasma effect
                                                                                                                                                                                                                    13. 2016-03-09 - Task: Polyspiral
                                                                                                                                                                                                                    14. 2012-09-07 - Task: Semordnilap
                                                                                                                                                                                                                    15. 2013-02-09 - Task: Set puzzle
                                                                                                                                                                                                                    16. 2015-10-15 - Task: Sierpinski pentagon
                                                                                                                                                                                                                    17. 2015-10-16 - Task: Superellipse
                                                                                                                                                                                                                    18. 2013-02-12 - Task: Temperature conversion
                                                                                                                                                                                                                    19. 2013-03-22 - Task: Vampire number
                                                                                                                                                                                                                    20. 2016-03-26 - Task: Word search
                                                                                                                                                                                                                      1. 2016-01-28 - Draft: Addition chains
                                                                                                                                                                                                                      2. 2016-03-25 - Draft: Cipolla's algorithm
                                                                                                                                                                                                                      3. 2016-03-19 - Draft: Prime conspiracy
                                                                                                                                                                                                                      4. 2016-01-21 - Draft: Railway circuit
                                                                                                                                                                                                                      5. 2016-03-23 - Draft: Simulated annealing
                                                                                                                                                                                                                      6. 2016-03-28 - Draft: Tonelli-Shanks algorithm
                                                                                                                                                                                                                        1. 2007-12-24 - Task: Compare sorting algorithms' performance
                                                                                                                                                                                                                        2. 2007-12-24 - Task: Plot coordinate pairs
                                                                                                                                                                                                                        3. 2007-12-24 - Task: Polynomial regression
                                                                                                                                                                                                                        4. 2007-12-24 - Task: Time a function
                                                                                                                                                                                                                        5. 2007-12-24 - Task: Write float arrays to a text file
                                                                                                                                                                                                                          1. 2015-02-18 - Draft: Longest Common Substring
                                                                                                                                                                                                                            1. 2014-07-29 - Task: Integer overflow
                                                                                                                                                                                                                              1. 2016-12-31 - Task: 4-rings or 4-squares puzzle
                                                                                                                                                                                                                              2. 2017-09-17 - Draft: Abbreviations, automatic
                                                                                                                                                                                                                              3. 2017-09-17 - Draft: Abbreviations, easy
                                                                                                                                                                                                                              4. 2017-09-17 - Draft: Abbreviations, simple
                                                                                                                                                                                                                              5. 2014-03-11 - Task: Bernoulli numbers
                                                                                                                                                                                                                              6. 2014-04-05 - Task: Commatizing numbers
                                                                                                                                                                                                                              7. 2014-04-02 - Draft: Egyptian fractions
                                                                                                                                                                                                                              8. 2014-03-24 - Task: Emirp primes
                                                                                                                                                                                                                              9. 2014-03-18 - Task: Exponentiation order
                                                                                                                                                                                                                              10. 2014-03-31 - Task: Farey sequence
                                                                                                                                                                                                                              11. 2014-03-25 - Task: Find palindromic numbers in both binary and ternary bases
                                                                                                                                                                                                                              12. 2017-09-11 - Draft: Four is the number of letters in the ...
                                                                                                                                                                                                                              13. 2014-03-21 - Draft: Idiomatically determine all the characters that can be used for symbols
                                                                                                                                                                                                                              14. 2014-03-21 - Draft: Idiomatically determine all the lowercase and uppercase letters
                                                                                                                                                                                                                              15. 2015-06-02 - Draft: Knuth's power tree
                                                                                                                                                                                                                              16. 2014-03-29 - Task: Left factorials
                                                                                                                                                                                                                              17. 2017-05-20 - Task: Leonardo numbers
                                                                                                                                                                                                                              18. 2014-03-05 - Task: Lucky and even lucky numbers
                                                                                                                                                                                                                              19. 2014-03-20 - Task: Magic squares of odd order
                                                                                                                                                                                                                              20. 2017-03-03 - Task: Partition an integer X into N primes
                                                                                                                                                                                                                              21. 2014-03-12 - Task: Pernicious numbers
                                                                                                                                                                                                                              22. 2014-03-12 - Task: Population count
                                                                                                                                                                                                                              23. 2015-06-12 - Task: Primorial numbers
                                                                                                                                                                                                                              24. 2017-07-11 - Task: Pythagorean quadruples
                                                                                                                                                                                                                              25. 2014-03-27 - Task: Reverse words in a string
                                                                                                                                                                                                                              26. 2017-04-30 - Task: Sort three variables
                                                                                                                                                                                                                              27. 2017-09-07 - Draft: Spelling of ordinal numbers
                                                                                                                                                                                                                              28. 2016-12-30 - Task: Split a character string based on change of character
                                                                                                                                                                                                                              29. 2016-12-31 - Task: Sum to 100
                                                                                                                                                                                                                              30. 2014-03-14 - Task: Taxicab numbers
                                                                                                                                                                                                                              31. 2015-01-14 - Task: Ulam spiral (for primes)
                                                                                                                                                                                                                              32. 2014-03-18 - Task: Zero to the zero power
                                                                                                                                                                                                                                1. 2007-01-22 - Task: Apply a callback to an array
                                                                                                                                                                                                                                2. 2007-01-22 - Task: Filter
                                                                                                                                                                                                                                3. 2007-01-22 - Task: Hash from two arrays
                                                                                                                                                                                                                                4. 2007-01-22 - Task: Remove duplicate elements
                                                                                                                                                                                                                                5. 2007-01-22 - Task: XML/XPath
                                                                                                                                                                                                                                  1. 2009-07-10 - Task: Boolean values
                                                                                                                                                                                                                                  2. 2009-05-13 - Task: Date manipulation
                                                                                                                                                                                                                                  3. 2009-10-09 - Task: Doubly-linked list/Traversal
                                                                                                                                                                                                                                  4. 2009-08-06 - Task: Loop over multiple arrays simultaneously
                                                                                                                                                                                                                                  5. 2009-07-10 - Task: Loops/For with a specified step
                                                                                                                                                                                                                                  6. 2009-10-21 - Task: Repeat a string
                                                                                                                                                                                                                                    1. 2012-09-24 - Draft: Check input device is a terminal
                                                                                                                                                                                                                                    2. 2017-05-29 - Draft: Damm algorithm
                                                                                                                                                                                                                                      1. 2007-06-20 - Task: Greatest subsequential sum
                                                                                                                                                                                                                                        1. 2007-01-24 - Task: Higher-order functions
                                                                                                                                                                                                                                          1. 2007-11-14 - Task: Determine if only one instance is running
                                                                                                                                                                                                                                          2. 2008-12-25 - Task: Doubly-linked list/Definition
                                                                                                                                                                                                                                          3. 2008-12-25 - Task: XML/Input
                                                                                                                                                                                                                                          4. 2008-12-25 - Task: XML/Output
                                                                                                                                                                                                                                            1. 2015-10-12 - Draft: Substitution Cipher
                                                                                                                                                                                                                                              1. 2012-11-27 - Task: Bitcoin/address validation
                                                                                                                                                                                                                                              2. 2012-11-29 - Task: Bitcoin/public point to address
                                                                                                                                                                                                                                              3. 2015-10-11 - Draft: Display a linear combination
                                                                                                                                                                                                                                              4. 2014-02-27 - Task: Elementary cellular automaton
                                                                                                                                                                                                                                              5. 2014-03-20 - Draft: Elementary cellular automaton/Infinite length
                                                                                                                                                                                                                                              6. 2014-03-19 - Draft: Elementary cellular automaton/Random Number Generator
                                                                                                                                                                                                                                              7. 2012-11-30 - Draft: Elliptic curve arithmetic
                                                                                                                                                                                                                                              8. 2013-02-26 - Draft: Entropy/Narcissist
                                                                                                                                                                                                                                              9. 2013-04-03 - Task: FASTA format
                                                                                                                                                                                                                                              10. 2014-05-01 - Task: Generate Chess960 starting position
                                                                                                                                                                                                                                              11. 2015-12-11 - Draft: Generate random chess position
                                                                                                                                                                                                                                              12. 2015-10-13 - Draft: Geometric algebra
                                                                                                                                                                                                                                              13. 2014-05-08 - Draft: Index finite lists of positive integers
                                                                                                                                                                                                                                              14. 2013-05-02 - Draft: Levenshtein distance/Alignment
                                                                                                                                                                                                                                              15. 2013-02-21 - Draft: Modular arithmetic
                                                                                                                                                                                                                                              16. 2012-11-30 - Task: Modular inverse
                                                                                                                                                                                                                                              17. 2016-07-06 - Draft: Orbital elements
                                                                                                                                                                                                                                              18. 2014-03-05 - Draft: Perlin noise
                                                                                                                                                                                                                                              19. 2012-11-02 - Task: SHA-256
                                                                                                                                                                                                                                              20. 2013-02-22 - Draft: Shortest common supersequence
                                                                                                                                                                                                                                              21. 2013-05-10 - Draft: Suffix tree
                                                                                                                                                                                                                                              22. 2014-06-18 - Task: Test integerness
                                                                                                                                                                                                                                              23. 2013-01-24 - Task: Topic variable
                                                                                                                                                                                                                                                1. 2009-07-30 - Task: Arrays
                                                                                                                                                                                                                                                2. 2009-07-21 - Task: Execute HQ9+
                                                                                                                                                                                                                                                3. 2010-09-30 - Task: Image noise
                                                                                                                                                                                                                                                4. 2009-01-29 - Task: Rosetta Code/Fix code tags
                                                                                                                                                                                                                                                5. 2009-01-24 - Task: Rosetta Code/Rank languages by popularity
                                                                                                                                                                                                                                                6. 2009-05-03 - Task: Yahoo! search interface
                                                                                                                                                                                                                                                  1. 2015-05-26 - Draft: Calculate P-Value
                                                                                                                                                                                                                                                  2. 2017-11-01 - Draft: P-value correction
                                                                                                                                                                                                                                                    1. 2014-11-18 - Draft: One-time pad
                                                                                                                                                                                                                                                      1. 2008-08-10 - Task: Active Directory/Connect
                                                                                                                                                                                                                                                      2. 2008-08-06 - Task: Active Directory/Search for a user
                                                                                                                                                                                                                                                        1. 2015-01-04 - Draft: Sorting Algorithms/Circle Sort
                                                                                                                                                                                                                                                          1. 2016-08-21 - Draft: Color wheel
                                                                                                                                                                                                                                                            1. 2009-10-24 - Task: Stair-climbing puzzle
                                                                                                                                                                                                                                                              1. 2017-05-29 - Task: Cartesian product of two or more lists
                                                                                                                                                                                                                                                              2. 2016-12-06 - Task: Water collected between towers
                                                                                                                                                                                                                                                                1. 2013-04-16 - Task: Find the last Sunday of each month
                                                                                                                                                                                                                                                                  1. 2009-05-26 - Task: Memory allocation
                                                                                                                                                                                                                                                                  2. 2007-10-03 - Task: Sorting algorithms/Quicksort
                                                                                                                                                                                                                                                                    1. 2009-07-21 - Task: Sudoku
                                                                                                                                                                                                                                                                      1. 2014-08-11 - Draft: File extension is in extensions list
                                                                                                                                                                                                                                                                        1. 2013-12-19 - Task: The Twelve Days of Christmas
                                                                                                                                                                                                                                                                          1. 2017-02-04 - Task: Parallel Brute Force
                                                                                                                                                                                                                                                                            1. 2011-01-02 - Task: Enforced immutability
                                                                                                                                                                                                                                                                              1. 2007-08-03 - Task: Date format
                                                                                                                                                                                                                                                                                1. 2007-11-20 - Task: Rot-13
                                                                                                                                                                                                                                                                                2. 2007-10-22 - Task: Secure temporary file
                                                                                                                                                                                                                                                                                  1. 2015-08-02 - Draft: Chebyshev coefficients
                                                                                                                                                                                                                                                                                  2. 2015-07-31 - Draft: Particle Swarm Optimization
                                                                                                                                                                                                                                                                                  3. 2015-06-30 - Draft: Weather Routing
                                                                                                                                                                                                                                                                                    1. 2014-01-08 - Task: ABC Problem
                                                                                                                                                                                                                                                                                      1. 2007-05-08 - Task: Doubly-linked list/Element definition
                                                                                                                                                                                                                                                                                      2. 2007-07-05 - Task: Doubly-linked list/Element insertion
                                                                                                                                                                                                                                                                                        1. 2007-09-18 - Task: Add a variable to a class instance at runtime
                                                                                                                                                                                                                                                                                          1. 2017-08-14 - Draft: Word count
                                                                                                                                                                                                                                                                                            1. 2011-06-12 - Task: Caesar cipher
                                                                                                                                                                                                                                                                                            2. 2012-01-30 - Task: Conjugate transpose
                                                                                                                                                                                                                                                                                            3. 2011-09-18 - Task: Deal cards for FreeCell
                                                                                                                                                                                                                                                                                            4. 2011-05-16 - Task: DNS query
                                                                                                                                                                                                                                                                                            5. 2012-01-02 - Task: Empty directory
                                                                                                                                                                                                                                                                                            6. 2011-11-13 - Task: Even or odd
                                                                                                                                                                                                                                                                                            7. 2012-03-19 - Task: Identity matrix
                                                                                                                                                                                                                                                                                            8. 2011-05-19 - Task: Jump anywhere
                                                                                                                                                                                                                                                                                            9. 2011-03-30 - Task: Least common multiple
                                                                                                                                                                                                                                                                                            10. 2011-09-18 - Task: Letter frequency
                                                                                                                                                                                                                                                                                            11. 2011-06-30 - Task: Linear congruential generator
                                                                                                                                                                                                                                                                                            12. 2012-03-26 - Task: MD4
                                                                                                                                                                                                                                                                                            13. 2011-12-18 - Task: Modular exponentiation
                                                                                                                                                                                                                                                                                            14. 2011-10-09 - Task: Return multiple values
                                                                                                                                                                                                                                                                                            15. 2012-03-29 - Task: RIPEMD-160
                                                                                                                                                                                                                                                                                            16. 2011-09-16 - Task: Set
                                                                                                                                                                                                                                                                                            17. 2012-01-18 - Task: SHA-1
                                                                                                                                                                                                                                                                                            18. 2011-08-02 - Task: Subtractive generator
                                                                                                                                                                                                                                                                                              1. 2009-05-16 - Task: Atomic updates
                                                                                                                                                                                                                                                                                              2. 2007-08-18 - Task: Distributed programming
                                                                                                                                                                                                                                                                                              3. 2009-01-29 - Task: Multiple distinct objects
                                                                                                                                                                                                                                                                                              4. 2009-05-24 - Task: Optional parameters
                                                                                                                                                                                                                                                                                              5. 2009-06-11 - Task: Play recorded sounds
                                                                                                                                                                                                                                                                                              6. 2009-01-05 - Task: Queue/Usage
                                                                                                                                                                                                                                                                                              7. 2010-06-29 - Task: Read entire file
                                                                                                                                                                                                                                                                                              8. 2009-02-07 - Task: Rosetta Code/Find unimplemented tasks
                                                                                                                                                                                                                                                                                              9. 2009-02-17 - Task: Runtime evaluation
                                                                                                                                                                                                                                                                                              10. 2009-02-17 - Task: Runtime evaluation/In an environment
                                                                                                                                                                                                                                                                                              11. 2009-12-14 - Task: Stem-and-leaf plot
                                                                                                                                                                                                                                                                                              12. 2009-07-03 - Task: Variables
                                                                                                                                                                                                                                                                                                1. 2007-02-11 - Task: Formatted numeric output
                                                                                                                                                                                                                                                                                                2. 2007-02-11 - Task: String case
                                                                                                                                                                                                                                                                                                  1. 2017-07-13 - Draft: Base58Check encoding
                                                                                                                                                                                                                                                                                                    1. 2016-10-27 - Draft: Singly-linked list/Element removal
                                                                                                                                                                                                                                                                                                      1. 2012-09-18 - Task: Catamorphism
                                                                                                                                                                                                                                                                                                        1. 2011-01-19 - Task: Sorting algorithms/Radix sort
                                                                                                                                                                                                                                                                                                          1. 2014-01-08 - Draft: Input/Output for Lines of Text
                                                                                                                                                                                                                                                                                                          2. 2013-12-04 - Draft: Input/Output for Pairs of Numbers
                                                                                                                                                                                                                                                                                                            1. 2011-11-01 - Task: Balanced ternary
                                                                                                                                                                                                                                                                                                            2. 2011-08-11 - Task: Color quantization
                                                                                                                                                                                                                                                                                                            3. 2011-10-27 - Task: Count the coins
                                                                                                                                                                                                                                                                                                            4. 2011-10-08 - Task: Cut a rectangle
                                                                                                                                                                                                                                                                                                            5. 2011-07-03 - Task: Draw a clock
                                                                                                                                                                                                                                                                                                            6. 2011-09-28 - Draft: IPC via named pipe
                                                                                                                                                                                                                                                                                                            7. 2012-10-27 - Task: Josephus problem
                                                                                                                                                                                                                                                                                                            8. 2015-05-06 - Draft: List rooted trees
                                                                                                                                                                                                                                                                                                            9. 2011-11-03 - Task: Odd word problem
                                                                                                                                                                                                                                                                                                            10. 2011-08-04 - Task: Priority queue
                                                                                                                                                                                                                                                                                                            11. 2011-06-28 - Task: Pythagorean triples
                                                                                                                                                                                                                                                                                                            12. 2011-08-21 - Task: Resistor mesh
                                                                                                                                                                                                                                                                                                            13. 2011-09-30 - Task: Set of real numbers
                                                                                                                                                                                                                                                                                                            14. 2011-07-02 - Task: Statistics/Basic
                                                                                                                                                                                                                                                                                                            15. 2011-07-27 - Task: Statistics/Normal distribution
                                                                                                                                                                                                                                                                                                            16. 2011-06-30 - Task: Unicode strings
                                                                                                                                                                                                                                                                                                            17. 2012-09-01 - Task: Visualize a tree
                                                                                                                                                                                                                                                                                                              1. 2016-09-07 - Draft: File size distribution
                                                                                                                                                                                                                                                                                                                1. 2015-06-05 - Draft: Polynomial synthetic division
                                                                                                                                                                                                                                                                                                                  1. 2008-12-11 - Task: Factors of a Mersenne number
                                                                                                                                                                                                                                                                                                                  2. 2008-11-27 - Task: Roots of a quadratic function
                                                                                                                                                                                                                                                                                                                  3. 2008-11-21 - Task: Sorting algorithms/Selection sort
                                                                                                                                                                                                                                                                                                                    1. 2011-11-07 - Task: Mad Libs
                                                                                                                                                                                                                                                                                                                    2. 2011-06-07 - Draft: Morpion solitaire
                                                                                                                                                                                                                                                                                                                    3. 2014-04-02 - Draft: Recursive descent parser generator
                                                                                                                                                                                                                                                                                                                    4. 2011-05-27 - Task: Sokoban
                                                                                                                                                                                                                                                                                                                    5. 2011-06-06 - Task: Straddling checkerboard
                                                                                                                                                                                                                                                                                                                    6. 2011-05-31 - Task: Vigenère cipher
                                                                                                                                                                                                                                                                                                                    7. 2011-05-31 - Task: Vigenère cipher/Cryptanalysis
                                                                                                                                                                                                                                                                                                                      1. 2017-08-24 - Draft: Finite state machine
                                                                                                                                                                                                                                                                                                                        1. 2011-12-20 - Draft: Montgomery reduction
                                                                                                                                                                                                                                                                                                                          1. 2014-04-10 - Task: Get system command output
                                                                                                                                                                                                                                                                                                                            1. 2013-02-23 - Draft: Audio frequency generator
                                                                                                                                                                                                                                                                                                                            2. 2011-07-06 - Task: Binary digits
                                                                                                                                                                                                                                                                                                                            3. 2011-07-15 - Task: Call a function
                                                                                                                                                                                                                                                                                                                            4. 2011-02-07 - Task: Case-sensitivity of identifiers
                                                                                                                                                                                                                                                                                                                            5. 2013-02-22 - Draft: Code segment unload
                                                                                                                                                                                                                                                                                                                            6. 2011-05-22 - Task: Colour bars/Display
                                                                                                                                                                                                                                                                                                                            7. 2011-05-22 - Task: Colour pinstripe/Display
                                                                                                                                                                                                                                                                                                                            8. 2011-05-22 - Task: Colour pinstripe/Printer
                                                                                                                                                                                                                                                                                                                            9. 2011-06-05 - Task: Count in octal
                                                                                                                                                                                                                                                                                                                            10. 2011-03-29 - Task: Death Star
                                                                                                                                                                                                                                                                                                                            11. 2010-12-13 - Task: Draw a cuboid
                                                                                                                                                                                                                                                                                                                            12. 2011-03-25 - Task: Draw a sphere
                                                                                                                                                                                                                                                                                                                            13. 2011-07-04 - Task: Empty string
                                                                                                                                                                                                                                                                                                                            14. 2011-07-17 - Task: Function prototype
                                                                                                                                                                                                                                                                                                                            15. 2010-10-30 - Task: Globally replace text in several files
                                                                                                                                                                                                                                                                                                                            16. 2011-05-22 - Task: Greyscale bars/Display
                                                                                                                                                                                                                                                                                                                            17. 2010-10-28 - Task: Guess the number
                                                                                                                                                                                                                                                                                                                            18. 2010-11-23 - Task: GUI/Maximum window dimensions
                                                                                                                                                                                                                                                                                                                            19. 2010-10-03 - Task: Hello world/Line printer
                                                                                                                                                                                                                                                                                                                            20. 2011-07-25 - Task: Hello world/Newline omission
                                                                                                                                                                                                                                                                                                                            21. 2011-05-14 - Task: Here document
                                                                                                                                                                                                                                                                                                                            22. 2011-05-25 - Task: Honeycombs
                                                                                                                                                                                                                                                                                                                            23. 2011-05-29 - Task: Include a file
                                                                                                                                                                                                                                                                                                                            24. 2011-05-30 - Task: Inverted syntax
                                                                                                                                                                                                                                                                                                                            25. 2011-05-23 - Task: Joystick position
                                                                                                                                                                                                                                                                                                                            26. 2010-10-07 - Task: Keyboard input/Flush the keyboard buffer
                                                                                                                                                                                                                                                                                                                            27. 2010-10-07 - Task: Keyboard input/Keypress check
                                                                                                                                                                                                                                                                                                                            28. 2010-10-08 - Task: Keyboard input/Obtain a Y or N response
                                                                                                                                                                                                                                                                                                                            29. 2011-09-07 - Task: Metronome
                                                                                                                                                                                                                                                                                                                            30. 2013-03-22 - Draft: Musical scale
                                                                                                                                                                                                                                                                                                                            31. 2013-02-21 - Task: Nautical bell
                                                                                                                                                                                                                                                                                                                            32. 2011-03-25 - Task: Pi
                                                                                                                                                                                                                                                                                                                            33. 2011-05-22 - Task: Pinstripe/Display
                                                                                                                                                                                                                                                                                                                            34. 2011-05-22 - Task: Pinstripe/Printer
                                                                                                                                                                                                                                                                                                                            35. 2011-10-08 - Task: Pragmatic directives
                                                                                                                                                                                                                                                                                                                            36. 2011-02-10 - Task: Read a configuration file
                                                                                                                                                                                                                                                                                                                            37. 2013-03-17 - Draft: Read a file character by character/UTF8
                                                                                                                                                                                                                                                                                                                            38. 2011-04-03 - Task: Read a file line by line
                                                                                                                                                                                                                                                                                                                            39. 2011-07-12 - Task: Read a specific line from a file
                                                                                                                                                                                                                                                                                                                            40. 2011-07-12 - Task: Remove lines from a file
                                                                                                                                                                                                                                                                                                                            41. 2013-02-18 - Task: Scope/Function names and labels
                                                                                                                                                                                                                                                                                                                            42. 2011-06-02 - Task: Special variables
                                                                                                                                                                                                                                                                                                                            43. 2011-07-12 - Task: Start from a main routine
                                                                                                                                                                                                                                                                                                                            44. 2013-02-22 - Task: String comparison
                                                                                                                                                                                                                                                                                                                            45. 2011-06-05 - Task: Strip a set of characters from a string
                                                                                                                                                                                                                                                                                                                            46. 2010-10-30 - Task: Strip comments from a string
                                                                                                                                                                                                                                                                                                                            47. 2011-06-05 - Task: Strip control codes and extended characters from a string
                                                                                                                                                                                                                                                                                                                            48. 2011-06-04 - Task: Strip whitespace from a string/Top and tail
                                                                                                                                                                                                                                                                                                                            49. 2011-06-05 - Task: Substring/Top and tail
                                                                                                                                                                                                                                                                                                                            50. 2010-10-04 - Task: Terminal control/Clear the screen
                                                                                                                                                                                                                                                                                                                            51. 2011-09-06 - Task: Terminal control/Coloured text
                                                                                                                                                                                                                                                                                                                            52. 2011-07-07 - Task: Terminal control/Cursor movement
                                                                                                                                                                                                                                                                                                                            53. 2010-10-04 - Task: Terminal control/Cursor positioning
                                                                                                                                                                                                                                                                                                                            54. 2010-10-05 - Task: Terminal control/Dimensions
                                                                                                                                                                                                                                                                                                                            55. 2010-10-26 - Task: Terminal control/Display an extended character
                                                                                                                                                                                                                                                                                                                            56. 2010-10-26 - Task: Terminal control/Hiding the cursor
                                                                                                                                                                                                                                                                                                                            57. 2010-10-26 - Task: Terminal control/Inverse video
                                                                                                                                                                                                                                                                                                                            58. 2010-10-04 - Task: Terminal control/Positional read
                                                                                                                                                                                                                                                                                                                            59. 2011-03-20 - Task: Terminal control/Preserve screen
                                                                                                                                                                                                                                                                                                                            60. 2013-02-10 - Draft: Terminal control/Restricted width positional input/No wrapping
                                                                                                                                                                                                                                                                                                                            61. 2013-02-10 - Draft: Terminal control/Restricted width positional input/With wrapping
                                                                                                                                                                                                                                                                                                                            62. 2011-09-11 - Task: Terminal control/Unicode output
                                                                                                                                                                                                                                                                                                                            63. 2011-07-19 - Task: Truncate a file
                                                                                                                                                                                                                                                                                                                            64. 2011-05-20 - Task: Update a configuration file
                                                                                                                                                                                                                                                                                                                            65. 2011-06-16 - Task: URL decoding
                                                                                                                                                                                                                                                                                                                            66. 2011-06-16 - Task: URL encoding
                                                                                                                                                                                                                                                                                                                            67. 2011-04-04 - Draft: Using a Speech engine to highlight words
                                                                                                                                                                                                                                                                                                                            68. 2011-06-06 - Task: Video display modes
                                                                                                                                                                                                                                                                                                                            69. 2011-07-12 - Draft: Waveform analysis/Doh ray me
                                                                                                                                                                                                                                                                                                                            70. 2011-09-09 - Draft: Waveform analysis/Top and tail
                                                                                                                                                                                                                                                                                                                            71. 2010-12-15 - Task: Write language name in 3D ASCII
                                                                                                                                                                                                                                                                                                                              1. 2017-01-27 - Task: Chinese zodiac
                                                                                                                                                                                                                                                                                                                              2. 2011-05-27 - Task: Knight's tour
                                                                                                                                                                                                                                                                                                                              3. 2015-04-27 - Task: Subleq
                                                                                                                                                                                                                                                                                                                                1. 2008-03-23 - Task: Amb
                                                                                                                                                                                                                                                                                                                                2. 2008-04-11 - Task: Loops/For
                                                                                                                                                                                                                                                                                                                                3. 2008-04-11 - Task: Loops/Infinite
                                                                                                                                                                                                                                                                                                                                  1. 2013-01-03 - Task: Average loop length
                                                                                                                                                                                                                                                                                                                                  2. 2011-02-20 - Task: Balanced brackets
                                                                                                                                                                                                                                                                                                                                    1. 2010-04-08 - Task: A+B
                                                                                                                                                                                                                                                                                                                                      1. 2008-03-27 - Task: Dragon curve
                                                                                                                                                                                                                                                                                                                                        1. 2009-05-20 - Task: Knuth shuffle
                                                                                                                                                                                                                                                                                                                                          1. 2011-03-03 - Draft: Modulinos
                                                                                                                                                                                                                                                                                                                                          2. 2011-08-06 - Draft: Multiline shebang
                                                                                                                                                                                                                                                                                                                                          3. 2011-08-06 - Draft: Parse command-line arguments
                                                                                                                                                                                                                                                                                                                                          4. 2011-08-09 - Task: Pick random element
                                                                                                                                                                                                                                                                                                                                          5. 2011-08-05 - Task: Program name
                                                                                                                                                                                                                                                                                                                                            1. 2010-08-25 - Task: Sorting algorithms/Bead sort
                                                                                                                                                                                                                                                                                                                                              1. 2011-05-09 - Task: Roman numerals/Decode
                                                                                                                                                                                                                                                                                                                                                1. 2017-02-05 - Draft: Kosaraju
                                                                                                                                                                                                                                                                                                                                                2. 2017-02-04 - Draft: Tarjan
                                                                                                                                                                                                                                                                                                                                                  1. 2014-06-12 - Draft: Sorting algorithms/Cycle sort
                                                                                                                                                                                                                                                                                                                                                    1. 2011-01-20 - Draft: VList
                                                                                                                                                                                                                                                                                                                                                      1. 2013-02-21 - Task: Entropy
                                                                                                                                                                                                                                                                                                                                                        1. 2008-02-28 - Task: 99 Bottles of Beer
                                                                                                                                                                                                                                                                                                                                                        2. 2008-09-23 - Task: Ackermann function
                                                                                                                                                                                                                                                                                                                                                        3. 2008-03-08 - Task: Arithmetic/Complex
                                                                                                                                                                                                                                                                                                                                                        4. 2009-09-09 - Task: Array concatenation
                                                                                                                                                                                                                                                                                                                                                        5. 2009-02-04 - Task: Assertions
                                                                                                                                                                                                                                                                                                                                                        6. 2007-11-08 - Task: Binary search
                                                                                                                                                                                                                                                                                                                                                        7. 2007-11-18 - Task: Bitwise operations
                                                                                                                                                                                                                                                                                                                                                        8. 2015-04-26 - Draft: Card shuffles
                                                                                                                                                                                                                                                                                                                                                        9. 2011-02-11 - Task: Catalan numbers
                                                                                                                                                                                                                                                                                                                                                        10. 2008-02-17 - Task: Detect division by zero
                                                                                                                                                                                                                                                                                                                                                        11. 2009-09-03 - Task: Documentation
                                                                                                                                                                                                                                                                                                                                                        12. 2008-05-04 - Task: Execute SNUSP
                                                                                                                                                                                                                                                                                                                                                        13. 2008-02-29 - Task: Fibonacci sequence
                                                                                                                                                                                                                                                                                                                                                        14. 2010-10-22 - Task: Five weekends
                                                                                                                                                                                                                                                                                                                                                        15. 2011-03-16 - Task: Gray code
                                                                                                                                                                                                                                                                                                                                                        16. 2009-01-07 - Task: Hello world/Standard error
                                                                                                                                                                                                                                                                                                                                                        17. 2009-03-26 - Task: Huffman coding
                                                                                                                                                                                                                                                                                                                                                        18. 2008-04-27 - Task: Inheritance/Single
                                                                                                                                                                                                                                                                                                                                                        19. 2008-02-17 - Task: Input loop
                                                                                                                                                                                                                                                                                                                                                        20. 2008-05-07 - Task: Longest common subsequence
                                                                                                                                                                                                                                                                                                                                                        21. 2009-06-05 - Task: Loops/Break
                                                                                                                                                                                                                                                                                                                                                        22. 2008-04-21 - Task: Loops/Continue
                                                                                                                                                                                                                                                                                                                                                        23. 2008-04-14 - Task: Loops/Do-while
                                                                                                                                                                                                                                                                                                                                                        24. 2008-04-13 - Task: Loops/Foreach
                                                                                                                                                                                                                                                                                                                                                        25. 2008-04-11 - Task: Loops/While
                                                                                                                                                                                                                                                                                                                                                        26. 2007-11-19 - Task: MD5
                                                                                                                                                                                                                                                                                                                                                        27. 2008-09-24 - Task: Monte Carlo methods
                                                                                                                                                                                                                                                                                                                                                        28. 2008-07-30 - Task: Null object
                                                                                                                                                                                                                                                                                                                                                        29. 2007-12-21 - Task: Numerical integration
                                                                                                                                                                                                                                                                                                                                                        30. 2009-10-07 - Task: Parametrized SQL statement
                                                                                                                                                                                                                                                                                                                                                        31. 2008-06-23 - Task: Pascal's triangle
                                                                                                                                                                                                                                                                                                                                                        32. 2008-08-22 - Task: Perfect numbers
                                                                                                                                                                                                                                                                                                                                                        33. 2007-11-20 - Task: Primality by trial division
                                                                                                                                                                                                                                                                                                                                                        34. 2008-02-05 - Task: Prime decomposition
                                                                                                                                                                                                                                                                                                                                                        35. 2008-04-21 - Task: Program termination
                                                                                                                                                                                                                                                                                                                                                        36. 2007-11-09 - Task: Quine
                                                                                                                                                                                                                                                                                                                                                        37. 2008-05-07 - Task: Real constants and functions
                                                                                                                                                                                                                                                                                                                                                        38. 2009-01-21 - Task: Reduced row echelon form
                                                                                                                                                                                                                                                                                                                                                        39. 2009-02-09 - Task: Rosetta Code/Count examples
                                                                                                                                                                                                                                                                                                                                                        40. 2009-06-10 - Task: Scope modifiers
                                                                                                                                                                                                                                                                                                                                                        41. 2011-08-08 - Task: Show the epoch
                                                                                                                                                                                                                                                                                                                                                        42. 2007-12-11 - Task: Sleep
                                                                                                                                                                                                                                                                                                                                                        43. 2008-11-25 - Task: Sorting algorithms/Cocktail sort
                                                                                                                                                                                                                                                                                                                                                        44. 2007-11-11 - Task: Sorting algorithms/Insertion sort
                                                                                                                                                                                                                                                                                                                                                        45. 2008-02-05 - Task: Sorting algorithms/Merge sort
                                                                                                                                                                                                                                                                                                                                                        46. 2010-07-24 - Task: Sorting algorithms/Stooge sort
                                                                                                                                                                                                                                                                                                                                                        47. 2008-12-17 - Task: String concatenation
                                                                                                                                                                                                                                                                                                                                                        48. 2008-01-19 - Task: String length
                                                                                                                                                                                                                                                                                                                                                        49. 2007-12-03 - Task: Sum and product of an array
                                                                                                                                                                                                                                                                                                                                                        50. 2008-01-23 - Task: System time
                                                                                                                                                                                                                                                                                                                                                        51. 2008-01-05 - Task: Trigonometric functions
                                                                                                                                                                                                                                                                                                                                                        52. 2009-07-08 - Task: User input/Graphical
                                                                                                                                                                                                                                                                                                                                                        53. 2009-07-08 - Task: User input/Text
                                                                                                                                                                                                                                                                                                                                                        54. 2008-06-01 - Task: Variadic function
                                                                                                                                                                                                                                                                                                                                                        55. 2014-06-18 - Task: World Cup group stage
                                                                                                                                                                                                                                                                                                                                                          1. 2014-12-27 - Draft: Using the Meetup.com API
                                                                                                                                                                                                                                                                                                                                                            1. 2011-08-27 - Draft: Addition-chain exponentiation
                                                                                                                                                                                                                                                                                                                                                            2. 2011-09-12 - Task: Append a record to the end of a text file
                                                                                                                                                                                                                                                                                                                                                            3. 2009-02-13 - Task: Arithmetic/Rational
                                                                                                                                                                                                                                                                                                                                                            4. 2013-02-24 - Draft: Banker's algorithm
                                                                                                                                                                                                                                                                                                                                                            5. 2013-06-04 - Draft: Birthday problem
                                                                                                                                                                                                                                                                                                                                                            6. 2011-05-30 - Task: Calendar
                                                                                                                                                                                                                                                                                                                                                            7. 2011-05-31 - Task: Calendar - for "REAL" programmers
                                                                                                                                                                                                                                                                                                                                                            8. 2013-04-14 - Task: Combinations and permutations
                                                                                                                                                                                                                                                                                                                                                            9. 2013-04-02 - Task: Currying
                                                                                                                                                                                                                                                                                                                                                            10. 2008-02-19 - Task: Exponentiation operator
                                                                                                                                                                                                                                                                                                                                                            11. 2011-12-07 - Draft: Find first and last set bit of a long integer
                                                                                                                                                                                                                                                                                                                                                            12. 2011-10-28 - Draft: Generalised floating point addition
                                                                                                                                                                                                                                                                                                                                                            13. 2011-10-30 - Draft: Generalised floating point multiplication
                                                                                                                                                                                                                                                                                                                                                            14. 2007-12-17 - Task: Greatest common divisor
                                                                                                                                                                                                                                                                                                                                                            15. 2008-02-12 - Task: Hello world/Graphical
                                                                                                                                                                                                                                                                                                                                                            16. 2010-06-29 - Task: Holidays related to Easter
                                                                                                                                                                                                                                                                                                                                                            17. 2010-06-24 - Task: Horizontal sundial calculations
                                                                                                                                                                                                                                                                                                                                                            18. 2013-04-23 - Draft: Implicit type conversion
                                                                                                                                                                                                                                                                                                                                                            19. 2008-11-21 - Task: Jensen's Device
                                                                                                                                                                                                                                                                                                                                                            20. 2013-12-15 - Draft: Just in time processing on a character stream
                                                                                                                                                                                                                                                                                                                                                            21. 2008-02-14 - Task: Lucas-Lehmer test
                                                                                                                                                                                                                                                                                                                                                            22. 2007-12-18 - Task: Man or boy test
                                                                                                                                                                                                                                                                                                                                                            23. 2008-02-19 - Task: Matrix-exponentiation operator
                                                                                                                                                                                                                                                                                                                                                            24. 2008-02-07 - Task: Matrix transposition
                                                                                                                                                                                                                                                                                                                                                            25. 2009-12-05 - Task: Multiplication tables
                                                                                                                                                                                                                                                                                                                                                            26. 2015-09-19 - Task: Naming conventions
                                                                                                                                                                                                                                                                                                                                                            27. 2013-09-03 - Draft: Native shebang
                                                                                                                                                                                                                                                                                                                                                            28. 2008-09-27 - Task: Number names
                                                                                                                                                                                                                                                                                                                                                            29. 2012-08-17 - Task: Operator precedence
                                                                                                                                                                                                                                                                                                                                                            30. 2013-04-26 - Draft: Permutations with repetitions
                                                                                                                                                                                                                                                                                                                                                            31. 2012-10-05 - Draft: Reverse the gender of a string
                                                                                                                                                                                                                                                                                                                                                            32. 2008-09-28 - Task: Search a list
                                                                                                                                                                                                                                                                                                                                                            33. 2014-03-30 - Draft: Sorting algorithms/Tree sort on a linked list
                                                                                                                                                                                                                                                                                                                                                            34. 2013-10-03 - Task: String append
                                                                                                                                                                                                                                                                                                                                                            35. 2013-10-03 - Task: String prepend
                                                                                                                                                                                                                                                                                                                                                            36. 2011-08-26 - Task: Ternary logic
                                                                                                                                                                                                                                                                                                                                                            37. 2010-10-02 - Task: Thiele's interpolation formula
                                                                                                                                                                                                                                                                                                                                                            38. 2011-11-17 - Draft: Unicode polynomial equation
                                                                                                                                                                                                                                                                                                                                                            39. 2011-09-13 - Draft: User defined pipe and redirection operators
                                                                                                                                                                                                                                                                                                                                                              1. 2013-04-27 - Task: 9 billion names of God the integer
                                                                                                                                                                                                                                                                                                                                                              2. 2012-02-06 - Task: Arithmetic-geometric mean
                                                                                                                                                                                                                                                                                                                                                              3. 2014-01-12 - Task: Arithmetic-geometric mean/Calculate Pi
                                                                                                                                                                                                                                                                                                                                                              4. 2013-07-01 - Draft: Blackjack strategy
                                                                                                                                                                                                                                                                                                                                                              5. 2012-11-30 - Task: Carmichael 3 strong pseudoprimes
                                                                                                                                                                                                                                                                                                                                                              6. 2012-06-24 - Task: Casting out nines
                                                                                                                                                                                                                                                                                                                                                              7. 2013-04-26 - Task: Catalan numbers/Pascal's triangle
                                                                                                                                                                                                                                                                                                                                                              8. 2014-09-16 - Draft: Combinations with repetitions/Square Digit Chain
                                                                                                                                                                                                                                                                                                                                                              9. 2012-02-27 - Task: Continued fraction
                                                                                                                                                                                                                                                                                                                                                              10. 2013-02-04 - Task: Continued fraction/Arithmetic/Construct from rational number
                                                                                                                                                                                                                                                                                                                                                              11. 2013-02-06 - Draft: Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N)
                                                                                                                                                                                                                                                                                                                                                              12. 2013-02-12 - Draft: Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N1, Contined Fraction N2)
                                                                                                                                                                                                                                                                                                                                                              13. 2012-07-20 - Task: Digital root
                                                                                                                                                                                                                                                                                                                                                              14. 2013-07-12 - Task: Fibonacci word
                                                                                                                                                                                                                                                                                                                                                              15. 2013-07-15 - Task: Fibonacci word/fractal
                                                                                                                                                                                                                                                                                                                                                              16. 2012-09-15 - Task: Find largest left truncatable prime in a given base
                                                                                                                                                                                                                                                                                                                                                              17. 2012-01-07 - Draft: Ramsey's theorem
                                                                                                                                                                                                                                                                                                                                                              18. 2012-01-12 - Task: Solve a Hidato puzzle
                                                                                                                                                                                                                                                                                                                                                              19. 2014-06-01 - Task: Solve a Holy Knight's tour
                                                                                                                                                                                                                                                                                                                                                              20. 2014-05-30 - Task: Solve a Hopido puzzle
                                                                                                                                                                                                                                                                                                                                                              21. 2014-05-30 - Task: Solve a Numbrix puzzle
                                                                                                                                                                                                                                                                                                                                                              22. 2012-07-19 - Task: Sum digits of an integer
                                                                                                                                                                                                                                                                                                                                                              23. 2015-02-03 - Task: Textonyms
                                                                                                                                                                                                                                                                                                                                                              24. 2015-02-20 - Draft: Ukkonen’s Suffix Tree Construction
                                                                                                                                                                                                                                                                                                                                                              25. 2013-09-01 - Task: Vogel's approximation method
                                                                                                                                                                                                                                                                                                                                                              26. 2012-10-29 - Task: Zeckendorf arithmetic
                                                                                                                                                                                                                                                                                                                                                                1. 2007-10-03 - Task: Delegates
                                                                                                                                                                                                                                                                                                                                                                2. 2007-11-04 - Task: Queue/Definition
                                                                                                                                                                                                                                                                                                                                                                  1. 2015-02-23 - Task: Primes - allocate descendants to their ancestors
                                                                                                                                                                                                                                                                                                                                                                    1. 2009-08-15 - Task: Factors of an integer
                                                                                                                                                                                                                                                                                                                                                                    2. 2009-08-05 - Task: Substring
                                                                                                                                                                                                                                                                                                                                                                      1. 2016-07-22 - Task: Reflection/Get source
                                                                                                                                                                                                                                                                                                                                                                      2. 2016-07-23 - Draft: Reflection/List methods
                                                                                                                                                                                                                                                                                                                                                                      3. 2016-07-24 - Task: Reflection/List properties
                                                                                                                                                                                                                                                                                                                                                                        1. 2017-07-02 - Draft: Fibonacci heap
                                                                                                                                                                                                                                                                                                                                                                          1. 2009-10-31 - Task: 24 game
                                                                                                                                                                                                                                                                                                                                                                          2. 2009-11-01 - Task: 24 game/Solve
                                                                                                                                                                                                                                                                                                                                                                          3. 2014-12-16 - Task: Abundant, deficient and perfect number classifications
                                                                                                                                                                                                                                                                                                                                                                          4. 2014-02-06 - Task: AKS test for primes
                                                                                                                                                                                                                                                                                                                                                                          5. 2008-11-16 - Task: Align columns
                                                                                                                                                                                                                                                                                                                                                                          6. 2014-12-18 - Task: Aliquot sequence classifications
                                                                                                                                                                                                                                                                                                                                                                          7. 2014-02-21 - Task: Almost prime
                                                                                                                                                                                                                                                                                                                                                                          8. 2014-12-16 - Task: Amicable pairs
                                                                                                                                                                                                                                                                                                                                                                          9. 2008-09-24 - Task: Anagrams
                                                                                                                                                                                                                                                                                                                                                                          10. 2011-05-14 - Task: Anagrams/Deranged anagrams
                                                                                                                                                                                                                                                                                                                                                                          11. 2010-02-13 - Task: Arbitrary-precision integers (included)
                                                                                                                                                                                                                                                                                                                                                                          12. 2012-07-09 - Task: Averages/Mean angle
                                                                                                                                                                                                                                                                                                                                                                          13. 2012-07-10 - Task: Averages/Mean time of day
                                                                                                                                                                                                                                                                                                                                                                          14. 2010-02-20 - Task: Averages/Pythagorean means
                                                                                                                                                                                                                                                                                                                                                                          15. 2010-02-20 - Task: Averages/Root mean square
                                                                                                                                                                                                                                                                                                                                                                          16. 2009-06-17 - Task: Averages/Simple moving average
                                                                                                                                                                                                                                                                                                                                                                          17. 2011-03-27 - Task: Box the compass
                                                                                                                                                                                                                                                                                                                                                                          18. 2011-08-06 - Task: Break OO privacy
                                                                                                                                                                                                                                                                                                                                                                          19. 2009-05-03 - Task: Bulls and cows
                                                                                                                                                                                                                                                                                                                                                                          20. 2010-06-13 - Task: Bulls and cows/Player
                                                                                                                                                                                                                                                                                                                                                                          21. 2013-04-16 - Task: Circles of given radius through two points
                                                                                                                                                                                                                                                                                                                                                                          22. 2013-10-06 - Task: Comma quibbling
                                                                                                                                                                                                                                                                                                                                                                          23. 2008-10-10 - Task: Conway's Game of Life
                                                                                                                                                                                                                                                                                                                                                                          24. 2010-11-13 - Task: CSV to HTML translation
                                                                                                                                                                                                                                                                                                                                                                          25. 2008-12-12 - Task: Day of the week
                                                                                                                                                                                                                                                                                                                                                                          26. 2014-04-11 - Task: Digital root/Multiplicative digital root
                                                                                                                                                                                                                                                                                                                                                                          27. 2011-06-25 - Task: Dinesman's multiple-dwelling problem
                                                                                                                                                                                                                                                                                                                                                                          28. 2010-02-24 - Task: Dot product
                                                                                                                                                                                                                                                                                                                                                                          29. 2012-07-01 - Task: Dutch national flag problem
                                                                                                                                                                                                                                                                                                                                                                          30. 2017-08-07 - Task: Egyptian division
                                                                                                                                                                                                                                                                                                                                                                          31. 2009-07-23 - Task: Ethiopian multiplication
                                                                                                                                                                                                                                                                                                                                                                          32. 2015-04-14 - Task: Euler's sum of powers conjecture
                                                                                                                                                                                                                                                                                                                                                                          33. 2009-10-06 - Task: Evolutionary algorithm
                                                                                                                                                                                                                                                                                                                                                                          34. 2009-03-07 - Task: Exceptions/Catch an exception thrown in a nested call
                                                                                                                                                                                                                                                                                                                                                                          35. 2011-03-14 - Task: Executable library
                                                                                                                                                                                                                                                                                                                                                                          36. 2014-03-26 - Task: Extensible prime generator
                                                                                                                                                                                                                                                                                                                                                                          37. 2010-07-15 - Task: Extreme floating point values
                                                                                                                                                                                                                                                                                                                                                                          38. 2012-05-24 - Task: Fibonacci n-step number sequences
                                                                                                                                                                                                                                                                                                                                                                          39. 2010-03-23 - Task: Find common directory path
                                                                                                                                                                                                                                                                                                                                                                          40. 2009-02-24 - Task: First-class functions
                                                                                                                                                                                                                                                                                                                                                                          41. 2009-08-05 - Task: First-class functions/Use numbers analogously
                                                                                                                                                                                                                                                                                                                                                                          42. 2009-08-16 - Task: Flatten a list
                                                                                                                                                                                                                                                                                                                                                                          43. 2013-07-10 - Task: Flipping bits game
                                                                                                                                                                                                                                                                                                                                                                          44. 2012-06-24 - Task: Floyd's triangle
                                                                                                                                                                                                                                                                                                                                                                          45. 2009-03-03 - Task: Function composition
                                                                                                                                                                                                                                                                                                                                                                          46. 2015-08-12 - Draft: Functional coverage tree
                                                                                                                                                                                                                                                                                                                                                                          47. 2010-10-29 - Task: Guess the number/With feedback
                                                                                                                                                                                                                                                                                                                                                                          48. 2010-10-29 - Task: Guess the number/With feedback (player)
                                                                                                                                                                                                                                                                                                                                                                          49. 2010-03-08 - Task: Hailstone sequence
                                                                                                                                                                                                                                                                                                                                                                          50. 2009-12-02 - Task: Hamming numbers
                                                                                                                                                                                                                                                                                                                                                                          51. 2013-03-25 - Task: Harshad or Niven series
                                                                                                                                                                                                                                                                                                                                                                          52. 2011-11-06 - Task: Hello world/Newbie
                                                                                                                                                                                                                                                                                                                                                                          53. 2015-01-03 - Task: Heronian triangles
                                                                                                                                                                                                                                                                                                                                                                          54. 2014-01-01 - Task: Hickerson series of almost integers
                                                                                                                                                                                                                                                                                                                                                                          55. 2010-03-09 - Task: Hofstadter-Conway $10,000 sequence
                                                                                                                                                                                                                                                                                                                                                                          56. 2011-10-22 - Task: Hofstadter Figure-Figure sequences
                                                                                                                                                                                                                                                                                                                                                                          57. 2011-10-23 - Task: Hofstadter Q sequence
                                                                                                                                                                                                                                                                                                                                                                          58. 2010-03-31 - Task: Horner's rule for polynomial evaluation
                                                                                                                                                                                                                                                                                                                                                                          59. 2013-01-03 - Task: I before E except after C
                                                                                                                                                                                                                                                                                                                                                                          60. 2009-02-21 - Task: Interactive programming
                                                                                                                                                                                                                                                                                                                                                                          61. 2014-12-11 - Draft: Kahan summation
                                                                                                                                                                                                                                                                                                                                                                          62. 2011-06-07 - Task: Kaprekar numbers
                                                                                                                                                                                                                                                                                                                                                                          63. 2008-12-02 - Task: Knapsack problem/Unbounded
                                                                                                                                                                                                                                                                                                                                                                          64. 2011-10-21 - Task: Knuth's algorithm S
                                                                                                                                                                                                                                                                                                                                                                          65. 2013-04-03 - Task: Largest int from concatenated ints
                                                                                                                                                                                                                                                                                                                                                                          66. 2009-02-01 - Task: Literals/Integer
                                                                                                                                                                                                                                                                                                                                                                          67. 2013-08-16 - Task: Longest increasing subsequence
                                                                                                                                                                                                                                                                                                                                                                          68. 2009-04-04 - Task: Look-and-say sequence
                                                                                                                                                                                                                                                                                                                                                                          69. 2014-03-15 - Task: Ludic numbers
                                                                                                                                                                                                                                                                                                                                                                          70. 2010-03-02 - Task: Luhn test of credit card numbers
                                                                                                                                                                                                                                                                                                                                                                          71. 2015-08-29 - Task: Lychrel numbers
                                                                                                                                                                                                                                                                                                                                                                          72. 2009-06-03 - Task: Menu
                                                                                                                                                                                                                                                                                                                                                                          73. 2013-02-02 - Task: Middle three digits
                                                                                                                                                                                                                                                                                                                                                                          74. 2010-07-10 - Task: Minesweeper game
                                                                                                                                                                                                                                                                                                                                                                          75. 2008-08-05 - Task: Monty Hall problem
                                                                                                                                                                                                                                                                                                                                                                          76. 2014-05-20 - Task: Move-to-front algorithm
                                                                                                                                                                                                                                                                                                                                                                          77. 2015-01-09 - Draft: Multi-dimensional array
                                                                                                                                                                                                                                                                                                                                                                          78. 2012-11-13 - Task: Multifactorial
                                                                                                                                                                                                                                                                                                                                                                          79. 2009-04-09 - Task: Mutual recursion
                                                                                                                                                                                                                                                                                                                                                                          80. 2014-03-15 - Task: N'th
                                                                                                                                                                                                                                                                                                                                                                          81. 2014-03-06 - Task: Narcissistic decimal number
                                                                                                                                                                                                                                                                                                                                                                          82. 2011-04-23 - Task: Natural sorting
                                                                                                                                                                                                                                                                                                                                                                          83. 2009-01-31 - Task: Non-decimal radices/Output
                                                                                                                                                                                                                                                                                                                                                                          84. 2014-04-04 - Task: Nonoblock
                                                                                                                                                                                                                                                                                                                                                                          85. 2010-04-03 - Task: Number reversal game
                                                                                                                                                                                                                                                                                                                                                                          86. 2011-07-30 - Task: Numeric error propagation
                                                                                                                                                                                                                                                                                                                                                                          87. 2008-10-08 - Task: One-dimensional cellular automata
                                                                                                                                                                                                                                                                                                                                                                          88. 2011-09-07 - Task: One of n lines in a file
                                                                                                                                                                                                                                                                                                                                                                          89. 2014-05-04 - Task: Order disjoint list items
                                                                                                                                                                                                                                                                                                                                                                          90. 2010-11-09 - Task: Ordered words
                                                                                                                                                                                                                                                                                                                                                                          91. 2010-01-25 - Task: Pangram checker
                                                                                                                                                                                                                                                                                                                                                                          92. 2011-12-03 - Task: Parsing/RPN calculator algorithm
                                                                                                                                                                                                                                                                                                                                                                          93. 2011-12-03 - Task: Parsing/RPN to infix conversion
                                                                                                                                                                                                                                                                                                                                                                          94. 2011-12-02 - Task: Parsing/Shunting-yard algorithm
                                                                                                                                                                                                                                                                                                                                                                          95. 2011-03-25 - Task: Partial function application
                                                                                                                                                                                                                                                                                                                                                                          96. 2015-04-15 - Task: Pascal matrix generation
                                                                                                                                                                                                                                                                                                                                                                          97. 2014-09-27 - Task: Penney's game
                                                                                                                                                                                                                                                                                                                                                                          98. 2013-08-07 - Task: Percolation/Bond percolation
                                                                                                                                                                                                                                                                                                                                                                          99. 2013-08-10 - Task: Percolation/Mean cluster density
                                                                                                                                                                                                                                                                                                                                                                          100. 2013-08-10 - Task: Percolation/Mean run density
                                                                                                                                                                                                                                                                                                                                                                          101. 2013-08-09 - Task: Percolation/Site percolation
                                                                                                                                                                                                                                                                                                                                                                          102. 2011-05-14 - Task: Permutations/Derangements
                                                                                                                                                                                                                                                                                                                                                                          103. 2012-10-25 - Task: Permutations/Rank of a permutation
                                                                                                                                                                                                                                                                                                                                                                          104. 2012-07-24 - Task: Permutations by swapping
                                                                                                                                                                                                                                                                                                                                                                          105. 2014-11-13 - Task: Phrase reversals
                                                                                                                                                                                                                                                                                                                                                                          106. 2012-09-12 - Task: Pig the dice game
                                                                                                                                                                                                                                                                                                                                                                          107. 2012-09-14 - Task: Pig the dice game/Player
                                                                                                                                                                                                                                                                                                                                                                          108. 2008-11-17 - Task: Probabilistic choice
                                                                                                                                                                                                                                                                                                                                                                          109. 2014-12-16 - Draft: Proper divisors
                                                                                                                                                                                                                                                                                                                                                                          110. 2010-08-02 - Task: Quaternion type
                                                                                                                                                                                                                                                                                                                                                                          111. 2013-09-28 - Task: Quickselect algorithm
                                                                                                                                                                                                                                                                                                                                                                          112. 2010-01-23 - Task: Random number generator (included)
                                                                                                                                                                                                                                                                                                                                                                          113. 2010-07-15 - Task: Range expansion
                                                                                                                                                                                                                                                                                                                                                                          114. 2010-07-15 - Task: Range extraction
                                                                                                                                                                                                                                                                                                                                                                          115. 2014-07-05 - Task: Ranking methods
                                                                                                                                                                                                                                                                                                                                                                          116. 2013-05-10 - Task: Rep-string
                                                                                                                                                                                                                                                                                                                                                                          117. 2015-05-01 - Task: Sailors, coconuts and a monkey problem
                                                                                                                                                                                                                                                                                                                                                                          118. 2009-07-01 - Task: Send email
                                                                                                                                                                                                                                                                                                                                                                          119. 2008-08-24 - Task: Sequence of non-squares
                                                                                                                                                                                                                                                                                                                                                                          120. 2015-06-13 - Draft: Sequence of primorial primes
                                                                                                                                                                                                                                                                                                                                                                          121. 2012-05-07 - Task: Set consolidation
                                                                                                                                                                                                                                                                                                                                                                          122. 2009-08-08 - Task: Seven-sided dice from five-sided dice
                                                                                                                                                                                                                                                                                                                                                                          123. 2017-08-09 - Task: Shoelace formula for polygonal area
                                                                                                                                                                                                                                                                                                                                                                          124. 2010-07-24 - Task: Short-circuit evaluation
                                                                                                                                                                                                                                                                                                                                                                          125. 2014-10-04 - Task: Solve the no connection puzzle
                                                                                                                                                                                                                                                                                                                                                                          126. 2011-02-12 - Task: Sort disjoint sublist
                                                                                                                                                                                                                                                                                                                                                                          127. 2009-06-06 - Task: Sort stability
                                                                                                                                                                                                                                                                                                                                                                          128. 2013-06-17 - Task: Sparkline in unicode
                                                                                                                                                                                                                                                                                                                                                                          129. 2008-08-05 - Task: Spiral matrix
                                                                                                                                                                                                                                                                                                                                                                          130. 2010-08-05 - Task: Stable marriage problem
                                                                                                                                                                                                                                                                                                                                                                          131. 2014-12-07 - Task: Stern-Brocot sequence
                                                                                                                                                                                                                                                                                                                                                                          132. 2010-01-30 - Task: String interpolation (included)
                                                                                                                                                                                                                                                                                                                                                                          133. 2014-11-14 - Draft: Superpermutation minimisation
                                                                                                                                                                                                                                                                                                                                                                          134. 2009-05-28 - Task: Test a function
                                                                                                                                                                                                                                                                                                                                                                          135. 2008-11-08 - Task: Text processing/1
                                                                                                                                                                                                                                                                                                                                                                          136. 2008-11-13 - Task: Text processing/2
                                                                                                                                                                                                                                                                                                                                                                          137. 2008-10-03 - Task: Text processing/Max licenses in use
                                                                                                                                                                                                                                                                                                                                                                          138. 2011-02-04 - Task: Tic-tac-toe
                                                                                                                                                                                                                                                                                                                                                                          139. 2009-07-03 - Task: Topological sort
                                                                                                                                                                                                                                                                                                                                                                          140. 2010-10-06 - Draft: Topological sort/Extracted top item
                                                                                                                                                                                                                                                                                                                                                                          141. 2012-11-22 - Task: Topswops
                                                                                                                                                                                                                                                                                                                                                                          142. 2012-05-22 - Task: Trabb Pardo–Knuth algorithm
                                                                                                                                                                                                                                                                                                                                                                          143. 2010-09-08 - Task: Truncatable primes
                                                                                                                                                                                                                                                                                                                                                                          144. 2011-10-31 - Task: Truth table
                                                                                                                                                                                                                                                                                                                                                                          145. 2011-02-22 - Task: Unbias a random generator
                                                                                                                                                                                                                                                                                                                                                                          146. 2011-07-01 - Task: Unicode variable names
                                                                                                                                                                                                                                                                                                                                                                          147. 2011-03-10 - Task: Van der Corput sequence
                                                                                                                                                                                                                                                                                                                                                                          148. 2011-04-09 - Task: Vector products
                                                                                                                                                                                                                                                                                                                                                                          149. 2009-08-08 - Task: Verify distribution uniformity/Naive
                                                                                                                                                                                                                                                                                                                                                                          150. 2008-08-20 - Task: Web scraping
                                                                                                                                                                                                                                                                                                                                                                          151. 2009-02-28 - Task: Y combinator
                                                                                                                                                                                                                                                                                                                                                                          152. 2011-04-02 - Task: Yin and yang
                                                                                                                                                                                                                                                                                                                                                                          153. 2012-10-10 - Task: Zeckendorf number representation
                                                                                                                                                                                                                                                                                                                                                                          154. 2013-10-13 - Task: Zhang-Suen thinning algorithm
                                                                                                                                                                                                                                                                                                                                                                            1. 2015-05-27 - Draft: Linux CPU utilization
                                                                                                                                                                                                                                                                                                                                                                              1. 2016-02-25 - Draft: Cycle detection
                                                                                                                                                                                                                                                                                                                                                                                1. 2017-07-10 - Task: 15 puzzle solver
                                                                                                                                                                                                                                                                                                                                                                                2. 2015-09-04 - Draft: Bacon cipher
                                                                                                                                                                                                                                                                                                                                                                                3. 2017-07-05 - Draft: Black Box
                                                                                                                                                                                                                                                                                                                                                                                4. 2014-02-02 - Draft: Decimal floating point number to binary
                                                                                                                                                                                                                                                                                                                                                                                5. 2016-04-13 - Draft: Greed
                                                                                                                                                                                                                                                                                                                                                                                6. 2015-06-05 - Draft: Hexapawn
                                                                                                                                                                                                                                                                                                                                                                                7. 2016-06-25 - Draft: Markov chain text generator
                                                                                                                                                                                                                                                                                                                                                                                8. 2016-10-31 - Draft: Mastermind
                                                                                                                                                                                                                                                                                                                                                                                9. 2013-05-10 - Draft: Playfair cipher
                                                                                                                                                                                                                                                                                                                                                                                10. 2016-04-14 - Draft: Robots
                                                                                                                                                                                                                                                                                                                                                                                11. 2016-04-09 - Task: Smith numbers
                                                                                                                                                                                                                                                                                                                                                                                12. 2016-12-02 - Draft: Snake And Ladder
                                                                                                                                                                                                                                                                                                                                                                                13. 2015-12-01 - Draft: Tamagotchi emulator
                                                                                                                                                                                                                                                                                                                                                                                  1. 2010-11-16 - Task: Combinations with repetitions
                                                                                                                                                                                                                                                                                                                                                                                  2. 2010-02-14 - Task: Knapsack problem/0-1
                                                                                                                                                                                                                                                                                                                                                                                  3. 2010-02-14 - Task: Knapsack problem/Bounded
                                                                                                                                                                                                                                                                                                                                                                                  4. 2010-02-24 - Task: Knapsack problem/Continuous
                                                                                                                                                                                                                                                                                                                                                                                  5. 2010-10-02 - Task: Permutations
                                                                                                                                                                                                                                                                                                                                                                                    1. 2012-02-11 - Task: Gaussian elimination
                                                                                                                                                                                                                                                                                                                                                                                      1. 2015-05-07 - Task: Hunt The Wumpus
                                                                                                                                                                                                                                                                                                                                                                                        1. 2016-10-05 - Draft: External sort
                                                                                                                                                                                                                                                                                                                                                                                          1. 2013-08-26 - Draft: Base64 encode data
                                                                                                                                                                                                                                                                                                                                                                                            1. 2007-08-12 - Task: Sort an array of composite structures
                                                                                                                                                                                                                                                                                                                                                                                              1. 2010-08-11 - Task: Problem of Apollonius
                                                                                                                                                                                                                                                                                                                                                                                                1. 2017-05-29 - Draft: Data Encryption Standard
                                                                                                                                                                                                                                                                                                                                                                                                  1. 2013-06-10 - Draft: Bilinear interpolation
                                                                                                                                                                                                                                                                                                                                                                                                    1. 2016-02-06 - Task: 15 Puzzle Game
                                                                                                                                                                                                                                                                                                                                                                                                    2. 2015-06-01 - Draft: Convex hull
                                                                                                                                                                                                                                                                                                                                                                                                    3. 2011-10-25 - Draft: OpenGL Pixel Shader
                                                                                                                                                                                                                                                                                                                                                                                                      1. 2010-04-27 - Task: Brownian tree
                                                                                                                                                                                                                                                                                                                                                                                                      2. 2009-12-15 - Task: Execute a Markov algorithm
                                                                                                                                                                                                                                                                                                                                                                                                      3. 2010-05-04 - Task: Fractal tree
                                                                                                                                                                                                                                                                                                                                                                                                      4. 2009-06-29 - Task: Multiple regression
                                                                                                                                                                                                                                                                                                                                                                                                        1. 2007-12-11 - Task: Averages/Arithmetic mean
                                                                                                                                                                                                                                                                                                                                                                                                        2. 2007-12-08 - Task: Combinations
                                                                                                                                                                                                                                                                                                                                                                                                        3. 2007-12-08 - Task: Multiplicative order
                                                                                                                                                                                                                                                                                                                                                                                                        4. 2007-12-13 - Task: Roots of unity
                                                                                                                                                                                                                                                                                                                                                                                                        5. 2007-12-11 - Task: Sum of squares
                                                                                                                                                                                                                                                                                                                                                                                                          1. 2016-09-17 - Task: Nested function
                                                                                                                                                                                                                                                                                                                                                                                                            1. 2014-04-15 - Draft: N-body problem
                                                                                                                                                                                                                                                                                                                                                                                                              1. 2015-05-04 - Draft: Extract file extension
                                                                                                                                                                                                                                                                                                                                                                                                                1. 2013-05-14 - Task: Sum multiples of 3 and 5
                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2007-02-03 - Task: Hostname
                                                                                                                                                                                                                                                                                                                                                                                                                  2. 2007-03-15 - Task: Introspection
                                                                                                                                                                                                                                                                                                                                                                                                                  3. 2007-02-20 - Task: Simple windowed application
                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2014-03-23 - Draft: Most frequent k chars distance
                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2009-04-14 - Task: Binary strings
                                                                                                                                                                                                                                                                                                                                                                                                                      2. 2009-02-18 - Task: Bitmap/Flood fill
                                                                                                                                                                                                                                                                                                                                                                                                                      3. 2008-12-11 - Task: Bitmap/Read an image through a pipe
                                                                                                                                                                                                                                                                                                                                                                                                                      4. 2008-12-19 - Task: Bitwise IO
                                                                                                                                                                                                                                                                                                                                                                                                                      5. 2009-03-06 - Task: Call a function in a shared library
                                                                                                                                                                                                                                                                                                                                                                                                                      6. 2009-05-06 - Task: Closest-pair problem
                                                                                                                                                                                                                                                                                                                                                                                                                      7. 2010-07-12 - Task: Forest fire
                                                                                                                                                                                                                                                                                                                                                                                                                      8. 2010-06-15 - Task: Four bit adder
                                                                                                                                                                                                                                                                                                                                                                                                                      9. 2009-03-05 - Task: Gamma function
                                                                                                                                                                                                                                                                                                                                                                                                                      10. 2009-04-29 - Task: Miller–Rabin primality test
                                                                                                                                                                                                                                                                                                                                                                                                                      11. 2009-07-31 - Task: Nth root
                                                                                                                                                                                                                                                                                                                                                                                                                      12. 2008-12-05 - Task: Palindrome detection
                                                                                                                                                                                                                                                                                                                                                                                                                      13. 2009-06-17 - Task: Polynomial long division
                                                                                                                                                                                                                                                                                                                                                                                                                      14. 2009-05-23 - Task: Ray-casting algorithm
                                                                                                                                                                                                                                                                                                                                                                                                                      15. 2009-05-19 - Task: Sorting algorithms/Counting sort
                                                                                                                                                                                                                                                                                                                                                                                                                      16. 2009-04-27 - Task: Sorting algorithms/Gnome sort
                                                                                                                                                                                                                                                                                                                                                                                                                      17. 2009-03-06 - Task: Xiaolin Wu's line algorithm
                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2007-01-25 - Task: Conditional structures
                                                                                                                                                                                                                                                                                                                                                                                                                        2. 2010-12-23 - Task: Count in factors
                                                                                                                                                                                                                                                                                                                                                                                                                        3. 2007-01-18 - Task: Empty program
                                                                                                                                                                                                                                                                                                                                                                                                                        4. 2007-01-25 - Task: Exceptions
                                                                                                                                                                                                                                                                                                                                                                                                                        5. 2007-02-01 - Task: Execute a system command
                                                                                                                                                                                                                                                                                                                                                                                                                        6. 2007-11-28 - Task: Execute Brain****
                                                                                                                                                                                                                                                                                                                                                                                                                        7. 2007-01-09 - Task: File input/output
                                                                                                                                                                                                                                                                                                                                                                                                                        8. 2009-12-24 - Task: Find the missing permutation
                                                                                                                                                                                                                                                                                                                                                                                                                        9. 2007-01-25 - Task: Flow-control structures
                                                                                                                                                                                                                                                                                                                                                                                                                        10. 2008-06-01 - Task: Greatest element of a list
                                                                                                                                                                                                                                                                                                                                                                                                                        11. 2007-01-09 - Task: Hello world/Text
                                                                                                                                                                                                                                                                                                                                                                                                                        12. 2011-02-13 - Task: Integer sequence
                                                                                                                                                                                                                                                                                                                                                                                                                        13. 2007-11-26 - Task: JSON
                                                                                                                                                                                                                                                                                                                                                                                                                        14. 2009-02-25 - Task: Long multiplication
                                                                                                                                                                                                                                                                                                                                                                                                                        15. 2010-11-25 - Task: Map range
                                                                                                                                                                                                                                                                                                                                                                                                                        16. 2011-08-15 - Task: Old lady swallowed a fly
                                                                                                                                                                                                                                                                                                                                                                                                                        17. 2011-09-25 - Task: Parse an IP Address
                                                                                                                                                                                                                                                                                                                                                                                                                        18. 2009-12-05 - Task: Rate counter
                                                                                                                                                                                                                                                                                                                                                                                                                        19. 2008-09-11 - Task: RCRPG
                                                                                                                                                                                                                                                                                                                                                                                                                        20. 2010-02-15 - Draft: Remote agent/Agent interface
                                                                                                                                                                                                                                                                                                                                                                                                                        21. 2010-02-15 - Draft: Remote agent/Agent logic
                                                                                                                                                                                                                                                                                                                                                                                                                        22. 2010-02-15 - Draft: Remote agent/Simulation
                                                                                                                                                                                                                                                                                                                                                                                                                        23. 2011-07-04 - Task: Rock-paper-scissors
                                                                                                                                                                                                                                                                                                                                                                                                                        24. 2008-02-22 - Task: Roots of a function
                                                                                                                                                                                                                                                                                                                                                                                                                        25. 2012-09-02 - Draft: Rosetta Code/List authors of task descriptions
                                                                                                                                                                                                                                                                                                                                                                                                                        26. 2008-02-05 - Task: Singleton
                                                                                                                                                                                                                                                                                                                                                                                                                        27. 2007-03-19 - Task: Singly-linked list/Element definition
                                                                                                                                                                                                                                                                                                                                                                                                                        28. 2007-03-20 - Task: Singly-linked list/Element insertion
                                                                                                                                                                                                                                                                                                                                                                                                                        29. 2008-02-22 - Task: Sum of a series
                                                                                                                                                                                                                                                                                                                                                                                                                        30. 2009-12-02 - Task: Symmetric difference
                                                                                                                                                                                                                                                                                                                                                                                                                        31. 2007-01-14 - Draft: Table creation
                                                                                                                                                                                                                                                                                                                                                                                                                        32. 2009-11-28 - Task: Undefined values
                                                                                                                                                                                                                                                                                                                                                                                                                        33. 2007-01-28 - Task: Walk a directory/Recursively
                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2017-05-22 - Task: Department Numbers
                                                                                                                                                                                                                                                                                                                                                                                                                            1. 2014-08-20 - Draft: Assertions in design by contract
                                                                                                                                                                                                                                                                                                                                                                                                                            2. 2014-06-09 - Draft: Separate the house number from the street name
                                                                                                                                                                                                                                                                                                                                                                                                                            3. 2014-07-27 - Draft: Starting a web browser
                                                                                                                                                                                                                                                                                                                                                                                                                              1. 2010-02-21 - Task: Deconvolution/1D
                                                                                                                                                                                                                                                                                                                                                                                                                              2. 2010-02-23 - Task: Deconvolution/2D+
                                                                                                                                                                                                                                                                                                                                                                                                                              3. 2011-02-01 - Task: Permutation test
                                                                                                                                                                                                                                                                                                                                                                                                                              4. 2012-01-01 - Draft: Subset sum problem
                                                                                                                                                                                                                                                                                                                                                                                                                                1. 2011-07-19 - Task: Voronoi diagram
                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2014-01-25 - Task: Brace expansion
                                                                                                                                                                                                                                                                                                                                                                                                                                  2. 2014-06-26 - Task: Compare a list of strings
                                                                                                                                                                                                                                                                                                                                                                                                                                  3. 2015-06-06 - Task: Convert seconds to compound duration
                                                                                                                                                                                                                                                                                                                                                                                                                                  4. 2014-06-24 - Task: Tokenize a string with escaping
                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2014-01-02 - Draft: Currency
                                                                                                                                                                                                                                                                                                                                                                                                                                    2. 2011-06-30 - Task: Hello world/Web server
                                                                                                                                                                                                                                                                                                                                                                                                                                    3. 2012-03-06 - Task: K-d tree
                                                                                                                                                                                                                                                                                                                                                                                                                                    4. 2011-06-16 - Task: Sorting algorithms/Sleep sort
                                                                                                                                                                                                                                                                                                                                                                                                                                    5. 2012-03-27 - Task: Word wrap
                                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2015-03-19 - Draft: Longest common prefix
                                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2011-11-29 - Task: CRC-32
                                                                                                                                                                                                                                                                                                                                                                                                                                        2. 2011-11-25 - Task: Munching squares
                                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2014-11-03 - Draft: XML Validation
                                                                                                                                                                                                                                                                                                                                                                                                                                            1. 2009-08-03 - Task: Associative array/Iteration
                                                                                                                                                                                                                                                                                                                                                                                                                                            2. 2008-11-17 - Task: Character codes
                                                                                                                                                                                                                                                                                                                                                                                                                                            3. 2011-07-20 - Task: Closures/Value capture
                                                                                                                                                                                                                                                                                                                                                                                                                                            4. 2011-06-16 - Task: Count occurrences of a substring
                                                                                                                                                                                                                                                                                                                                                                                                                                            5. 2008-12-23 - Task: Environment variables
                                                                                                                                                                                                                                                                                                                                                                                                                                            6. 2013-08-21 - Draft: Sorting algorithms/Patience sort
                                                                                                                                                                                                                                                                                                                                                                                                                                              1. 2011-07-26 - Draft: Audio Overlap Loop
                                                                                                                                                                                                                                                                                                                                                                                                                                              2. 2011-07-21 - Draft: AudioAlarm
                                                                                                                                                                                                                                                                                                                                                                                                                                                1. 2007-02-02 - Task: Tokenize a string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2012-07-09 - Draft: OpenWebNet Password
                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2007-12-14 - Task: Forward difference
                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2015-02-23 - Task: Validate International Securities Identification Number
                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2013-05-03 - Task: Benford's law
                                                                                                                                                                                                                                                                                                                                                                                                                                                        2. 2017-09-27 - Draft: Four is magic
                                                                                                                                                                                                                                                                                                                                                                                                                                                        3. 2017-02-12 - Draft: Imaginary base numbers
                                                                                                                                                                                                                                                                                                                                                                                                                                                        4. 2017-09-01 - Draft: Largest number divisible by its digits
                                                                                                                                                                                                                                                                                                                                                                                                                                                        5. 2016-02-22 - Task: Pathological floating point problems
                                                                                                                                                                                                                                                                                                                                                                                                                                                        6. 2011-08-21 - Task: Self-referential sequence
                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2007-01-24 - Task: Regular expressions
                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. 2016-12-18 - Draft: A* search algorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                            2. 2016-12-16 - Task: Angle difference between two bearings
                                                                                                                                                                                                                                                                                                                                                                                                                                                            3. 2016-12-16 - Task: Apply a digital filter (direct form II transposed)
                                                                                                                                                                                                                                                                                                                                                                                                                                                            4. 2016-12-16 - Draft: Determine if two triangles overlap
                                                                                                                                                                                                                                                                                                                                                                                                                                                            5. 2016-12-15 - Draft: Eertree
                                                                                                                                                                                                                                                                                                                                                                                                                                                            6. 2016-12-16 - Task: Find the intersection of a line with a plane
                                                                                                                                                                                                                                                                                                                                                                                                                                                            7. 2016-12-16 - Task: Find the intersection of two lines
                                                                                                                                                                                                                                                                                                                                                                                                                                                            8. 2016-12-16 - Task: Negative base numbers
                                                                                                                                                                                                                                                                                                                                                                                                                                                            9. 2016-12-16 - Task: Ramer-Douglas-Peucker line simplification
                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. 2012-08-14 - Task: Same Fringe
                                                                                                                                                                                                                                                                                                                                                                                                                                                              2. 2012-09-20 - Task: Twelve statements
                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. 2009-05-27 - Task: Color of a screen pixel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                2. 2009-06-02 - Task: Dynamic variable names
                                                                                                                                                                                                                                                                                                                                                                                                                                                                3. 2010-04-20 - Task: Inverted index
                                                                                                                                                                                                                                                                                                                                                                                                                                                                4. 2009-05-27 - Task: Keyboard macros
                                                                                                                                                                                                                                                                                                                                                                                                                                                                5. 2009-05-27 - Task: Mouse position
                                                                                                                                                                                                                                                                                                                                                                                                                                                                6. 2011-07-24 - Task: OLE Automation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                7. 2010-06-12 - Draft: Parse EBNF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                8. 2009-06-02 - Task: Simulate input/Keyboard
                                                                                                                                                                                                                                                                                                                                                                                                                                                                9. 2009-05-26 - Task: Simulate input/Mouse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                10. 2009-05-27 - Task: Window management
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2012-11-08 - Task: Check Machin-like formulas
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  2. 2015-05-18 - Draft: Chess player/Move generation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  3. 2015-05-18 - Draft: Chess player/Program options and user interface
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  4. 2015-05-18 - Draft: Chess player/Search and evaluation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  5. 2013-04-10 - Draft: Find duplicate files
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  6. 2016-04-24 - Task: Password generator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2017-02-11 - Task: CUSIP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2. 2013-03-31 - Task: IBAN
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3. 2013-03-17 - Draft: NYSIIS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4. 2014-09-21 - Draft: Time-based One-time Password Algorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2016-01-23 - Draft: Arithmetic coding/As a generalized change of radix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      2. 2016-01-28 - Task: Cramer's rule
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      3. 2016-01-10 - Draft: Faulhaber's formula
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      4. 2017-06-05 - Draft: Faulhaber's triangle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      5. 2016-02-01 - Task: Jaro distance
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      6. 2016-03-30 - Draft: Snake
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2013-02-04 - Task: Universal Turing machine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2016-07-07 - Task: Sort a list of object identifiers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. 2009-11-27 - Task: Go Fish
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2. 2010-11-14 - Task: Metaprogramming
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. 2007-01-21 - Task: Sorting algorithms/Bubble sort
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. 2013-06-20 - Task: CSV data manipulation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2007-02-27 - Task: Address of a variable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  2. 2007-02-06 - Task: Concurrent computing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  3. 2007-02-27 - Task: Define a primitive data type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  4. 2007-09-07 - Task: Generic swap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  5. 2008-12-23 - Task: Handle a signal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  6. 2007-02-27 - Task: Memory layout of a data structure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  7. 2007-02-09 - Task: Metered concurrency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  8. 2007-03-09 - Task: Object serialization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  9. 2008-04-27 - Task: Playing cards
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  10. 2008-04-01 - Task: Roman numerals/Encode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  11. 2007-02-09 - Task: Synchronous concurrency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  12. 2007-02-27 - Task: Variable size/Get
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  13. 2007-02-27 - Task: Variable size/Set
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2015-04-27 - Draft: Selective File Copy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2015-03-08 - Task: General FizzBuzz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      2. 2014-06-05 - Task: Unix/ls
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2014-09-13 - Task: Sequence of primes by Trial Division
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        2. 2011-12-02 - Task: Zebra puzzle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2010-01-25 - Task: Compile-time calculation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. 2011-02-08 - Task: Fast Fourier transform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. 2014-02-20 - Task: Semiprime
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. 2012-03-15 - Task: Runge-Kutta method
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2011-06-11 - Task: Convert decimal number to rational
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  2. 2011-05-08 - Task: Self-describing numbers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2016-01-12 - Draft: OpenGL/Utah Teapot
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2016-05-10 - Draft: Integer roots
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      2. 2014-05-02 - Draft: Self-hosting compiler
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2015-04-16 - Task: Perfect shuffle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        2. 2015-03-21 - Draft: Vector
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2015-09-20 - Task: Thue-Morse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. 2012-08-31 - Task: Main step of GOST 28147-89
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2. 2013-01-09 - Draft: Old Russian measure of length
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            3. 2013-05-24 - Draft: Transportation problem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Perl 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Works with: Rakudo version 2017.08

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The pseudocode above is no longer really useful as the page format has changed significantly sine this task was written. Rather than checking every edit to see if it was a change to the task description, we'll just assume the user that created the page is the task author. This isn't 100% accurate; a very few pages got renamed and recreated by someone other than the original author without preserving the history, so they are misreported (15 Puzzle Game for instance,) but is as good as it is likely to get without extensive manual intervention. Subsequent edits to the task description are not credited. As it is, we must still make thousands of requests and pound the server pretty hard. Checking every edit would make the task several of orders of magnitude more abusive of the server (and my internet connection.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The task names and author information are saved to local files so it can pick up where it left off if it gets interrupted during processing. As the task creation time (and original editor) never change, don't bother to re-download every time. Just update the category (Draft or Task) as that is the only thing that really changes. If a task name gets edited, manual intervention is required. Either edit the JSON file with the task information or just delete it and recreate it from scratch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <lang perl6>use HTTP::UserAgent; use Gumbo; use Sort::Naturally; use JSON::Fast;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            my $ua = HTTP::UserAgent.new;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            for 'Programming_Tasks', 'Draft_Programming_Tasks' -> $category { # Get lists of Tasks & Draft Tasks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               #last; # Uncomment to skip this step
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               say "Updating $category list...";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               my $page   = "http://rosettacode.org/wiki/Category:$category";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               my $html   = $ua.get($page).content;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            my $xmldoc = parse-html($html, :TAG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            , :id<mw-pages>); my @tasks = parse-html($xmldoc[0].Str, :TAG
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ).Str.comb( /'/wiki/' <-["]>+ / )».substr(6); #'" my $f = open("./RC_{$category}.txt", :w) or die "$!\n"; note "Writing $category file..."; $f.print( @tasks.join("\n") ); $f.close; } my %cat = ( # Friendlier descriptions for task categories 'Programming_Tasks' => 'Task: ', 'Draft_Programming_Tasks' => 'Draft:' );
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. Month names for date manipulations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            my %months = <January February March April May June July August September October November December> Z=> 1..12; my $hashfile = './RC_hash.json'; my $htmlfile = './RC_Authors.html'; note "Reading JSON hash file..."; my %tasks = $hashfile.IO.e ?? $hashfile.IO.slurp.&from-json !! ( ); for 'Programming_Tasks', 'Draft_Programming_Tasks' -> $category { # Scrape info from each page. #last; # Uncomment to skip this step note "Loading $category file..."; my @entries = "./RC_{$category}.txt".IO.slurp.lines; for @entries -> $title { # Update the category as that is the only thing that can really change. %tasks{$title}{'category'} = %cat{$category}; # Otherwise skip if it has already been indexed. The creation date can't change # the task name *can* change, but it is exceedinly rare if %tasks{$title}{'title'}:exists { note $title; next; } # Get the earliest edit my $html = $ua.get: "http://rosettacode.org/mw/index.php?title={$title}&dir=prev&limit=1&action=history"; # Filter out the actual history links $html.content ~~ m|'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • ' (.+?) ''|;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # Only interested in the oldest (last in the list)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   my $line = $0.lines.tail;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # Parse out the User name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   $line ~~ m| 'title="User:' <-[>]>+? '>' (.+?) '</a>' |;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   my $auth = $0 ?? $0.Str !! ;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # Oops, no user name, must be anonymous, get IP address instead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   unless $auth {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       $line ~~ m| '"mw-userlink mw-anonuserlink">' (.+?) '</a>' |;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       $auth = $0.Str;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   %tasks{$title}{'author'} = $auth;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # Parse out human readable title
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   $line ~~ m| '<a href="/mw/index.php?title=' $title '&' .+? 'title="'(<-["]>+)'"' |; #"'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   %tasks{$title}{'title'} = $0.Str;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # Parse out date task was added, convert date to ISO format
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   $line ~~ m| 'class="mw-changeslist-date">' <-[\s]>+  (<-[<]>+) '</a>‎' |;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   %tasks{$title}{'date'} = $0.Str.trim.&toISO8601;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # report progress
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   note $title;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # save to a file
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   $hashfile.IO.spurt(%tasks.&to-json);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   sleep 3; # Don't pound the server
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. Convert saved task / author info to an HTML table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            note "Building HTML table..."; my $count = +%tasks; my $taskcnt = +%tasks.grep: *.value.<category> eq %cat<Programming_Tasks>; my $draftcnt = $count - $taskcnt;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. Dump an HTML table to a file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            my $out = open($htmlfile, :w) or die "$!\n";

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. Add table boilerplate and header
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $out.say( '' );
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. Get sorted unique list of task authors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            for %tasks{*}».<author>.unique.sort(*.&naturally) -> $author {

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $out.print( '' );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $out.say( '
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            As of ', Date.today, ' | Total: ',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             "$count / Tasks: $taskcnt / Draft Tasks: $draftcnt",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            '
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UserAuthored
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ' );
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   # Get list of tasks by this author, sorted by name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   for %tasks.grep( { $_.value.<author> eq $author } ).sort(*.key.&naturally) -> $task {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       # and add them
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                $out.print( "
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. {$task.value.<date>} - {$task.value.<category>}", " [[{$task.key}|{$task.value.<title>}]]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              2. " ); } $out.say( '
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ' );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              $out.close;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              say "HTML table file saved as: {$htmlfile.IO.absolute}";

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sub toISO8601 ($date) { # convert day month year to YYYY-MM-DD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 my @dmy = $date.split: ' ';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 sprintf "%4d-%02d-%02d", @dmy[2].Int, %months{@dmy[1]}, @dmy[0].Int;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } </lang>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sample output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              As of 2017-10-10 | Total: 1067 / Tasks: 859 / Draft Tasks: 208
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UserAuthored
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. 2013-05-16 - Draft: Names to numbers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                2. 2013-05-16 - Draft: Solving coin problems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 2009-11-12 - Task: Soundex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 2015-05-04 - Task: Draw a rotating cube

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Many rows omitted...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. 2015-04-16 - Task: Perfect shuffle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      2. 2015-03-21 - Draft: Vector
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. 2015-09-20 - Task: Thue-Morse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. 2012-08-31 - Task: Main step of GOST 28147-89
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          2. 2013-01-09 - Draft: Old Russian measure of length
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          3. 2013-05-24 - Draft: Transportation problem