v1.0.0-rc9
Approval chain
Build a release approval process with states and deadlines.
Batch enrichment
Add fields to many records at the same time with Tasks.map.
Batch pipeline
Split records into batches, process them at the same time, and sort the results.
Big integers
Calculate factorials, Fibonacci numbers, and powers larger than 64 bits.
Bounded fanout
Limit how many tasks run at once with max:.
Chudnovsky π
Calculate 100 digits of π with the Chudnovsky formula and big integers.
Concurrent scoring
Score many records at the same time with Tasks.map.
Digest schedule
Schedule digest jobs from a cadence and a time window.
Escalation policy
Route support tickets from their severity and response deadline.
Event timestamps
Format RFC3339 timestamps with whole or fractional seconds.
Hash projection
Remove, select, merge, and fetch fields from a hash.
Late fee
Calculate a late fee from an overdue duration.
Late fee policy
Choose a late fee from the account standing and days overdue.
Log digest
Parse log lines, group them by level, and count each group.
Maintenance window
Plan a maintenance window with environment rules, freeze notices, and durations.
Matrix report
Turn rows of daily metrics into totals for each metric.
Numeric literals and rounding
Read hex, octal, binary, and scientific numbers, then round them.
On-call handoff
Build an on-call handoff from the coverage level and shift length.
Parallel preparation
Run independent functions in one Tasks.run block and combine their results.
Payout schedule
Schedule payouts from the amount, cadence, and settlement delay.
Quote approval
Send each quote to the right approval step based on its total.
Refund decision
Use enums, money, and durations to decide whether to refund an order.
Release readiness
Report whether a release is ready from its state, approvals, and schedule.
Reminder schedule
Schedule reminders from a channel and lead time.
Reshape a list
Split a list into pages and rolling windows, then sample values.
Resilient lookups
Recover from missing hash keys and check float edge cases.
Retry backoff schedule
Build an exponential retry schedule with enums, durations, and timestamps.
Session expiry
Set a session expiry time from its risk level.
Shipping quote
Calculate delivery dates and prices for each shipping speed.
Staged barrier
Start a batch of tasks, wait for all of them, then total the results.
Statement grid
Turn rows of money values into totals for each category.
Subscription billing
Price a subscription invoice from the plan and quantity.
Task error propagation
Catch a task error by wrapping Tasks.run in begin and rescue.
Text toolkit
Split, align, and inspect text with Ruby-style string helpers.
Trial offer
Build a trial offer from the account type and trial length.
Word and symbol arrays
Build string and symbol arrays with %w, %i, %W, and %I.
Extras
Use array helpers to search, sort, combine, and inspect values.
Jobs And Events
Queue jobs and publish events through APIs from the Go app.
Functions And Calls
Define functions, call other functions, and return values.
Literals And Operators
Work with numbers, strings, arrays, hashes, and common operators.
Blocks Advanced
Filter, group, and reduce data with blocks.
Blocks Transformations
Map, filter, and reduce collections with blocks.
Enumerable Reports
Group donations and total the money in each currency.
Yield Patterns
Write functions that accept and yield to blocks.
Capabilities Iteration
Iterate over records returned by an API from the Go app.
Context Access
Read the current user from context provided by the Go app.
Database Queries
Query and update data through a database API from the Go app.
Collections Arrays
Read, build, and update arrays.
Hashes
Build, update, and read nested hashes.
Symbols
Use symbols as stable hash keys.
Case When
Match values and ranges with case and when.
Conditionals
Choose values with if, elsif, else, and unless.
Loop Control
Skip and stop loop iterations with next and break.
Recursion
Write factorial and Fibonacci functions with recursion.
Until Loop
Repeat work with an until loop.
While Loop
Repeat work with a while loop.
Durations
Create durations and add them together.
Enums Operations
Define enums and inspect their values.
Assertions
Check inputs with assertions.
Hashes Operations
Merge, search, and count values in hashes.
Hashes Transformations
Rename, filter, and transform hash keys and values.
Fizzbuzz
Write FizzBuzz with a loop and conditionals.
Loops Advanced
Nest loops and stop early with break.
Loops Iteration
Iterate over ranges and arrays with common loop helpers.
Money Operations
Add, subtract, and compare money values.
Access Control
Write access rules as small functions.
Usage
Create ascending and descending ranges, then filter their values.
Core Utilities
Parse JSON and time values, then create IDs.
Strings Operations
Normalize, split, search, and inspect strings.
Scoring
Run independent scoring and preparation functions at the same time.
Duration
Add durations to times and use duration arithmetic.
100 doors
Toggle one hundred doors and return the open door numbers.
99 Bottles of Beer
Generate the full 99 Bottles of Beer song from 99 down to 0.
Abbreviations, automatic
Compute the shortest unique command prefixes for a fixed command set and resolve sample abbreviations.
Abbreviations, simple
Resolve simple command abbreviations by matching unique prefixes from a fixed command list.
Abundant odd numbers
Check a few well-known odd abundant numbers by comparing them with their proper divisor sums.
Abundant, deficient and perfect number classifications
Classify sample integers by comparing them with the sum of their proper divisors.
Align columns
Align Rosetta Code's dollar-delimited sample text into left, right, and centered columns.
Aliquot sequence classifications
Build short aliquot sequences and classify whether they terminate, loop, or are perfect.
Anagrams
Group a fixed word list into anagram sets using sorted-letter signatures.
Angle difference between two bearings
Compute the smallest signed turn needed to move from one bearing to another.
Angles (geometric), normalization and conversion
Normalize degree angles and convert between degrees and radians for fixed sample values.
Bacon cipher
Encode and decode short messages with Bacon's five-letter A/B cipher.
Balanced ternary
Convert small signed integers into balanced ternary using 1, 0, and T digits.
Best shuffle
Produce a low-fixed-point shuffle by rotating the sorted characters of a word.
Binary digits
Convert fixed non-negative integers into binary strings.
Binary strings
Generate all binary strings of a fixed length with a simple recursive builder.
Bitwise operations
Run common bitwise operations with a hand-built 8-bit model.
Box the compass
Map degree headings to the correct 32-point compass names for the Rosetta Code sample bearings.
Brazilian numbers
Find the first Brazilian numbers by searching for bases whose representation uses one repeated digit.
Bubble sort
Sort an array of integers using the bubble sort algorithm.
Call a function
Call functions with positional arguments and combine their results.
Cartesian product of two or more lists
Build Cartesian products iteratively for a pair of lists and a three-list input.
Catalan numbers
Generate the opening Catalan numbers with the standard multiplicative recurrence.
Chinese zodiac
Map sample years to their Chinese zodiac animal and element.
Conditional structures
Classify values with if, elsif, and else branches.
Day of the week
Compute weekdays for fixed Gregorian dates with Zeller's congruence.
Determine if a string is numeric
Recognize simple signed integer and decimal strings.
Determine if a string is squeezable
Collapse repeated adjacent characters and compare the squeezed result with a target string.
Digital root
Compute the digital root and additive persistence of a non-negative integer.
Discordian date
Convert Gregorian dates into the Discordian calendar.
Dot product
Compute the dot product of two vectors of equal length.
Ethiopian multiplication
Multiply two integers by repeated halving, doubling, and summing odd rows.
Factorial
Compute factorial values both recursively and iteratively, well past the 64-bit range.
Factors of an integer
Compute all positive factors of a small positive integer with trial division up to its square root.
Farey sequence
Generate Farey sequences of small orders with the classic iterative recurrence.
Fibonacci n-step number sequences
Generate Tribonacci and Tetranacci sequences by summing the previous n terms.
Fibonacci sequence
Produce the opening terms of the Fibonacci sequence iteratively.
Fibonacci word
Build the opening Fibonacci words by concatenating the two previous terms.
Find palindromic numbers in both binary and ternary bases
Search for numbers whose binary and ternary representations are both palindromes.
Find words which contain the most consonants
Count consonants in a fixed word list and return the words with the highest totals.
FizzBuzz
Emit the classic FizzBuzz sequence up to a chosen limit.
Floyd's triangle
Generate the opening rows of Floyd's triangle.
Four bit adder
Add two four-bit binary values and return the carry with the result bits.
Fraction reduction
Reduce sample fractions to lowest terms with Euclid's algorithm.
Gray code
Generate the 4-bit Gray code sequence with the standard reflective construction.
Greatest common divisor
Compute greatest common divisors with the iterative Euclidean algorithm on a fixed sample set.
Greedy algorithm for Egyptian fractions
Decompose sample rational numbers into Egyptian fractions with the standard greedy method, including inputs whose unit-fraction denominators run to 25 digits.
Hailstone sequence
Build a hailstone sequence and report its length.
Hamming numbers
Generate the opening Hamming numbers with the classic 2-3-5 pointer technique.
Happy numbers
Classify happy numbers by iterating the sum-of-squares process and list the first twelve.
Harshad or Niven series
Find Harshad (Niven) numbers, which are divisible by the sum of their digits.
Heronian triangles
Search a small side-length range for Heronian triangles with integer area.
Humble numbers
Generate humble numbers with the standard 2-3-5-7 pointer technique.
I before E except after C
Check sample words against the classic “i before e except after c” spelling rule.
Insertion sort
Sort an array by repeatedly inserting each element into its correct position.
Isqrt (integer square root) of X
Compute integer square roots with a binary search over fixed sample inputs.
Josephus problem
Find the survivor position in the Josephus problem for n people counting every k-th.
Kaprekar numbers
Test fixed integers for the Kaprekar split-square property.
Kaprekar routine
Apply the Kaprekar routine to a 4-digit number and watch it converge to 6174.
Last letter-first letter
Build a word chain where each next word starts with the previous word's last letter.
Leap year
Determine whether a given year is a leap year using the Gregorian calendar rules.
Letter frequency
Count alphabetic character frequencies in a sample phrase.
Levenshtein distance
Compute edit distance with insert, delete, and substitute operations using a single rolling row.
Long multiplication
Break a multiplication problem into the partial products used by long multiplication.
Look-and-say sequence
Generate terms of the look-and-say sequence where each term describes the digits of the previous one.
Luhn test of credit card numbers
Validate account numbers with the Luhn checksum.
Lychrel numbers
Check sample numbers for palindrome formation under 200 rounds of the reverse-and-add process, where sums grow far past 64 bits.
Magic squares of odd order
Build a 3x3 magic square with the classic Siamese method.
Matrix multiplication
Multiply two small matrices.
Matrix transposition
Transpose a matrix by swapping its rows and columns with the built-in Array#transpose.
Middle three digits
Return the middle three digits of integers that have an odd number of digits.
Minimum multiple of m where digital sum equals m
Search small multiples until the digit sum matches the divisor.
Morse code
Encode text to Morse code using a fixed A-Z and digit lookup table.
Multiplication tables
Build a small multiplication table as nested arrays.
N-smooth numbers
Generate the first twenty 5-smooth numbers by stripping allowed small factors.
Narcissistic decimal number
Identify fixed sample numbers that equal the sum of their digits raised to the digit count.
Natural sorting
Sort filenames by comparing embedded digit runs numerically instead of lexicographically.
Number names
Spell small whole numbers in English.
Numerical integration
Approximate definite integrals with the trapezoidal rule over fixed functions.
Palindrome detection
Detect palindromes after normalizing letters and digits to lowercase.
Palindromic gapful numbers
Find the first palindromic gapful numbers in a bounded decimal range.
Pangram checker
Check whether a sentence contains every letter of the alphabet at least once.
Parse an IP Address
Parse dotted IPv4 strings into four validated octets.
Pascal's triangle
Generate the opening rows of Pascal's triangle iteratively.
Permutations
Generate every permutation of three items with a simple recursive backtracking routine.
Pig Latin
Translate English words into Pig Latin by moving leading consonants and appending ay.
Playing cards
Construct a standard 52-card deck from suit and rank combinations.
Prime decomposition
Find the prime factors of composite integers with trial division.
Priority queue
Model a simple highest-priority-first queue with sorted insertion over an array-backed store.
Pythagorean triples
Enumerate small Pythagorean triples with bounded hypotenuse.
Range extraction
Compress an ordered list of integers into Rosetta Code's comma-and-range string format.
Roman numerals/Decode
Convert a Roman numeral string back to its integer value.
Roman numerals/Encode
Convert an integer to its Roman numeral representation.
Rosetta Code A+B
Add fixed integer pairs and return the resulting sums.
Rosetta Code A+B
Return the sum of integer pairs.
Rosetta Code Arrays
Create, index, append to, and total arrays.
Rot-13
Encode and decode text by rotating letters by thirteen positions.
Run-length encoding
Encode and decode a short sample string with classic run-length encoding.
Selection sort
Sort an array by repeatedly selecting the minimum element from the unsorted portion.
Sequence of primorial primes
Check primorial minus one and plus one values for primality over a short prime prefix.
Set
Find the union, intersection, and difference of array-backed sets.
Show ASCII table
Return a compact slice of ASCII rows with code, character, and ordinal data.
Sieve of Eratosthenes
Generate the prime numbers up to fifty with the classic sieve.
Smith numbers
Detect Smith numbers by comparing the digit sum of a composite integer with the digit sum of its prime factors.
Spiral matrix
Fill a square matrix in clockwise spiral order.
Square-free integers
List the square-free integers up to thirty.
Stack
Model a small LIFO stack with push, pop, and peek over an array-backed store.
String comparison
Compare sample string pairs lexicographically and report the sign of each comparison.
String matching
Find every starting index of a pattern inside a fixed string with a naive scan.
Substring
Extract substrings from a source string using start offsets and lengths.
Sum multiples of 3 and 5
Sum the integers below fixed limits that are divisible by three or five.
Taxicab numbers
Search a small cube-sum table for numbers that can be written as two sums of two cubes.
Temperature conversion
Convert values between Celsius and Fahrenheit.
Ternary logic
Build a small truth table for three-valued logic with true, maybe, and false states.
Top rank per group
Pick the highest-scoring row from each group with a stable tie-break on name.
Topological sort
Topologically sort a small dependency graph with Kahn's algorithm.
Total circles area
Sum the areas of several circles from their radii.
Towers of Hanoi
Solve Towers of Hanoi recursively and return each move in order.
Tree traversal
Traverse a small binary tree in preorder, inorder, postorder, and level order.
Truth table
Enumerate boolean combinations for common logical operators.
UPC
Validate sample UPC codes with the standard checksum rule.
URL parser
Parse a fixed URL into scheme, host, path, and query parameters.
UTF-8 encode and decode
Encode fixed code points into UTF-8 byte arrays and decode them back.
Variables
Show variable assignment, reassignment, and derived values.
Vector products
Compute the dot product and cross product of two fixed three-dimensional vectors.
Vigenère cipher
Encode and decode a short uppercase message with a fixed Vigenère key.
Word frequency
Count the frequency of normalized words in a short sample passage.
Word wrap
Wrap a paragraph with the standard greedy algorithm at two different column widths.
Zeckendorf number representation
Represent integers as sums of non-consecutive Fibonacci numbers using Zeckendorf's theorem.
Zig-zag matrix
Fill a small square matrix with zig-zag diagonal ordering.
ABC Problem
Determine whether a word can be formed from a fixed set of two-letter blocks without reusing a block.
Ackermann Function
Run the Ackermann function on small inputs to show deep recursion.
Balanced Brackets
Check whether bracket pairs are properly nested and closed by scanning the text with a stack.
Binary Search
Locate values in a sorted array by repeatedly halving the remaining search interval.
Caesar Cipher
Encode and decode text by rotating alphabetic characters through a fixed shift.