Skip to content
CAI
Software that uses CAICheck a score

exercism/elixir

70.0

Adequate · 15 November 2026

8.6k

lines of production code

Elixir

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add 'Bread and Potions' concept exercise for learning Elixir protocols

A new concept exercise titled 'Bread and Potions' has been added to the curriculum. This exercise guides users through implementing and using Elixir protocols by simulating a role-playing game scenario where characters consume items like bread, mana potions, and poison. The package includes the exercise configuration, design documentation outlining learning objectives, and an exemplar solution demonstrating the \Edible\ protocol implementation for various item structs.

exercises/concept/bread-and-potions/.meta · high confidence

Add 'House' practice exercise for the Exercism track

This change introduces a new practice exercise, 'House', which challenges users to recite the nursery rhyme 'This is the House that Jack Built'. The implementation requires writing a \House.recite/2\ function in \lib/house.ex\ that generates specific verses based on start and stop indices. The entry includes the full test suite in \test/house\_test.exs\, an example solution in \.meta/example.ex\, and necessary configuration files like \.meta/config.json\ and \.docs/instructions.md\ to support the new exercise within the track.

exercises/practice/house · high confidence

Add Book Store exercise with discount calculation logic

Introduces the new Book Store practice exercise, which challenges users to calculate the lowest price for a shopping basket by applying tiered discounts for groups of distinct books. The change includes the exercise configuration, a canonical example solution implementing the discount algorithm, and the associated test suite definitions.

exercises/practice/book-store/.meta · high confidence

Add Bowling exercise with solution and test metadata

The Bowling practice exercise is now available, including the stub implementation in lib/bowling.ex, a reference solution in .meta/example.ex, and the test suite metadata in .meta/tests.toml. The solution implements the standard bowling scoring rules, handling strikes, spares, and bonus rolls, while the metadata defines the authorship, file structure, and specific test cases that validate the scoring logic.

exercises/practice/bowling/.meta · high confidence

Add Camicia card game simulation exercise

Added a new practice exercise for the Camicia card game (a variant of Beggar-My-Neighbour). The exercise requires simulating a two-player card game to determine if the match finishes or enters an infinite loop, returning the final status, total cards played, and number of tricks collected. The diff includes the stub implementation in \lib/camicia.ex\, a comprehensive test suite in \test/camicia\_test.exs\, and supporting documentation and configuration files for the track.

exercises/practice/camicia · high confidence

Add City Office concept exercise for Elixir documentation and typespecs

This change introduces the new 'City Office' concept exercise, which guides users through writing module and function documentation (\@moduledoc\, \@doc\) and type specifications (\@spec\) in Elixir. The exercise includes instructions, hints, and an introduction covering typespec syntax, custom types, and argument naming, alongside a starter implementation in \lib/form.ex\ that provides form-handling functions like \blanks\, \letters\, \check\_length\, and \format\_address\.

exercises/concept/city-office/.docs · high confidence

Add Community Garden concept exercise for learning Elixir Agents

This change introduces the 'Community Garden' concept exercise, which teaches users how to use the Elixir \Agent\ module to manage stateful processes. The exercise includes a design document outlining learning objectives around processes and encapsulation, a configuration file mapping the solution and test files, and an exemplar implementation that demonstrates starting an agent, registering plots, listing registrations, releasing plots, and retrieving specific registration details.

exercises/concept/community-garden/.meta · high confidence

Add Connect exercise stub and solution metadata

The Connect exercise is now available with a starter stub in lib/connect.ex for users to implement the game logic, alongside a reference solution in .meta/example.ex. Configuration files (.meta/config.json, .meta/tests.toml) define the exercise structure, test cases, and contributor metadata, while .formatter.exs and .gitignore set up the local development environment for the Elixir track.

exercises/practice/connect/.meta · high confidence

Add Connect exercise stub and solution metadata

This change introduces the Connect exercise for the Elixir track, providing the initial student stub in lib/connect.ex and the corresponding metadata in .meta/config.json. It also includes the reference solution in .meta/example.ex, which implements the game logic to determine the winner of a Hex board, along with the test configuration in tests.toml and standard project files like .formatter.exs and .gitignore.

exercises/practice/dominoes/.meta · high confidence

Add D&D character generation example solution and metadata

The D&D character exercise now includes a reference implementation in \.meta/example.ex\ that provides the \DndCharacter\ module with functions to calculate ability modifiers, generate random ability scores, and create a full character struct. This is accompanied by \.meta/config.json\ defining the exercise metadata (authors, source, blurb) and \.meta/tests.toml\ mapping the canonical test cases, enabling users to view the example solution and ensuring the test suite aligns with the problem specifications.

exercises/practice/dnd-character/.meta · high confidence

Add DNA Encoding concept exercise documentation

Introduced the 'dna-encoding' concept exercise, providing users with instructions to encode and decode nucleic acids into binary representations using Elixir's bitstrings and charlists. The package includes an introduction to tail-call recursion with accumulators, detailed instructions for implementing four functions (encoding/decoding single nucleotides and full charlists/bitstrings), and hints guiding users toward using code points, binary integer literals, and tail-recursive strategies.

(repo-wide) · high confidence

Add Eliud's Eggs exercise for Elixir

A new practice exercise has been added for Elixir users, requiring them to count the number of set bits (1s) in the binary representation of an integer. The exercise includes a stub module \EliudsEggs\ with an \egg\_count/1\ function, a test suite covering cases from 0 to 100 eggs, and an example solution that implements the logic using bitwise operations while restricting the use of standard library bit-counting functions.

exercises/practice/eliuds-eggs · high confidence

Add Food Chain practice exercise

Added the new 'Food Chain' practice exercise for the Elixir track. This includes the stub implementation in \lib/food\_chain.ex\, a comprehensive test suite in \test/food\_chain\_test.exs\ covering individual verses through the full song, an example solution in \.meta/example.ex\, and supporting configuration files (\.meta/config.json\, \.meta/tests.toml\, \.docs/instructions.md\). The exercise challenges users to algorithmically generate the lyrics for the cumulative song 'I Know an Old Lady Who Swallowed a Fly'.

(repo-wide) · high confidence

Add Forth exercise metadata and example solution

This change introduces the configuration and reference implementation for the Forth practice exercise. It adds a \config.json\ file that defines the exercise metadata, including the solution file (\lib/forth.ex\), test file (\test/forth\_test.exs\), and the new example solution location (\.meta/example.ex\). It also includes the \example.ex\ file itself, which provides a complete evaluator for a subset of the Forth language, supporting arithmetic operations, stack manipulation, user-defined words, and case-insensitivity, along with the necessary custom exception types. Finally, a \tests.toml\ file is added to map the canonical test cases to their descriptions.

(repo-wide) · high confidence

Add Graph data structure and DSL macro for dot-dsl exercise

The dot-dsl exercise now includes a starter implementation for the Graph data structure and a DSL macro. The Graph module provides functions to create graphs, set attributes, add nodes and edges, and compare graphs for equivalence using a canonical form. A Graph macro is also provided in the Dot module to facilitate DSL usage.

exercises/practice/dot-dsl · high confidence

Add Killer Sudoku Helper exercise for Elixir

A new practice exercise has been added to the Elixir track to help users practice combinatorial logic by solving Killer Sudoku cages. The entry point is the \KillerSudokuHelper\ module, which provides a \combinations/1\ function that calculates valid sets of distinct digits (1-9) for a given cage size and sum, while respecting excluded digits. The package includes a stub implementation in \lib/killer\_sudoku\_helper.ex\, a comprehensive test suite in \test/killer\_sudoku\_helper\_test.exs\ covering trivial single-digit cages, full 9-digit cages, and restricted combinations, along with an example solution and standard Exercism metadata files.

(repo-wide) · high confidence

Add ListOps and LinkedList exercise stubs

New exercise stubs have been added for the ListOps and LinkedList tracks. The ListOps exercise provides a module with empty implementations for basic list operations (count, reverse, map, filter, foldl, foldr, append, concat) that must be implemented without using external list modules. The LinkedList exercise provides a module with empty implementations for a custom linked list data structure, including operations like push, pop, peek, tail, count, empty?, and conversion to/from standard lists. Both exercises include necessary project configuration files (.formatter.exs, .gitignore) to support local development and testing.

exercises/practice/list-ops · high confidence

Add Mensch Ärgere Dich Nicht concept exercise

Introduces a new concept exercise for learning Elixir streams, including the configuration, design documentation, and an exemplar solution that demonstrates lazy evaluation with \Stream.repeatedly\ and \Stream.transform\.

exercises/concept/mensch-aergere-dich-nicht/.meta · high confidence

Add Pac-Man Rules concept exercise for Elixir

A new concept exercise titled 'Pacman Rules' has been added to the Elixir track. This exercise helps learners understand booleans, logical operators (and, or, not), and function definitions by implementing game logic. The entry includes the configuration file (config.json), design documentation (design.md), and an exemplar solution (exemplar.ex) that demonstrates the expected implementation.

exercises/concept/pacman-rules/.meta · high confidence

Add Pac-Man Rules exercise documentation

The Pac-Man Rules concept exercise now includes its instructional materials, providing users with an introduction to Elixir booleans and the \and/2\, \or/2\, and \not/1\ operators, along with specific instructions and hints for implementing the \Rules\ module functions.

exercises/concept/pacman-rules/.docs · high confidence

Add Paint by Number exercise for learning bitstrings

Introduced a new Elixir concept exercise, Paint by Number, which guides users through working with bitstrings. The exercise includes instructions, hints, and an introduction to the bitstring data type, covering operations such as calculating palette bit sizes, creating and manipulating pictures (prepending, appending, concatenating, and pattern matching pixels), and understanding binary representation. The implementation stub provides seven functions for users to complete: \palette\_bit\_size/1\, \empty\_picture/0\, \test\_picture/0\, \prepend\_pixel/3\, \get\_first\_pixel/2\, \drop\_first\_pixel/2\, and \concat\_pictures/2\.

exercises/concept/paint-by-number/.docs, exercises/concept/paint-by-number/.meta · high confidence

Add Protein Translation exercise with solution and configuration

The Protein Translation practice exercise is now available, including the student stub (\lib/protein\_translation.ex\), a reference solution (\lib/protein\_translation.ex\ in \.meta\), and configuration files (\config.json\, \tests.toml\, \.formatter.exs\, \.gitignore\). The exercise requires users to implement functions that translate RNA sequences into lists of proteins based on codon mappings, handling STOP codons and invalid inputs.

exercises/practice/protein-translation/.meta · high confidence

Add RPN Calculator Inspection exercise stub and project configuration

The RPN Calculator Inspection concept exercise is introduced with a new project structure, including a \.formatter.exs\ for code formatting, a \.gitignore\ for standard Mix artifacts, and a \lib/rpn\_calculator\_inspection.ex\ stub. The stub defines the \RPNCalculatorInspection\ module with four unimplemented functions (\start\_reliability\_check/2\, \await\_reliability\_check\_result/2\, \reliability\_check/2\, and \correctness\_check/2\) that students must implement.

(repo-wide) · high confidence

Add Simple Cipher exercise scaffolding and example solution

The \simple-cipher\ exercise now includes a complete setup for the Elixir track. This adds the \SimpleCipher\ module with \encode/2\, \decode/2\, and \generate\_key/1\ functions, providing both a starter file (\lib/simple\_cipher.ex\) with empty implementations and a reference solution (\.meta/example.ex\). The exercise is configured via \.meta/config.json\ with author/contributor metadata, a blurb, and source links, while \.meta/tests.toml\ defines the specific test cases to run. Supporting files like \.formatter.exs\ and \.gitignore\ are also added to standardize the development environment.

exercises/practice/robot-simulator/.meta, exercises/practice/simple-cipher/.meta · high confidence

Add Stack Underflow concept exercise

A new concept exercise titled 'Stack Underflow' has been added to the track, focusing on defining custom exceptions in Elixir. The exercise continues the context of a Reverse Polish Notation calculator, requiring learners to implement a \StackUnderflowError\ that handles context-specific messages, alongside a \DivisionByZeroError\. The provided solution demonstrates the use of the Exception behaviour, including the \exception/1\ callback for dynamic message construction and raising errors during division operations.

(repo-wide) · high confidence

Add State of Tic Tac Toe exercise for Elixir

A new practice exercise has been added for the Elixir track, requiring users to implement a \StateOfTicTacToe\ module that determines whether a 3x3 Tic-Tac-Toe board is in a win, draw, or ongoing state, or if the board configuration is invalid (e.g., wrong turn order or play continuing after a win). The entry includes the stub implementation in \lib/state\_of\_tic\_tac\_toe.ex\, the reference solution in \.meta/example.ex\, the test suite in \test/state\_of\_tic\_tac\_toe\_test.exs\, and supporting metadata and documentation files.

exercises/practice/state-of-tic-tac-toe · high confidence

Add Strain exercise metadata and example solution

The Strain practice exercise is now available with its configuration, including authors, contributors, and a blurb describing the task to implement \keep\ and \discard\ operations on collections. An example solution file (\example.ex\) is provided, demonstrating implementations of \keep\ and \discard\ using recursion without relying on \Enum.filter\ or \Enum.reject\. Additionally, a test configuration file (\tests.toml\) defines the specific test cases for both keeping and discarding elements from various collection types.

exercises/practice/matrix/.meta, exercises/practice/strain/.meta · high confidence

Add Wine Cellar concept exercise with filtering helpers

The Wine Cellar concept exercise has been added to the track. It includes a stub module for students to implement \explain\_colors/0\ and \filter/3\ functions, along with pre-implemented private helper functions (\filter\_by\_year/2\ and \filter\_by\_country/2\) to assist with filtering logic. The exercise directory also includes standard Elixir project configuration files such as \.formatter.exs\ and \.gitignore\ to support the development environment.

exercises/concept/wine-cellar · high confidence

Add Yacht dice game exercise

Introduced a new practice exercise for the Yacht dice game, providing the starter code in \lib/yacht.ex\ and a reference solution in \.meta/example.ex\. The exercise requires users to implement a \score/2\ function that calculates points for categories such as ones through sixes, full house, four of a kind, straights, choice, and yacht based on a list of five dice rolls.

exercises/practice/yacht/.meta · high confidence

Add Zipper exercise stubs and BinTree inspection helpers

The Zipper practice exercise now includes the standard Elixir project scaffolding (formatter and gitignore files) and the initial library stubs. The \BinTree\ module provides the data structure definition along with a custom \Inspect\ implementation to improve test output readability. The \Zipper\ module exposes the core API for navigating and modifying binary trees, including functions to create a zipper from a tree, retrieve the current node's value, navigate to left/right/parent nodes, and update the tree structure via \set\_value\, \set\_left\, and \set\_right\.

exercises/practice/zipper · high confidence

Add \`react\` practice exercise for implementing a reactive system in Elixir

A new practice exercise has been added to the Elixir track, requiring students to implement a basic reactive system using GenServers. The exercise involves creating input cells with settable values and compute cells that automatically propagate changes to dependent values, including support for registering and firing change notification callbacks. The entry includes the stub implementation in \lib/react.ex\, the test suite in \test/react\_test.exs\, and the reference solution in \.meta/example.ex\.

exercises/practice/react · high confidence

Add bird-count concept exercise for learning recursion

A new concept exercise named 'bird-count' has been added to the Elixir track. This exercise teaches users how to write and call recursive functions, specifically focusing on processing lists using pattern matching, multiple-clause functions, and guards. It includes a configuration file, design documentation outlining learning objectives and prerequisites, and an exemplar solution that implements recursive logic for tasks like counting birds, incrementing daily counts, checking for days without birds, calculating totals, and counting busy days.

exercises/concept/bird-count/.meta · high confidence

Add canonical data and example solution for Rotational Cipher

The Rotational Cipher exercise now includes a canonical test suite (tests.toml) covering rotation by various shifts, handling of uppercase letters, spaces, numbers, and punctuation, along with a reference example solution (example.ex) that implements the Caesar cipher logic. A config.json file has been added to define the exercise metadata, including authors, contributors, and source information.

exercises/practice/rotational-cipher/.meta · high confidence

Add canonical metadata and example solution for the Change exercise

The Change exercise now includes a \.meta/config.json\ file that defines the authorship, contributors, and a blurb describing the task of determining the least number of coins to give as change. An example solution (\example.ex\) has been added to provide a reference implementation for the \Change.generate/2\ function, which returns either \{:ok, list\_of\_coins}\ or \{:error, "cannot change"}\. Additionally, \tests.toml\ has been created to map specific test cases (such as handling single coin changes, large targets, and error conditions) to the canonical problem specifications.

exercises/practice/change/.meta, exercises/practice/roman-numerals/.meta · high confidence

Add chessboard concept exercise for learning Elixir ranges

A new concept exercise has been added to teach learners about Elixir ranges. The exercise requires students to implement a module that generates chessboard ranks (1-8) and files (A-H) using range structs and enumerable functions. The provided solution demonstrates creating range structs, converting them to lists, and mapping code points to strings.

exercises/concept/chessboard/.meta · high confidence

Add concept exercise for MapSets

A new concept exercise, 'gotta-snatch-em-all', has been added to teach the use of Elixir's \MapSet\ module. The exercise guides users through creating collections, adding and removing cards, trading, deduplicating lists, and performing set operations like union, intersection, and difference, along with filtering and partitioning sets.

exercises/concept/gotta-snatch-em-all · high confidence

Add concept exercise for working with files

A new concept exercise named \newsletter\ has been added to the curriculum. This exercise guides users through working with the \File\ module, specifically covering \File.read\, \File.write\, \File.open\, and \File.close\, as well as using the \IO\ module for logging. The implementation involves reading email addresses from a file, sending them via a provided function, and logging successful sends to a separate log file.

exercises/concept/newsletter/.meta · high confidence

Add documentation and hints for the Elixir chessboard exercise

The chessboard concept exercise now includes structured documentation files. An introduction explains how to create and use Ranges in Elixir, while the instructions define four tasks: defining rank and file ranges, and transforming them into lists using Enum functions. A new hints file provides specific guidance on using the range creation operator, Unicode code points, and Enum utilities like to\_list and map.

exercises/concept/chessboard/.docs · high confidence

Add documentation and hints for the Remote Control Car exercise

The Remote Control Car concept exercise now includes its instructional materials. An introduction explains Elixir structs, including their definition with \defstruct\, field access, pattern matching, and the use of \@enforce\_keys\. The instructions guide users through implementing a struct-based car model with specific behaviors for initialization, distance tracking, battery management, and handling a dead battery state. Additionally, a hints file provides targeted advice on using structs, function clauses, and pattern matching to complete the exercise tasks.

exercises/concept/bird-count/.docs, exercises/concept/name-badge/.docs, exercises/concept/remote-control-car/.docs · high confidence

Add documentation for the 'Mensch ärgere dich nicht' concept exercise

This change introduces the instructional materials for the new 'Mensch ärgere dich nicht' exercise, which teaches Elixir streams and enumerables. The package includes instructions for implementing a dice-rolling function that supports lazy evaluation and optional rigged dice, an introduction explaining the difference between eager Enum and lazy Stream modules, and hints guiding users toward specific Elixir functions like Enum.random/1 and Stream.repeatedly/1.

exercises/concept/mensch-aergere-dich-nicht/.docs · high confidence

Add documentation for the RPN Calculator Inspection exercise

The RPN Calculator Inspection concept exercise now includes its instructional materials. New files have been added to provide an introduction to Elixir processes, specifically covering process links, trapping exits, and the Task module (async/await patterns). Additionally, detailed instructions for the four exercise steps and a hints file with relevant documentation links are now available to guide learners.

(repo-wide) · high confidence

Add documentation for the new library-fees concept exercise

Added the \hints.md\, \instructions.md\, and \introduction.md\ files for the \library-fees\ exercise, which teaches users how to work with Elixir's \Date\, \Time\, and \NaiveDateTime\ modules to calculate late fees. The instructions specify a scenario for a library in Ghana (GMT, no DST) and guide the implementation of functions to parse ISO8601 strings, determine return windows based on checkout time, calculate days late, and apply a Monday discount. An \introduction.md.tpl\ template was also added to unify the introduction content with the \dates-and-time\ concept.

exercises/concept/library-fees/.docs, exercises/concept/lucas-numbers/.docs · high confidence

Add example solution and metadata for Rail Fence Cipher

The Rail Fence Cipher exercise now includes a reference implementation (.meta/example.ex) that users can view to understand the expected solution structure, alongside a new .meta/config.json file defining the exercise's metadata (authors, source, blurb) and file paths. The .meta/tests.toml file has also been added to map specific test cases to their descriptions, ensuring the test suite is properly configured for this exercise.

exercises/practice/rail-fence-cipher/.meta · high confidence

Add freelancer-rates concept exercise stub

The freelancer-rates concept exercise has been introduced, providing the initial project structure and stub file for learners. The lib/freelancer\_rates.ex module defines the FreelancerRates module with four functions—daily\_rate/1, apply\_discount/2, monthly\_rate/2, and days\_in\_budget/3—each containing a placeholder comment for implementation. Standard Elixir project configuration files (.formatter.exs and .gitignore) have also been added to support the exercise environment.

exercises/concept/pacman-rules, exercises/practice/knapsack · high confidence

Add hexadecimal exercise configuration and example solution

The hexadecimal practice exercise now includes a \.meta/config.json\ file defining the exercise metadata (authors, contributors, blurb, source) and file paths, alongside a new \.meta/example.ex\ file providing the reference implementation for converting hexadecimal strings to decimal integers.

exercises/practice/hexadecimal/.meta · high confidence

Add high-score concept exercise stub and configuration

The high-score concept exercise now includes a standard Mix project structure with a \.formatter.exs\ for code formatting and a \.gitignore\ to exclude build artifacts. The \lib/high\_score.ex\ stub defines the \HighScore\ module with empty implementations for \new/0\, \add\_player/3\, \remove\_player/2\, \reset\_score/2\, \update\_score/3\, and \get\_players/1\, providing the starting point for learners to implement high-score tracking logic.

exercises/concept/high-score · high confidence

Add ledger refactoring exercise

Introduced a new practice exercise that challenges users to refactor a poorly written ledger printer. The exercise requires rewriting the \format\_entries\ function in \lib/ledger.ex\ to correctly format financial entries based on currency (USD, EUR) and locale (American, Dutch), handling date formatting, number grouping, and description truncation while maintaining specific sorting rules.

exercises/practice/ledger · high confidence

Add log-parser exercise for Elixir regular expressions

Introduced a new \log-parser\ concept exercise that guides users through parsing and cleaning log files using Elixir's \Regex\ module. The exercise includes instructions, hints, and a stub implementation requiring users to implement functions for identifying valid log lines, splitting lines with custom separators, removing artifacts, and tagging lines with user names.

exercises/concept/log-parser/.docs · high confidence

Add log-parser exercise for learning Elixir regular expressions

A new concept exercise, log-parser, has been added to the track. It teaches Elixir-specific regular expression usage, including the Regex module, the =\~ operator, string functions that accept regex, modifiers, capturing groups, and sigils. The exercise includes configuration, design documentation outlining learning objectives and prerequisites, and an exemplar solution demonstrating how to validate log levels, split lines, remove artifacts, and tag lines with user names using regex patterns.

exercises/concept/log-parser/.meta · high confidence

Add new Point of View (POV) tree manipulation exercise

Introduces a new practice exercise for Elixir that challenges users to implement tree reparenting and path-finding logic. The \Pov\ module provides stub functions \from\_pov/2\ and \path\_between/3\ with specified return types (\{:ok, tree} \| {:error, atom}\ and \{:ok, \[any\]} \| {:error, atom}\), along with necessary project configuration files like \.formatter.exs\ and \.gitignore\ to support the new exercise structure.

exercises/practice/pov · high confidence

Add new concept exercise for generating Lucas numbers using streams

A new concept exercise, \lucas-numbers\, has been added to the track. It introduces learners to generating the Lucas number sequence (2, 1, 3, 4, 7, ...) and is designed to teach the use of streams. The exercise includes a stub implementation in \lib/lucas\_numbers.ex\ and standard project configuration files (\.formatter.exs\, \.gitignore\) to support the learning environment.

exercises/concept/lucas-numbers · high confidence

Add new concept exercise for learning Elixir streams

A new concept exercise, 'lucas-numbers', has been added to help users learn about Elixir streams. The exercise requires students to generate the Lucas number sequence, reinforcing concepts such as streams, enums, guards, and anonymous functions. The package includes the necessary configuration, design documentation, and an exemplar solution demonstrating the implementation.

exercises/concept/lucas-numbers/.meta · high confidence

Add new practice exercise: Camicia

A new practice exercise for the Elixir track has been added, requiring users to simulate the 'Camicia' card game (based on Beggar-My-Neighbour). The \Camicia\ module provides a \simulate/2\ function that takes two player decks and returns the game status (\:finished\ or \:loop\) along with the total cards played and tricks collected. The exercise includes instructions, a stub implementation, a reference solution, and a comprehensive test suite covering various game scenarios including loops and different penalty card interactions.

(repo-wide) · high confidence

Add new word-search practice exercise

Introduces a new practice exercise for solving word search puzzles. The entry includes the problem instructions, a stub implementation in \lib/word\_search.ex\ defining the \search/2\ function and \Location\ struct, a comprehensive test suite in \test/word\_search\_test.exs\, and an example solution in \.meta/example.ex\. It also adds necessary configuration files like \.formatter.exs\, \.gitignore\, and metadata in \.meta/config.json\ to integrate the exercise into the track.

exercises/practice/affine-cipher · high confidence

Add new-passport concept exercise for learning the \`with\` expression

A new concept exercise named \new-passport\ has been added to the Elixir track. This exercise is designed to teach learners how to use the \with\ expression to manage control flow and handle errors, specifically focusing on chaining operations and using \else\ clauses for specific error cases. The exercise includes configuration, design documentation, and an exemplar solution that simulates a bureaucratic process for obtaining a passport.

exercises/concept/new-passport/.meta · high confidence

Add new-passport concept exercise for the \`with\` special form

Introduces a new concept exercise, \new-passport\, designed to teach the usage of Elixir's \with\ special form. The exercise provides a scaffold (\lib/new\_passport.ex\) with helper functions simulating a passport renewal workflow (entering a building, finding a counter, stamping a form, and receiving a number), along with documentation (\instructions.md\, \introduction.md\, \hints.md\) that guides users to handle success and failure paths using \with\ chains and \else\ blocks.

exercises/concept/new-passport/.docs · high confidence

Add rational-numbers practice exercise stub

A new practice exercise for rational numbers has been added, providing a module stub with type definitions and function signatures for arithmetic operations (add, subtract, multiply, divide), absolute value, exponentiation (both rational and real bases), and reduction to lowest terms. The entry also includes standard Elixir project configuration files (.formatter.exs and .gitignore) to support the exercise environment.

exercises/concept/freelancer-rates · high confidence

Add reference implementation and metadata for Diffie-Hellman exercise

The Diffie-Hellman practice exercise now includes a reference solution in \.meta/example.ex\ that implements private key generation, public key calculation, and shared secret derivation using Erlang's \:crypto.mod\_pow\. Metadata in \.meta/config.json\ defines the exercise structure, authors, and blurb, while \.meta/tests.toml\ maps the canonical test cases to their descriptions.

exercises/practice/diffie-hellman/.meta · high confidence

Add reference solution and metadata for Minesweeper

The Minesweeper exercise now includes a reference implementation in \.meta/example.ex\ that annotates board cells with adjacent mine counts, along with a \config.json\ defining the solution and test file paths and a \tests.toml\ listing the canonical test cases. This enables automated grading and provides a working example for learners.

exercises/practice/minesweeper/.meta · high confidence

Add reference solution and metadata for the Forth exercise

The Forth exercise now includes a canonical reference implementation in \.meta/example.ex\ and its associated metadata in \.meta/config.json\. The solution implements a stack-based evaluator supporting arithmetic operations (+, -, \*, /), stack manipulation (DUP, DROP, SWAP, OVER), and user-defined word definitions, along with case-insensitivity and proper error handling for stack underflow, division by zero, and unknown words. This provides a complete example for learners to compare against their own implementations.

exercises/practice/twelve-days/.meta · high confidence

Add remote-control-car concept exercise for learning Elixir structs

Introduced a new concept exercise that teaches users how to define and use structs in Elixir. The exercise includes a configuration file, design documentation outlining learning objectives (such as struct declaration, field initialization, and \@enforce\_keys\), and an exemplar solution demonstrating struct creation, pattern matching, and immutable state updates.

exercises/concept/remote-control-car/.meta · high confidence

Add series exercise boilerplate and project configuration

The series exercise now includes a standard Elixir project structure with a \.formatter.exs\ for code formatting, a \.gitignore\ for Mix artifacts, and a \lib/string\_series.ex\ file containing the \StringSeries\ module with the \slices/2\ function signature. This provides users with the necessary scaffolding to implement the series solution.

exercises/practice/series · high confidence

Add starter files and example solution for the All Your Base exercise

The All Your Base exercise now includes a complete set of metadata and source files. A new \.meta/example.ex\ provides the reference implementation for converting numbers between bases, while \.meta/config.json\ defines the file structure and authorship. The \.meta/tests.toml\ file maps the canonical test cases, and standard project scaffolding files (\.formatter.exs\, \.gitignore\) have been added to support local development. The \lib/all\_your\_base.ex\ stub remains as the starting point for students.

exercises/practice/all-your-base/.meta · high confidence

Add stub implementation and project configuration for kitchen-calculator exercise

The kitchen-calculator concept exercise now includes a standard Mix project structure with a \.formatter.exs\ for code formatting and a \.gitignore\ to exclude build artifacts. The core module \KitchenCalculator\ provides stub functions (\get\_volume\, \to\_milliliter\, \from\_milliliter\, and \convert\) that students must implement, replacing any previous placeholder or error-based approach.

exercises/concept/kitchen-calculator · high confidence

Add wine-cellar concept exercise for learning keyword lists

A new concept exercise named 'wine-cellar' has been added to the Elixir track. This exercise teaches users about keyword lists, including their behavior as ordered key-value storage with duplicate keys, usage of the \Keyword\ module, and syntax conventions. The entry includes the configuration, design document, and an exemplar solution that demonstrates filtering wine cellars by color, year, and country using keyword list options.

exercises/concept/wine-cellar/.meta · high confidence

Added Alphametics and Transpose exercise stubs

New exercise stubs for the Alphametics and Transpose tracks have been added to the exercises/practice directory. Each exercise now includes a standard Elixir project structure with a .formatter.exs for code formatting, a .gitignore tailored to Mix artifacts, and a lib module (Alphametics.ex and Transpose.ex) containing the public API signatures and documentation examples for users to implement.

exercises/practice/alphametics, exercises/practice/transpose · high confidence

Added Elixir meetup exercise stub with type specifications

The meetup practice exercise now includes a standard Elixir project structure, providing a \.formatter.exs\ for code formatting, a \.gitignore\ for Mix artifacts, and a \lib/meetup.ex\ stub. The stub defines the \Meetup\ module with type specifications for weekdays and schedules (first, second, third, fourth, last, teenth) and a \meetup/4\ function signature that users must implement to calculate specific meetup dates.

exercises/practice/meetup · high confidence

Added documentation and hints for the Boutique Inventory exercise

The Boutique Inventory concept exercise now includes its instructional materials. The \instructions.md\ file defines five tasks for managing inventory maps: sorting by price, filtering items with missing prices, updating item names, incrementing quantities, and calculating total quantities. The \introduction.md\ file explains the relevant Elixir concepts, specifically the \Enum\ module (including \map\, \reduce\, and \into\) and working with maps. A \hints.md\ file has been added to guide learners toward the correct \Enum\ and \Map\ functions for each task.

(repo-wide) · high confidence

Added documentation and hints for the High Score concept exercise

The High Score concept exercise now includes a new hints.md file providing guidance on using Elixir's Map module functions (put, delete, update, keys) and an introduction.md file explaining maps and module attributes as constants. The instructions.md file has been updated to define the HighScore module functions (new, add\_player, remove\_player, reset\_score, update\_score, get\_players) and their expected behaviors, ensuring learners have the necessary context and support to complete the exercise.

exercises/concept/high-score/.docs · high confidence

Added documentation for the Boutique Suggestions exercise

The Boutique Suggestions concept exercise now includes its instructional materials. Users will find an introduction explaining list comprehensions, generators, filters, and cartesian products in Elixir, along with detailed instructions for implementing the \get\_combinations/3\ function to suggest outfit combinations based on tops, bottoms, and price constraints. A hints file is also provided to guide learners through using comprehensions, pattern matching, and keyword list functions.

(repo-wide) · high confidence

Added example solution and metadata for Difference of Squares

The Difference of Squares exercise now includes a reference implementation in \.meta/example.ex\ and associated metadata in \.meta/config.json\. The example provides the canonical solution for calculating the sum of squares, square of sum, and their difference, while the config file defines the exercise's blurb, source, and file structure. Additionally, \.meta/tests.toml\ was added to map specific test cases to their descriptions, enabling better test tracking and tooling support.

exercises/practice/difference-of-squares/.meta · high confidence

Added library-fees concept exercise stub

A new concept exercise named \library-fees\ has been added to the track. The stub file \lib/library\_fees.ex\ provides the module structure and function signatures for \datetime\_from\_string\, \before\_noon?\, \return\_date\, \days\_late\, \monday?\, and \calculate\_late\_fee\, allowing students to implement date and time handling logic. Supporting configuration files, including \.formatter.exs\ and \.gitignore\, have also been created to set up the standard Mix project environment for this exercise.

exercises/concept/library-fees · high confidence

Added stack-underflow exercise scaffolding

The stack-underflow concept exercise now includes a standard Elixir project structure with a formatter configuration, a gitignore file, and a library module defining stubs for DivisionByZeroError and StackUnderflowError for students to implement.

exercises/concept/stack-underflow · high confidence

Added stub files for new concept exercises

Added new concept exercises for chessboard, date-parser, and dna-encoding, each including a module stub with placeholder functions, a \.formatter.exs\ file for code formatting, and a \.gitignore\ file to exclude build artifacts and dependencies.

exercises/concept/dna-encoding · high confidence

Added stub implementations for Accumulate and FlattenArray exercises

New exercise stubs have been added for the Accumulate and FlattenArray tracks. Each exercise now includes a dedicated .formatter.exs for code formatting, a .gitignore tailored to the Mix build artifacts, and a lib module (Accumulate and FlattenArray respectively) containing the function signatures and documentation examples. Users can now begin implementing these exercises using the provided module structures.

exercises/practice/accumulate, exercises/practice/flatten-array · high confidence

Basketball Website exercise introduces Access Behaviour concepts

The basketball-website concept exercise has been added to teach the Elixir Access Behaviour for extracting deeply nested data. The new files include a configuration defining the solution and test paths, a design document outlining learning objectives around maps and keyword lists, and an exemplar solution demonstrating both manual path traversal and the use of the \get\_in\ macro.

exercises/concept/basketball-website/.meta · high confidence

Beer Song exercise metadata and example solution added

The Beer Song practice exercise now includes its configuration metadata and a reference example solution. A new config.json file defines the exercise's authors, contributors, source information, and the specific file paths for the solution, test, and example files. An example.ex file has been added to .meta, providing a complete implementation of the BeerSong module that handles verse generation for 0, 1, 2, and generic bottle counts, as well as lyrics generation for a range of verses. Additionally, a tests.toml file has been created to map specific test cases to their descriptions, ensuring the exercise's test suite is properly structured and documented.

(repo-wide) · high confidence

Binary Search Tree exercise metadata and solution added

The binary-search-tree practice exercise now includes its configuration, test definitions, and a reference solution. Users can see the exercise blurb, author/contributor credits, and file structure in config.json, while tests.toml defines the specific test cases (such as data retention, insertion logic, and in-order sorting). The .meta/example.ex file provides the canonical Elixir implementation for the BinarySearchTree module, including functions for creating nodes, inserting values, and performing in-order traversal.

exercises/practice/binary-search-tree/.meta · high confidence

Custom Set exercise now includes an official example solution

The Custom Set practice exercise now provides an official reference implementation in \.meta/example.ex\, allowing users to view a working solution after completing the exercise. This change is accompanied by the addition of a \config.json\ file that defines the exercise metadata (including the blurb "Create a custom set type") and explicitly maps the solution, test, and example file paths, ensuring the exercise is properly configured for the v3 track structure.

exercises/practice/custom-set/.meta, exercises/practice/poker/.meta · high confidence

Grade-school exercise scaffold and example solution added

The grade-school practice exercise now includes a complete project structure with a \.formatter.exs\ for code formatting, a \.gitignore\ for Mix artifacts, and a \.meta/config.json\ defining the solution, test, and example file paths along with author metadata. A stub implementation (\lib/school.ex\) is provided for users to fill in, while the \.meta/example.ex\ contains the reference solution implementing the \School\ module with \new/0\, \add/3\, \grade/2\, and \roster/0\ functions. The test suite is defined in \.meta/tests.toml\, specifying which canonical test cases are included or excluded.

exercises/practice/binary/.meta, exercises/practice/grade-school/.meta, exercises/practice/ocr-numbers/.meta · high confidence

Grep exercise now includes official example solution and metadata

The Grep practice exercise now provides an official reference implementation in \.meta/example.ex\, allowing users to view a complete solution after completing the exercise. This is accompanied by a new \.meta/config.json\ file that defines the exercise's metadata, including the blurb, source, and file paths, as well as a \tests.toml\ file that maps test cases to their descriptions. This change standardizes the exercise structure within the v3 track.

exercises/practice/grep/.meta · high confidence

Initial DNA Encoding concept exercise added

A new concept exercise for DNA encoding has been introduced, teaching users about bitstrings and tail-call recursion in Elixir. The package includes a configuration file defining the exercise scope, a design document outlining learning objectives (such as bitstring literals and pattern matching), and an exemplar solution that demonstrates encoding DNA sequences into binary data and decoding them back using recursive functions.

exercises/concept/dna-encoding/.meta · high confidence

Initial Pig Latin exercise scaffold and solution

The Pig Latin practice exercise is introduced with a complete set of supporting files. This includes a stub implementation in lib/pig\_latin.ex for students to fill in, a reference solution in .meta/example.ex that handles vowel/consonant cluster logic, and a test suite defined in .meta/tests.toml covering words starting with vowels, consonants, specific clusters (ch, qu, th, sch, thr), and Y behavior. Metadata in .meta/config.json links these files and provides the exercise blurb, while .formatter.exs and .gitignore configure the Elixir project environment.

exercises/practice/pig-latin/.meta · high confidence

Initial bank-account exercise scaffold for Elixir

The bank-account practice exercise has been added to the Elixir track, providing a starter project structure. This includes a \.formatter.exs\ for code formatting, a \.gitignore\ tailored for Mix artifacts, and the \lib/bank\_account.ex\ module containing the \BankAccount\ API. The module defines the \account\ opaque type and stubs the \open\, \close\, \balance\, \deposit\, and \withdraw\ functions with their respective specs, allowing users to implement the concurrent bank account logic.

exercises/practice/bank-account · high confidence

Initial release of the DNA Encoding concept exercise

A new concept exercise has been added to help learners understand bitstrings and tail-call recursion in Elixir. The package includes a configuration file defining the learning objectives, an exemplar solution demonstrating how to encode and decode DNA sequences using binary data, and a design document outlining the specific concepts (bitstrings, tail-call-recursion) and prerequisites (recursion, charlists, pattern-matching) covered.

exercises/concept/language-list · high confidence

Initial setup for palindrome-products exercise

The palindrome-products practice exercise has been added to the track. This includes the stub implementation in lib/palindrome\_products.ex, the canonical test suite defined in .meta/tests.toml, the reference solution in .meta/example.ex, and supporting metadata (config.json, .formatter.exs, .gitignore) to enable students to solve the problem of detecting palindrome products within a given range.

exercises/practice/palindrome-products/.meta · high confidence

Initial setup of list-ops exercise metadata and example solution

The list-ops exercise is now fully configured with a new .meta/config.json file that defines the solution, test, and example file paths, along with contributor metadata and a blurb. An example solution (.meta/example.ex) has been added, implementing basic list operations (count, reverse, map, filter, foldl, foldr, append, concat) using recursive Kernel functions while avoiding external modules like Enum or List. The tests.toml file has been created to map canonical test cases, including specific handling for fold operations where some tests are marked as reimplemented or excluded.

exercises/practice/secret-handshake/.meta · high confidence

Initial setup of the Bob exercise stub and metadata

The Bob exercise is introduced with a standard project structure, including a \lib/bob.ex\ stub for the solution, a \.meta/example.ex\ containing the reference implementation, and configuration files (\config.json\, \tests.toml\, \.formatter.exs\, \.gitignore\) that define the exercise's metadata, test cases, and formatting rules.

exercises/practice/bob/.meta · high confidence

Initial setup of the ETL exercise with metadata and example solution

The ETL exercise is now fully configured for the v3 track structure. This includes a new \.meta/config.json\ defining the exercise metadata (authors, blurb, file paths), an \.meta/example.ex\ providing the reference solution that transforms Scrabble scores, a \.meta/tests.toml\ listing the canonical test cases, and standard project files (\.formatter.exs\, \.gitignore\) to support the Elixir development environment. The stub file \lib/etl.ex\ is also present for students to implement.

exercises/practice/etl/.meta · high confidence

Initial stub for RPN Calculator Inspection exercise

The RPN Calculator Inspection concept exercise has been added, providing the initial project structure and stub code for students. This includes a \.formatter.exs\ file for code formatting, a \.gitignore\ file to exclude build artifacts, and the \RPNCalculatorInspection\ module containing stub functions (\start\_reliability\_check/2\, \await\_reliability\_check\_result/2\, \reliability\_check/2\, and \correctness\_check/2\) that students must implement.

exercises/concept/rpn-calculator-inspection · high confidence

Initialize Accumulate exercise metadata and example solution

Added the configuration file, canonical test data, and an example solution for the Accumulate exercise. This provides the necessary metadata (authors, contributors, blurb) and a reference implementation to guide users in solving the problem of applying a function to each element of a collection.

exercises/practice/accumulate/.meta · high confidence

Initialize Elixir track repository structure and tooling

The repository is initialized with the core configuration and tooling required for the Exercism Elixir track. This includes a comprehensive \config.json\ defining the track's version, exercises (concept and practice), and file patterns, alongside setup files for code formatting (\.formatter.exs\ with custom Markdown and Doctest formatters), static analysis (\.dialyzer\_ignore.exs\), and version control (\.gitignore\). Documentation files such as \README.md\, \CONTRIBUTING.md\, \HELLO.md\, and \CODE\_OF\_CONDUCT.md\ are added to guide users and contributors, while a \LICENSE\ file establishes the MIT license for the project.

(repo-wide) · high confidence

Initialize nth-prime exercise with solution and metadata

The nth-prime exercise is now available with a complete starter structure. A solution example has been added at .meta/example.ex, and the exercise metadata (config.json) defines the file paths, blurb, and authorship. Test cases are specified in tests.toml, and standard Elixir project files (.formatter.exs, .gitignore) are included to support local development.

exercises/practice/nth-prime/.meta · high confidence

Introduce Take-A-Number concept exercise

Added the new 'Take-A-Number' concept exercise, which teaches users about Elixir processes and process identifiers (PIDs). The package includes the exercise configuration, design documentation outlining learning objectives (such as starting processes and using the Process module), and an exemplar solution demonstrating a simple embedded system for a take-a-number machine.

exercises/concept/take-a-number/.meta · high confidence

Introduce name-badge concept exercise for Elixir

A new concept exercise named 'name-badge' has been added to the Elixir track. This exercise teaches learners about \nil\ values, truthiness, and the \if\ conditional expression by implementing a function that formats name badges for factory employees. The entry includes the configuration metadata, design documentation outlining learning objectives, and an exemplar solution.

exercises/concept/name-badge/.meta · high confidence

Leap year exercise metadata and example solution added

The Leap exercise now includes a \.meta\ directory containing \config.json\, \example.ex\, and \tests.toml\. The configuration file defines the exercise metadata, including authors, contributors, source information, and the specific files for the solution, test, and example implementations. The \example.ex\ file provides a reference implementation for determining leap years, while \tests.toml\ lists the canonical test cases that validate the logic for common and leap years.

exercises/practice/leap/.meta · high confidence

New 'Need for Speed' concept exercise for Elixir

Added a new concept exercise that teaches module composition via \alias\ and \import\. The exercise provides a skeleton \NeedForSpeed\ module with compilation errors, requiring learners to add aliases for \NeedForSpeed.Race\ and \NeedForSpeed.RemoteControlCar\, and to import specific functions from \IO\ and \IO.ANSI\ to fix the code and print race status.

exercises/concept/need-for-speed · high confidence

New 'Top Secret' concept exercise for learning AST manipulation

A new concept exercise named 'Top Secret' has been added to the Elixir track, focusing on the Abstract Syntax Tree (AST). This exercise teaches users how to parse strings into ASTs, understand their structure, and traverse them to decode secret messages, specifically covering functions like \Code.string\_to\_quoted!\ and \Macro.prewalk\ while excluding macros and quote/unquote.

exercises/concept/top-secret/.meta · high confidence

New Killer Sudoku Helper exercise for the Elixir track

Added a new practice exercise, \killer-sudoku-helper\, which challenges users to write a program that lists all valid digit combinations for a given Killer Sudoku cage. The solution requires implementing a \combinations\ function that takes a cage's size, target sum, and excluded digits, then returns sorted lists of distinct digits from 1-9 that satisfy the constraints. The entry includes the full exercise scaffold: instructions, metadata, a stub implementation in \lib/killer\_sudoku\_helper.ex\, a test suite in \test/killer\_sudoku\_helper\_test.exs\, and supporting configuration files.

exercises/practice/killer-sudoku-helper · high confidence

New Top Secret concept exercise on Elixir ASTs

A new concept exercise named 'top-secret' has been added to the Elixir track, focusing on Abstract Syntax Trees (ASTs). This exercise guides users through implementing functions to convert Elixir code strings into ASTs, parse specific AST nodes to extract function names based on arity, and decode secret messages hidden within function definitions, including handling function guards.

exercises/concept/top-secret/.docs · high confidence

New bin scripts for exercise bootstrapping and CI validation

Added a suite of new scripts in the bin directory to streamline the development workflow. \generate\_practice\_exercise.sh\ and \bootstrap\_practice\_exercise.exs\ allow contributors to scaffold new practice exercises with the correct directory structure, \mix.exs\, and stub code. Several validation scripts (\check\_formatting.sh\, \check\_autogenerated\_files.sh\, \check\_concepts.exs\, \check\_practice\_exercise\_order.exs\, and \dialyzer\_check.sh\) have been introduced to enforce code quality, ensure autogenerated files are up to date, verify concept coverage, and validate type specifications. These are orchestrated by \ci-check.sh\ for pre-commit checks and \ci.sh\ for full test execution, which now runs \test\_exercises.sh\ to validate each exercise against its example solution.

bin · high confidence

New city-office concept exercise for Elixir documentation and typespecs

A new concept exercise named 'city-office' has been added to the Elixir track. This exercise guides users through writing module documentation (@moduledoc, @doc) and typespecs (@spec, @type) for a set of simple form-handling functions, covering topics such as union types, named arguments, and atom literals in type definitions.

exercises/concept/city-office/.meta · high confidence

New concept exercise \`dancing-dots\` introduced

A new concept exercise named \dancing-dots\ has been added to the track. This exercise focuses on the \use\ macro and Elixir behaviours. It provides a scaffold for students to implement animation modules (such as \Flicker\ and \Zoom\) that conform to the \DancingDots.Animation\ behaviour, utilizing a \DotGroup\ helper to apply these animations to a collection of dots.

exercises/concept/dancing-dots · high confidence

New concept exercise for learning Elixir behaviours and the use macro

A new concept exercise, \dancing-dots\, has been added to help learners understand Elixir behaviours and the \use\ macro. The exercise guides users through defining a behaviour with callbacks, providing default implementations, and implementing custom logic for dot-based animations, specifically covering \@impl\ usage and callback overrides.

exercises/concept/dancing-dots/.meta · high confidence

New concept exercise: Captain's Log

Added the 'Captain's Log' concept exercise, which teaches users how to generate random data in Elixir. The exercise covers using \Enum.random\ for selecting random elements from lists and ranges, and demonstrates interoperability with Erlang libraries by using \:rand.uniform\ for random floats and \:io\_lib.format\ for string formatting. Documentation includes instructions, hints, and an introduction covering the 'randomness' and 'erlang-libraries' concepts.

exercises/concept/captains-log/.docs · high confidence

New concept exercise: Take-A-Number Deluxe for learning GenServers

A new concept exercise, \take-a-number-deluxe\, has been added to teach the use of GenServers in Elixir. This exercise guides learners through implementing an embedded system for a 'Take-A-Number' machine, covering key GenServer concepts such as \init\, \handle\_call\, \handle\_cast\, \handle\_info\, and timeout handling. The exercise includes a provided exemplar solution and design documentation outlining learning objectives and prerequisites.

exercises/concept/take-a-number-deluxe/.meta · high confidence

New concept exercise: take-a-number-deluxe

Added a new concept exercise, \take-a-number-deluxe\, which guides users in implementing a GenServer-based number queue system. The exercise provides stubs for client API functions (\start\_link\, \report\_state\, \queue\_new\_number\, \serve\_next\_queued\_number\, \reset\_state\) and server callbacks in \lib/take\_a\_number\_deluxe.ex\, along with supporting modules for queue management (\TakeANumberDeluxe.Queue\) and state handling (\TakeANumberDeluxe.State\) that include validation logic and queue operations.

(repo-wide) · high confidence

New darts practice exercise added

A new practice exercise for the Darts problem has been introduced, providing the initial project structure including a \.formatter.exs\ configuration, a \.gitignore\ file for Mix artifacts, and a \lib/darts.ex\ stub. The stub defines a \Darts\ module with a \position\ type alias and a \score/1\ function signature that users must implement to calculate the score of a dart based on its coordinates.

exercises/concept/boutique-inventory/.meta, exercises/practice/darts · high confidence

New high-score concept exercise for learning Elixir maps

A new concept exercise titled 'high-score' has been added to the Elixir track. This exercise teaches users how to work with maps, including defining map literals, adding, updating, and removing values, and using the Map module functions. The provided solution demonstrates these concepts by managing a collection of player scores.

exercises/concept/high-score/.meta · high confidence

New practice exercise for counting ASCII rectangles

A new practice exercise has been added for the \rectangles\ problem. It includes a stub implementation in \lib/rectangles.ex\ with a \count/1\ function signature, along with standard Elixir project configuration files (\.formatter.exs\ and \.gitignore\) to support local development and testing.

exercises/practice/rectangles · high confidence

New practice exercise: Point of View

Added the 'Point of View' exercise, which challenges users to reparent a tree structure on a selected node and find paths between nodes. The entry includes the configuration metadata, a reference implementation using a zipper pattern for tree navigation, and the associated test suite defining scenarios for rerooting trees and handling errors for nonexistent nodes.

exercises/practice/pov/.meta · high confidence

Parallel Letter Frequency exercise metadata and example solution added

The parallel-letter-frequency exercise now includes its configuration metadata, test definitions, and an example solution. The config.json file defines the solution file (lib/frequency.ex), test file (test/frequency\_test.exs), and the new example implementation (.meta/example.ex), while also listing contributors and providing a blurb. The example.ex file implements the frequency function using parallel computation via Task.async/await, handling character rejection (numbers, whitespace, punctuation) and case insensitivity. The tests.toml file maps 14 test cases covering scenarios like empty texts, single/multiple letters, Unicode support, and various character filtering requirements.

exercises/practice/luhn/.meta, exercises/practice/triangle/.meta · high confidence

Pascal's Triangle exercise metadata and example solution added

The Pascal's Triangle practice exercise now includes its configuration metadata, test definitions, and an official example solution. Users can now view the list of authors and contributors, see the specific source reference (Wolfram Math World), and access the provided \.meta/example.ex\ implementation which demonstrates how to calculate the triangle rows. The \tests.toml\ file explicitly maps the test cases for row counts from zero to ten, ensuring the exercise is fully configured for the v3 track structure.

exercises/practice/pascals-triangle/.meta · high confidence

Scale Generator exercise scaffold and solution metadata added

The Scale Generator exercise now includes its complete project structure and metadata. This adds the \.meta/config.json\ file defining the exercise's authors, contributors, and file paths, alongside the \.meta/example.ex\ solution file that implements the \ScaleGenerator\ module (including functions for chromatic scales, flat scales, and pattern-based scale generation). The stub file \lib/scale\_generator.ex\ is provided with function signatures and documentation for users to implement, while \tests.toml\ maps the test cases to the problem specification, and standard Elixir configuration files (\.formatter.exs\, \.gitignore\) are included to support the local development environment.

exercises/practice/scale-generator/.meta · high confidence

Standardize exercise metadata and add example solutions

The run-length-encoding and scrabble-score exercises now include .meta/config.json files that define authors, contributors, file paths, and descriptions, alongside new .meta/example.ex files providing reference implementations. This change standardizes how exercise metadata is stored and makes official solution examples available for learners and tooling.

exercises/practice/run-length-encoding/.meta, exercises/practice/scrabble-score/.meta · high confidence

Behavioural changes

2 commits (0 fixes) modifying exercises/concept/file-sniffer/assets

A change to existing behaviour in exercises/concept/file-sniffer/assets — 2 commits, 6 files: “Rename concept exercises”; “Add a test case for File Sniffer exercise (\#1321)” (refs \#1321).

exercises/concept/file-sniffer/assets · medium confidence · unverified

Add documentation and hints for the freelancer-rates exercise

The freelancer-rates exercise now includes structured documentation files: instructions.md defines the four tasks (calculating daily rate, discounted price, monthly rate, and workdays in budget), introduction.md explains Elixir integers and floats, hints.md provides guidance on relevant Kernel and Float functions, and introduction.md.tpl serves as a template for concept integration.

exercises/concept/freelancer-rates/.docs · high confidence

Bank Account exercise updated with Elixir-specific GenServer implementation and test configuration

The Bank Account exercise now provides an example solution using Elixir's GenServer to handle concurrent transactions, replacing previous approaches that did not leverage process isolation. The \.meta\ directory has been restructured to include a \config.json\ defining the solution, test, and example file paths, a \tests.toml\ mapping specific test cases (including those for concurrency and error handling), and a \design.md\ explaining why certain state-transition tests (like reopening accounts) are skipped in this language. Users will now see an example implementation that manages account state via process messages, ensuring correct behavior for open, close, balance, deposit, and withdraw operations in a concurrent environment.

exercises/practice/bank-account/.meta · high confidence

Clock exercise scaffold and solution structure updated

The Clock practice exercise now includes a dedicated example solution in .meta/example.ex, a configuration file (.meta/config.json) defining the solution, test, and example file paths, and a comprehensive tests.toml mapping canonical test cases. A new .formatter.exs and .gitignore have been added to support local development with Mix, while the student stub in lib/clock.ex retains the Clock.new/2 and Clock.add/2 API signatures for implementation.

exercises/practice/clock/.meta · high confidence

Exercises relocated to exercises/practice directory

The existing exercise stubs, including their Elixir module files, formatter configurations, and gitignore rules, have been moved into the exercises/practice directory. This reorganization structures the repository to clearly separate practice exercises from other content.

(repo-wide) · high confidence

File Sniffer exercise now returns nil for unknown file types

The File Sniffer concept exercise has been updated to handle unknown file inputs gracefully. The solution logic now returns \nil\ when a file extension or binary signature is not recognized, rather than raising an error or returning a default value. This change ensures that the exercise correctly tests pattern matching on binary data and edge cases where the file format cannot be identified.

exercises/concept/file-sniffer/.meta · high confidence

Gigasecond exercise metadata and example solution standardized

The Gigasecond exercise metadata has been updated to align with the v3 track structure. A new config.json file now explicitly defines the solution, test, and example file paths, lists the authors and contributors, and includes the exercise blurb and source information. The example solution has been moved to .meta/example.ex, and the tests.toml file has been regenerated to reflect the current test specifications, including the exclusion of the 'does not mutate the input' test case.

exercises/practice/gigasecond/.meta · high confidence

Hello World exercise stub now returns incorrect output

The starter code for the Hello World exercise in the \lib/hello\_world.ex\ file has been changed to return "Goodbye, Mars!" instead of the expected "Hello, World!". This behavioral change in the provided stub will cause tests to fail immediately upon running them, requiring users to manually correct the return value to complete the exercise.

exercises/practice/hello-world/.meta · high confidence

Initial v3 metadata and example solution for list-ops

The \list-ops\ exercise has been updated to the v3 track structure. This change introduces a \.meta/config.json\ file that defines the exercise's metadata, including the solution file (\lib/list\_ops.ex\), test file (\test/list\_ops\_test.exs\), and the new example solution location (\.meta/example.ex\). The \tests.toml\ file has been regenerated to align with the canonical problem specifications, mapping test cases for operations like append, concat, filter, map, count, reverse, and fold. The provided example solution implements these list operations using recursive functions while avoiding external modules like \List\ or \Enum\, adhering to the exercise's constraints.

exercises/practice/list-ops/.meta · high confidence

Kitchen Calculator exercise updated to use exemplar and new config structure

The Kitchen Calculator concept exercise has been restructured to align with the v3 exercise specification. The solution file is now provided as an 'exemplar' in .meta/exemplar.ex rather than a traditional solution, and the exercise configuration (.meta/config.json) has been updated to include a blurb describing the learning objectives (tuples and pattern matching) and a flattened authors/contributors list. The design documentation (design.md) has also been added to outline learning objectives, prerequisites, and analyzer rules.

exercises/concept/kitchen-calculator/.meta · high confidence

Lasagna exercise documentation restructured with new hints and introduction

The Lasagna concept exercise documentation has been reorganized to improve clarity and consistency. A new hints.md file has been added, providing specific guidance for each of the five tasks, including references to Elixir functions, integers, strings, and operators. The instructions.md file has been updated to clearly define the expected functions (expected\_minutes\_in\_oven, remaining\_minutes\_in\_oven, preparation\_time\_in\_minutes, total\_time\_in\_minutes, alarm) with their arguments and return values. The introduction.md file has been expanded to cover basics like variables, modules, named functions, arity, naming conventions, the standard library, and code comments, with a new introduction.md.tpl template file added to unify introduction contents across exercises.

exercises/concept/lasagna/.docs · high confidence

Lasagna exercise migrated to v3 concept structure

The Lasagna exercise has been restructured for the v3 curriculum, moving from a practice exercise to a concept exercise focused on 'basics'. The configuration now uses the 'exemplar' file for solution references instead of 'example', and includes a specific blurb describing the learning objectives. The design documentation has been updated to reflect the new scope, emphasizing variables, functions, and basic data types, while the analyzer rules have been refined to check for specific function calls within the solution.

exercises/concept/lasagna/.meta · high confidence

Lasagna exercise scaffold updated with formatter and gitignore

The Lasagna concept exercise now includes a \.formatter.exs\ file to enforce consistent code formatting via \mix format\, and a \.gitignore\ file to exclude build artifacts and dependencies. The main source file \lib/lasagna.ex\ has been updated to use polite instructional comments (replacing 'TODO:') for the functions students need to implement.

exercises/concept/lasagna · high confidence

Markdown exercise scaffold and solution updated

The Markdown practice exercise now includes a complete solution implementation in .meta/example.ex, which parses Markdown syntax (headers, bold, italic, lists) into HTML. The exercise metadata in .meta/config.json has been updated to define the solution, test, and example file paths, and includes contributor information. A new .formatter.exs file configures the Mix project for code formatting, and a .gitignore file excludes standard Elixir build artifacts. The test suite in tests.toml has been synchronized with canonical data, including specific test cases for various header levels, list handling, and edge cases like h7 headers being treated as paragraphs.

exercises/practice/markdown/.meta · high confidence

Pythagorean Triplet exercise scaffold and example solution updated

The Pythagorean Triplet exercise now includes a complete example solution in .meta/example.ex, providing a reference implementation for users. The exercise metadata in .meta/config.json has been updated to list authors and contributors, and the test suite is defined in .meta/tests.toml. Additionally, standard Elixir project files (.formatter.exs and .gitignore) have been added to support local development and code formatting.

exercises/practice/pythagorean-triplet/.meta · high confidence

RPN Calculator exercise updated to use exemplar and new error-handling concepts

The RPN Calculator concept exercise has been restructured to align with the new v3 exercise format. The configuration now points to a dedicated exemplar solution file instead of the previous example structure, and includes a specific icon and blurb. The exercise design has been updated to focus on learning objectives for errors, raising, rescuing, and the \!\ suffix convention, while explicitly excluding exception definitions and \throw\/\catch\. The provided exemplar solution demonstrates these concepts by implementing \calculate!\, \calculate\, and \calculate\_verbose\ functions that handle operations using \try-rescue\ blocks.

exercises/concept/rpn-calculator/.meta · high confidence

Redesign of the language-list exercise documentation

The language-list exercise documentation has been restructured to provide clearer guidance for learners. The instructions now explicitly define six specific functions (\new/0\, \add/2\, \remove/1\, \first/1\, \count/1\, and \functional\_list?/1\) with precise arity and argument descriptions, replacing previous vague or inconsistent instructions. A new dedicated hints file has been added to point users to specific Elixir Kernel functions (\hd\, \tl\, \length\, \in\) for each task, and the introduction has been updated to explain linked list notation and basic list operations.

exercises/concept/language-list/.docs · high confidence

Resistor Color exercise updated to use atoms and a single code function

The Resistor Color exercise has been refactored to align with the \resistor-color-duo\ and \resistor-color-trio\ exercises by removing the \colors\ function and requiring students to implement a \code/1\ function that accepts an atom (e.g., \:black\) and returns its corresponding integer value. The provided stub in \lib/resistor\_color.ex\ and the example solution in \.meta/example.ex\ now use a map keyed by atoms, and the test configuration in \.meta/tests.toml\ explicitly excludes the \Colors\ test case to reflect this behavioral change.

exercises/practice/resistor-color/.meta · high confidence

Space Age exercise now returns errors for invalid planets

The Space Age exercise has been updated to handle invalid input gracefully. Instead of crashing or returning undefined behavior, the \SpaceAge.age\_on/2\ function now returns an \{:error, "not a planet"}\ tuple when a planet name that is not one of the eight solar system planets is provided. This change aligns the exercise with the canonical test suite, which includes a specific test case for this error condition, and ensures users learn to implement proper error handling for unexpected inputs.

exercises/practice/space-age/.meta · high confidence

Standardize concept exercise stubs with formatter configs and comment-based instructions

Concept exercises now include .formatter.exs files to enforce consistent code formatting via mix format, and their lib stubs use comments instead of RuntimeErrors to guide implementation. This change improves the development experience by ensuring code style consistency and providing clearer, non-executing instructions for students.

(repo-wide) · high confidence

Standardize exercise stubs with Mix project structure and charlist syntax

The Hamming, Nucleotide Count, and RNA Transcription exercises have been updated to use the new charlist syntax (e.g., \~c"...") in their documentation examples and type specifications. Additionally, each exercise now includes a standard Mix project structure, featuring .formatter.exs for code formatting, .gitignore files tailored to the specific package name, and lib stubs that define the module interfaces for users to implement.

exercises/practice/hamming, exercises/practice/nucleotide-count, exercises/practice/rna-transcription · high confidence

Standardized default README template for Elixir exercises

A new default template for exercise READMEs has been introduced, providing a consistent structure for students. This template includes the exercise description, specific instructions for running tests using \mix test\, and guidance on handling pending tests (unskipping via \@tag :pending\ or \ExUnit.configure\). It also links to available resources and includes sections for source credits and submitting incomplete solutions, ensuring a uniform onboarding experience across Elixir exercises.

config · high confidence

Update concept exercise stubs to use comments instead of RuntimeErrors

The stub files for several concept exercises (including bird-count, community-garden, german-sysadmin, mensch-aergere-dich-nicht, name-badge, take-a-number, and wine-cellar) have been updated to replace RuntimeErrors with descriptive comments. This change improves the learning experience by providing clearer guidance on what needs to be implemented, rather than throwing errors when the stub code is run.

(repo-wide) · high confidence

Updated boutique-inventory exercise stubs and added project scaffolding

The boutique-inventory concept exercise now provides a cleaner stub file (lib/boutique\_inventory.ex) with placeholder functions for inventory operations, replacing previous RuntimeErrors with comments to guide implementation. Additionally, the exercise directory now includes standard Elixir project scaffolding files (.formatter.exs and .gitignore) to support local development and formatting.

exercises/concept/boutique-inventory · high confidence

Updated documentation for the RPG Character Sheet exercise

The documentation for the Elixir RPG Character Sheet exercise has been refreshed to align with the new IO concept. The introduction now explicitly covers \IO.puts\, \IO.write\, \IO.gets\, and \IO.inspect\ with examples. Hints have been added to guide learners through implementing the five steps (welcome, ask name, class, level, and combine) using standard IO functions and string manipulation. A new debug guide explains that IO tests require capturing output, making \IO.inspect\ debugging unavailable for this specific exercise.

exercises/concept/high-school-sweetheart/.docs, exercises/concept/rpg-character-sheet/.docs · high confidence

Updated dot-dsl exercise configuration and example solution

The dot-dsl practice exercise now includes a dedicated .meta/config.json file that defines the file structure (solution, test, example, and editor files) and provides metadata such as the blurb and source attribution. Additionally, the example solution has been moved to .meta/example.ex, implementing the Dot module with a macro-based DSL to construct graphs, nodes, and edges using the Graph API.

exercises/practice/dot-dsl/.meta · high confidence

Updated metadata and example solution for Sum of Multiples exercise

The Sum of Multiples exercise metadata has been refreshed to align with the latest canonical data. The .meta/config.json file now explicitly lists authors, contributors, and the specific file paths for the solution, test, and example files, along with a blurb and source attribution. A new .meta/example.ex file provides a reference implementation for the exercise. Additionally, the tests.toml file has been updated to include all canonical test cases, ensuring that learners are tested against the complete set of requirements, including edge cases like factors of zero and large limits.

exercises/practice/flatten-array/.meta, exercises/practice/hamming/.meta, exercises/practice/sum-of-multiples/.meta · high confidence

Test coverage

2 commits adding/updating tests in exercises; Add initial test suite for the Rational Numbers exercise; Add test suite for Community Garden concept exercise; Added Pig Latin exercise tests for Elixir; Added initial test suite for the Roman Numerals exercise; Added test helper for RPN Calculator Output exercise; Added test helper to configure ExUnit and load example files; Added test suite for Boutique Inventory concept exercise; Added test suite for D&D character generation; Added test suite for Hamming distance exercise; Added test suite for Pascal's Triangle exercise; Added test suite for the High School Sweetheart exercise; Added test suite for the Luhn algorithm exercise; Added test suite for the Point of View exercise; Added test suite for the Sieve of Eratosthenes exercise; Added test suite for the new Affine Cipher practice exercise; Added test suites for Beer Song and Collatz Conjecture exercises; Added test suites for multiple practice exercises; Added tests for RPN Calculator exception handling; Added tests for RPN Calculator output handling; Added tests for the Mensch Ärgere Dich Nicht concept exercise; Added tests for the Newsletter concept exercise; Added tests for the take-a-number-deluxe GenServer exercise; Initial test suite for the RPN Calculator concept exercise.

Dependencies

Standardized Mix project configurations for exercises

Concept and practice exercises now include standardized mix.exs files, providing a consistent build environment for learners. These files define the application structure, set the version to 0.1.0 (with one exception at 1.0.0), and configure the project to start as permanent in production. Most exercises have a commented-out Elixir version requirement, while concept exercises omit this constraint entirely, ensuring a uniform starting point for all tracks.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 71 → 70 (-1.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 98 → 97 (-1.0)
  • Architecture 97 → 97 (+0.0)
  • Maturity 58 → 58 (+0.0)
  • Readiness 73 → 73 (+0.0)
  • Security 88 → 81 (-7.7)

Resolved (5)

  • Duplicated block (30 lines × 2) (exercises/concept/need-for-speed/.meta/exemplar.ex)
  • Duplicated block (5 lines × 2) (exercises/concept/new-passport/.meta/exemplar.ex)
  • Duplicated block (5 lines × 2) (exercises/concept/new-passport/.meta/exemplar.ex)
  • Duplicated block (6 lines × 2) (exercises/concept/new-passport/.meta/exemplar.ex)
  • Edited copy of a member (13 corresponding lines) (exercises/concept/new-passport/.meta/exemplar.ex)

New (6)

  • Edited copies of one member (3 members, 15+ corresponding lines) (exercises/practice/piecing-it-together/.meta/example.ex)
  • Edited copy of a member (1 corresponding lines) (exercises/practice/binary/.meta/example.ex)
  • Edited copy of a member (1 corresponding lines) (exercises/practice/flower-field/.meta/example.ex)
  • Edited copy of a member (1 corresponding lines) (exercises/practice/parallel-letter-frequency/.meta/example.ex)
  • Edited copy of a member (16 corresponding lines) (exercises/practice/swift-scheduling/.meta/example.ex)
  • Edited copy of a member (17 corresponding lines) (exercises/practice/affine-cipher/.meta/example.ex)

Changes since last survey

  • 7 commits — 7 feature/other, 0 fixes

By area

  • exercises/practice — 4 commits
  • .github/CODEOWNERS — 2 commits
  • .github/required-checks.yml — 1 commit

Notable commits

  • change: Add a sign-up snippet (#1663)
  • change: Add a summary job for Tests (#1665)
  • change: List the checks that must pass before a PR can merge (#1664)
  • change: Sync line-up (#1662)
  • change: Sync list-ops (#1661)
  • change: Sync pig latin (#1666)
  • change: 🤖 Auto-sync docs, metadata, and filepaths (#1667)

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

exercism/elixir was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 5413474e113c299c8125570ee7cafb02d0f6181e — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.