{
 "id": "codesnob",
 "_note": "Distractors are drawn from the same family as the answer. Offering Rust against HTML is not a question. Families with fewer than four members are topped up from the full language list at runtime.",
 "families": {
  "array": [
   "APL",
   "J",
   "Julia",
   "MATLAB",
   "R"
  ],
  "beam": [
   "Elixir",
   "Erlang",
   "Gleam"
  ],
  "curly": [
   "C#",
   "Dart",
   "Objective-C",
   "Solidity",
   "Swift",
   "TypeScript"
  ],
  "jvm": [
   "Groovy",
   "Java",
   "Kotlin",
   "Scala"
  ],
  "legacy": [
   "Ada",
   "COBOL",
   "Fortran",
   "Pascal"
  ],
  "lisp": [
   "Clojure",
   "Common Lisp",
   "Racket",
   "Scheme"
  ],
  "logic": [
   "Forth",
   "Haxe",
   "Prolog",
   "Smalltalk"
  ],
  "ml": [
   "Elm",
   "F#",
   "Haskell",
   "OCaml",
   "PureScript",
   "Standard ML"
  ],
  "scripting": [
   "Lua",
   "PHP",
   "Perl",
   "Python",
   "Ruby",
   "Tcl"
  ],
  "shell": [
   "AWK",
   "Bash",
   "Fish",
   "PowerShell"
  ],
  "systems": [
   "C",
   "C++",
   "Crystal",
   "D",
   "Go",
   "Nim",
   "Odin",
   "Rust",
   "V",
   "Zig"
  ]
 },
 "rounds": [
  {
   "lang": "Zig",
   "family": "systems",
   "code": "const std = @import(\"std\");\n\npub fn main() !void {\n    std.debug.print(\"{d}\\n\", .{42});\n}",
   "id": "r000"
  },
  {
   "lang": "Nim",
   "family": "systems",
   "code": "proc greet(name: string): string =\n  result = \"hi \" & name\n\necho greet(\"world\")",
   "id": "r001"
  },
  {
   "lang": "Crystal",
   "family": "systems",
   "code": "def fib(n : Int32) : Int32\n  n < 2 ? n : fib(n - 1) + fib(n - 2)\nend",
   "id": "r002"
  },
  {
   "lang": "Odin",
   "family": "systems",
   "code": "main :: proc() {\n    nums := [dynamic]int{1, 2, 3}\n    append(&nums, 4)\n}",
   "id": "r003"
  },
  {
   "lang": "V",
   "family": "systems",
   "code": "fn main() {\n    nums := [1, 2, 3]\n    println(nums.map(it * 2))\n}",
   "id": "r004"
  },
  {
   "lang": "D",
   "family": "systems",
   "code": "import std.stdio;\n\nvoid main() {\n    auto arr = [1, 2, 3];\n    writeln(arr);\n}",
   "id": "r005"
  },
  {
   "lang": "Rust",
   "family": "systems",
   "code": "let total: u64 = data\n    .iter()\n    .filter(|x| x.active)\n    .map(|x| x.size)\n    .sum();",
   "id": "r006"
  },
  {
   "lang": "C++",
   "family": "systems",
   "code": "template <typename T>\nconstexpr T square(T v) noexcept {\n    return v * v;\n}",
   "id": "r007"
  },
  {
   "lang": "C",
   "family": "systems",
   "code": "static inline size_t\nbuf_len(const struct buf *b)\n{\n    return b->end - b->start;\n}",
   "id": "r008"
  },
  {
   "lang": "Go",
   "family": "systems",
   "code": "func worker(jobs <-chan int, done chan<- bool) {\n\tfor j := range jobs {\n\t\t_ = j\n\t}\n\tdone <- true\n}",
   "id": "r009"
  },
  {
   "lang": "Haskell",
   "family": "ml",
   "code": "primes = sieve [2..]\n  where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]",
   "id": "r010"
  },
  {
   "lang": "OCaml",
   "family": "ml",
   "code": "let rec sum = function\n  | [] -> 0\n  | h :: t -> h + sum t",
   "id": "r011"
  },
  {
   "lang": "F#",
   "family": "ml",
   "code": "let inline square x = x * x\n\n[1..10] |> List.map square |> List.sum |> printfn \"%d\"",
   "id": "r012"
  },
  {
   "lang": "Elm",
   "family": "ml",
   "code": "type Msg\n    = Increment\n    | Decrement\n\n\nupdate : Msg -> Int -> Int\nupdate msg model =\n    case msg of\n        Increment ->\n            model + 1\n\n        Decrement ->\n            model - 1",
   "id": "r013"
  },
  {
   "lang": "PureScript",
   "family": "ml",
   "code": "main :: Effect Unit\nmain = do\n  log \"hello\"",
   "id": "r014"
  },
  {
   "lang": "Standard ML",
   "family": "ml",
   "code": "fun fact 0 = 1\n  | fact n = n * fact (n - 1);",
   "id": "r015"
  },
  {
   "lang": "Clojure",
   "family": "lisp",
   "code": "(defn transduce-sum [xs]\n  (transduce (comp (filter even?) (map inc)) + xs))",
   "id": "r016"
  },
  {
   "lang": "Racket",
   "family": "lisp",
   "code": "#lang racket\n\n(define (squares n)\n  (for/list ([i (in-range n)]) (* i i)))",
   "id": "r017"
  },
  {
   "lang": "Scheme",
   "family": "lisp",
   "code": "(define (my-map f lst)\n  (if (null? lst)\n      '()\n      (cons (f (car lst)) (my-map f (cdr lst)))))",
   "id": "r018"
  },
  {
   "lang": "Common Lisp",
   "family": "lisp",
   "code": "(defun average (&rest numbers)\n  (/ (reduce #'+ numbers) (length numbers)))",
   "id": "r019"
  },
  {
   "lang": "Kotlin",
   "family": "jvm",
   "code": "data class User(val name: String, val age: Int)\n\nfun adults(users: List<User>) = users.filter { it.age >= 18 }",
   "id": "r020"
  },
  {
   "lang": "Scala",
   "family": "jvm",
   "code": "case class Point(x: Int, y: Int)\n\nval moved = points.map(p => p.copy(x = p.x + 1))",
   "id": "r021"
  },
  {
   "lang": "Groovy",
   "family": "jvm",
   "code": "def numbers = [1, 2, 3, 4]\nprintln numbers.findAll { it % 2 == 0 }.collect { it * it }",
   "id": "r022"
  },
  {
   "lang": "Java",
   "family": "jvm",
   "code": "var result = items.stream()\n    .filter(Objects::nonNull)\n    .collect(Collectors.toUnmodifiableList());",
   "id": "r023"
  },
  {
   "lang": "Ruby",
   "family": "scripting",
   "code": "class Stack\n  def initialize\n    @items = []\n  end\n\n  def push(x)\n    @items << x\n  end\nend",
   "id": "r024"
  },
  {
   "lang": "Python",
   "family": "scripting",
   "code": "match command.split():\n    case [\"go\", direction]:\n        move(direction)\n    case _:\n        pass",
   "id": "r025"
  },
  {
   "lang": "Perl",
   "family": "scripting",
   "code": "my %seen;\nmy @uniq = grep { !$seen{$_}++ } @list;",
   "id": "r026"
  },
  {
   "lang": "Lua",
   "family": "scripting",
   "code": "local function map(t, f)\n  local out = {}\n  for i, v in ipairs(t) do out[i] = f(v) end\n  return out\nend",
   "id": "r027"
  },
  {
   "lang": "Tcl",
   "family": "scripting",
   "code": "proc factorial {n} {\n    if {$n <= 1} { return 1 }\n    return [expr {$n * [factorial [expr {$n - 1}]]}]\n}",
   "id": "r028"
  },
  {
   "lang": "PHP",
   "family": "scripting",
   "code": "$active = array_filter($users, fn($u) => $u->isActive());\nusort($active, fn($a, $b) => $a->age <=> $b->age);",
   "id": "r029"
  },
  {
   "lang": "Elixir",
   "family": "beam",
   "code": "defmodule Math do\n  def sum(list), do: Enum.reduce(list, 0, &+/2)\nend",
   "id": "r030"
  },
  {
   "lang": "Erlang",
   "family": "beam",
   "code": "loop(Count) ->\n    receive\n        {add, N} -> loop(Count + N);\n        stop -> ok\n    end.",
   "id": "r031"
  },
  {
   "lang": "Gleam",
   "family": "beam",
   "code": "pub fn main() {\n  list.range(1, 10)\n  |> list.map(fn(x) { x * x })\n  |> io.debug\n}",
   "id": "r032"
  },
  {
   "lang": "APL",
   "family": "array",
   "code": "⍝ mean of a vector\navg ← {(+/⍵)÷≢⍵}\navg 1 2 3 4 5",
   "id": "r033"
  },
  {
   "lang": "J",
   "family": "array",
   "code": "NB. mean of a list\nmean =: +/ % #\nmean 1 2 3 4 5",
   "id": "r034"
  },
  {
   "lang": "MATLAB",
   "family": "array",
   "code": "A = magic(4);\n[V, D] = eig(A);\ndisp(diag(D)');",
   "id": "r035"
  },
  {
   "lang": "Julia",
   "family": "array",
   "code": "function mandel(z)\n    c = z\n    for i = 1:80\n        z = z^2 + c\n        abs(z) > 2 && return i\n    end\n    80\nend",
   "id": "r036"
  },
  {
   "lang": "R",
   "family": "array",
   "code": "df %>%\n  filter(!is.na(value)) %>%\n  group_by(category) %>%\n  summarise(mean_val = mean(value))",
   "id": "r037"
  },
  {
   "lang": "COBOL",
   "family": "legacy",
   "code": "IDENTIFICATION DIVISION.\nPROGRAM-ID. HELLO.\nPROCEDURE DIVISION.\n    DISPLAY 'HELLO'.\n    STOP RUN.",
   "id": "r038"
  },
  {
   "lang": "Fortran",
   "family": "legacy",
   "code": "program main\n  implicit none\n  integer :: i\n  do i = 1, 10\n     print *, i**2\n  end do\nend program main",
   "id": "r039"
  },
  {
   "lang": "Ada",
   "family": "legacy",
   "code": "procedure Main is\n   Total : Integer := 0;\nbegin\n   for I in 1 .. 10 loop\n      Total := Total + I;\n   end loop;\nend Main;",
   "id": "r040"
  },
  {
   "lang": "Pascal",
   "family": "legacy",
   "code": "function Factorial(n: Integer): Integer;\nbegin\n  if n <= 1 then\n    Factorial := 1\n  else\n    Factorial := n * Factorial(n - 1);\nend;",
   "id": "r041"
  },
  {
   "lang": "TypeScript",
   "family": "curly",
   "code": "type Result<T> = { ok: true; value: T } | { ok: false; error: string };\n\nconst unwrap = <T,>(r: Result<T>): T => {\n  if (!r.ok) throw new Error(r.error);\n  return r.value;\n};",
   "id": "r042"
  },
  {
   "lang": "Dart",
   "family": "curly",
   "code": "class Counter extends StatefulWidget {\n  const Counter({super.key});\n\n  @override\n  State<Counter> createState() => _CounterState();\n}",
   "id": "r043"
  },
  {
   "lang": "C#",
   "family": "curly",
   "code": "public record Point(int X, int Y)\n{\n    public double Length => Math.Sqrt(X * X + Y * Y);\n}",
   "id": "r044"
  },
  {
   "lang": "Swift",
   "family": "curly",
   "code": "extension Collection where Element: Numeric {\n    var total: Element { reduce(0, +) }\n}",
   "id": "r045"
  },
  {
   "lang": "Objective-C",
   "family": "curly",
   "code": "- (NSArray *)filtered {\n    return [self.items filteredArrayUsingPredicate:\n        [NSPredicate predicateWithFormat:@\"active == YES\"]];\n}",
   "id": "r046"
  },
  {
   "lang": "Solidity",
   "family": "curly",
   "code": "function withdraw(uint256 amount) external nonReentrant {\n    require(balances[msg.sender] >= amount, \"insufficient\");\n    balances[msg.sender] -= amount;\n}",
   "id": "r047"
  },
  {
   "lang": "Bash",
   "family": "shell",
   "code": "while IFS= read -r line; do\n  printf '%s\\n' \"${line//foo/bar}\"\ndone < \"$1\"",
   "id": "r048"
  },
  {
   "lang": "PowerShell",
   "family": "shell",
   "code": "Get-ChildItem -Recurse -Filter *.log |\n    Where-Object { $_.Length -gt 1MB } |\n    Sort-Object Length -Descending",
   "id": "r049"
  },
  {
   "lang": "AWK",
   "family": "shell",
   "code": "BEGIN { FS = \",\" }\n$3 > 100 { sum += $3; n++ }\nEND { print sum / n }",
   "id": "r050"
  },
  {
   "lang": "Fish",
   "family": "shell",
   "code": "function backup --argument-names src\n    set -l stamp (date +%Y%m%d)\n    cp -r $src $src.$stamp\nend",
   "id": "r051"
  },
  {
   "lang": "Prolog",
   "family": "logic",
   "code": "ancestor(X, Y) :- parent(X, Y).\nancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).",
   "id": "r052"
  },
  {
   "lang": "Forth",
   "family": "logic",
   "code": ": SQUARE ( n -- n^2 ) DUP * ;\n: CUBE  ( n -- n^3 ) DUP SQUARE * ;",
   "id": "r053"
  },
  {
   "lang": "Smalltalk",
   "family": "logic",
   "code": "Collection >> sum\n    ^ self inject: 0 into: [:acc :each | acc + each]",
   "id": "r054"
  },
  {
   "lang": "Haxe",
   "family": "logic",
   "code": "class Main {\n    static function main() {\n        trace([for (i in 0...5) i * i]);\n    }\n}",
   "id": "r055"
  }
 ]
}