exercism/elixir
70.0
Adequate · 15 November 2026
8.6k
lines of production code
Elixir
primary language
5
measurements over time
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.