Skip to content
CAI
Software that uses CAICheck a score

exercism/scala

63.4

Adequate · 7 November 2026

532

lines of production code

Scala

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Alphametics example solution and metadata

The Alphametics practice exercise now includes an official example solution (Example.scala) that uses Scala's RegexParsers to parse and solve alphametic puzzles, along with the necessary metadata files (config.json and tests.toml) to define the exercise structure, authors, and test cases.

exercises/practice/alphametics/.meta · high confidence

Add Dominoes exercise metadata and example solution

The Dominoes practice exercise now includes its configuration metadata, test mappings, and a reference example solution. The .meta/config.json file defines the exercise's authors, contributors, file paths (solution, test, example, and invalidator), and a blurb describing the task as making a chain of dominoes. The .meta/tests.toml file maps specific test cases to their descriptions, covering scenarios such as empty input, singletons, reversing dominoes, disconnected inputs, and backtracking requirements. Additionally, the .meta/Example.scala file provides a complete reference implementation for the Dominoes exercise, demonstrating how to chain dominoes by finding a valid permutation that forms a continuous loop.

(repo-wide) · high confidence

Add Killer Sudoku Helper exercise for Scala

A new practice exercise has been added to the Scala track, requiring users to write a program that lists all valid digit combinations for a Killer Sudoku cage. The solution involves implementing a \combinations\ method that calculates valid sets of digits summing to a target value, respecting constraints such as unique digits within a cage and excluded digits from standard Sudoku rules. The entry includes the problem instructions, a reference implementation, and a test suite covering trivial single-digit cages, multi-digit combinations, and restricted scenarios.

(repo-wide) · high confidence

Add Lasagna basics exercise

A new 'Lasagna' exercise has been added to the basics concept track. It provides a Scala class skeleton with stub methods for calculating oven time and preparation metrics, accompanied by a test suite that verifies the expected behavior for these calculations.

exercises/concept/basics · high confidence

Add Scala 3 example solution for SGF Parsing exercise

The SGF Parsing exercise now includes a reference implementation in Scala 3, located in .meta/Example.scala. This solution uses Scala's built-in RegexParsers to parse Smart Game Format strings into a tree structure, handling properties, values, and nested game trees. The exercise metadata (config.json) has been updated to point to this new example file, and the test configuration (tests.toml) has been synchronized to ensure all canonical test cases are included.

exercises/practice/sgf-parsing/.meta · high confidence

Add Scala 3 example solutions and metadata for binary-search, phone-number, and sieve exercises

Example solution files (Example.scala) and associated metadata (config.json, tests.toml) have been added for the binary-search, phone-number, and sieve exercises. These files provide reference implementations for Scala 3 and define the test cases and file structure for these practice exercises, enabling users to see correct solutions and allowing the track's tooling to validate submissions against the canonical test suite.

exercises/practice/binary-search/.meta, exercises/practice/phone-number/.meta, exercises/practice/sieve/.meta · high confidence

Add Scala Hamming exercise stub and tests

Added the Scala implementation for the Hamming exercise, providing a \Hamming\ object with a \distance\ method that returns an \Option\[Int\]\ and a corresponding test suite using ScalaTest. The test suite includes cases for identical strands, varying distances, and validation that strands of unequal length return \None\, with most tests currently marked as pending.

exercises/practice/hamming · high confidence

Add Scala example solution and metadata for Largest Series Product

The Scala track now includes an official example solution for the Largest Series Product exercise, located in \.meta/Example.scala\. This file provides a reference implementation that calculates the largest product of a contiguous substring of digits, handling edge cases such as negative spans, invalid characters, and span lengths exceeding the string length. Accompanying metadata files (\config.json\ and \tests.toml\) have been added to define the exercise's authors, source, and test case mappings, enabling users to compare their solutions against this canonical implementation.

exercises/practice/largest-series-product/.meta · high confidence

Add Scala example solution and metadata for lens-person exercise

The lens-person exercise now includes a reference implementation in Scala, provided in \.meta/Example.scala\. This file demonstrates two approaches to solving the problem: one using the Monocle library and another using Scalaz, allowing users to study idiomatic lens usage for updating nested immutable records. A corresponding \.meta/config.json\ file has been added to register the exercise metadata, including the solution file path, test file, and contributor information.

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

Add Scala example solution and metadata for the Meetup exercise

The Meetup exercise now includes an official Scala example solution (\.meta/Example.scala\) that demonstrates how to calculate the date of a meetup given a month, year, day of the week, and schedule (e.g., first Monday, teenth Wednesday). This is accompanied by the creation of \.meta/config.json\ and \.meta/tests.toml\ files, which define the exercise's metadata, file paths, and test cases, enabling users to see a reference implementation and ensuring the exercise is properly configured in the track.

exercises/practice/say/.meta · high confidence

Add Scala linked-list exercise with Deque implementation

The linked-list practice exercise now includes a Scala track, introducing a \Deque\ class and corresponding test suite (\DequeTest.scala\). Users can now implement a double-ended queue supporting push, pop, unshift, and shift operations, with tests verifying basic and complex interaction scenarios.

exercises/practice/linked-list · high confidence

Add Scala stub and test suite for Pythagorean Triplet exercise

The Pythagorean Triplet exercise now includes a Scala implementation stub and a corresponding test suite. The tests verify the \isPythagorean\ helper method and define pending tests for \pythagoreanTriplets\ and \pythagoreanTripletsSum\ methods, establishing the expected behavior for finding triplets within ranges or by sum.

exercises/practice/pythagorean-triplet · high confidence

Add Space Age exercise skeleton for Scala

A new practice exercise for calculating a person's age on other planets has been added to the Scala track. The change introduces a \SpaceAge\ object with stub methods for Earth, Venus, Mercury, Mars, Jupiter, Saturn, Uranus, and Neptune, along with a corresponding test suite that validates the expected age calculations for each planet.

exercises/practice/space-age · high confidence

Add canonical solution and metadata for Prime Factors exercise

The Prime Factors exercise now includes a canonical example implementation (Example.scala) that provides a reference solution using a tail-recursive algorithm for computing prime factors. Additionally, metadata files (config.json and tests.toml) have been added to define the exercise's source, blurb, file structure, and test case mappings, enabling proper configuration and validation within the track.

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

Add circular-buffer exercise

A new circular-buffer exercise has been added to the Scala track. The package includes the problem instructions, a stub implementation for students to complete, a comprehensive test suite covering read/write/overwrite/clear behaviors, and an example solution. The exercise is configured to use sbt 1.13.0 for building.

exercises/practice/circular-buffer, exercises/practice/flower-field · high confidence

Add example solution and metadata for the Complex Numbers exercise

The Complex Numbers practice exercise now includes a reference implementation (Example.scala) that demonstrates how to implement the ComplexNumber case class with arithmetic operations (addition, subtraction, multiplication, division), absolute value, conjugate, and exponential functions. The exercise metadata (config.json) has been updated to point to this example file, list the authors and contributors, and define the file structure for solutions, tests, and invalidation. Additionally, a tests.toml file has been added to map the canonical test cases to their descriptions, ensuring the exercise aligns with the standard problem specifications.

(repo-wide) · high confidence

Add example solutions and metadata for Change and High Scores exercises

This update provides official example solutions and configuration metadata for the 'Change' and 'High Scores' Scala exercises. For 'Change', the example demonstrates a greedy algorithm to find the fewest coins for a given target, while 'High Scores' includes implementations for retrieving the latest score, personal best, top three scores, and a formatted report. Both exercises now include \.meta/config.json\ files defining file paths, authors, contributors, and blurbs, as well as \tests.toml\ files mapping test cases to their descriptions, ensuring consistent validation and documentation for learners.

(repo-wide), exercises/practice/sum-of-multiples/.meta · high confidence

Add example solutions and metadata for practice exercises

Added canonical example implementations and associated metadata files to the \all-your-base\, \custom-set\, \sublist\, and \zipper\ practice exercises. Each exercise now includes a \.meta/Example.scala\ file providing a reference solution, a \.meta/config.json\ file defining file paths, authors, contributors, and blurbs, and a \tests.toml\ file mapping test cases to their descriptions. These changes enable the track's tooling to validate user submissions against the official examples and provide consistent metadata across these exercises.

(repo-wide) · high confidence

Add reference example solutions and metadata for multiple practice exercises

Reference example implementations (Example.scala) and associated metadata (config.json, tests.toml) have been added for the anagram, isogram, matching-brackets, protein-translation, rail-fence-cipher, raindrops, rotational-cipher, scrabble-score, variable-length-quantity, and wordy exercises. These files provide official solution patterns for users to consult and ensure the test suites are correctly mapped to the canonical problem specifications.

(repo-wide) · high confidence

Add reference implementation and metadata for the Strain exercise

The Strain exercise now includes a canonical solution (Example.scala) that implements the \keep\ and \discard\ operations on collections using a tail-recursive helper, along with the necessary metadata files (config.json and tests.toml) to define the exercise structure, file paths, and test cases for users.

exercises/practice/strain/.meta · high confidence

Add stub files for Bowling and Run-Length Encoding exercises

New stub files have been added for the Bowling and Run-Length Encoding exercises, providing the initial class structures and test suites for users to begin implementation. The Bowling stub includes a comprehensive test suite covering scoring rules for strikes, spares, and invalid inputs, while the Run-Length Encoding stub provides tests for encoding and decoding strings with various character patterns.

exercises/practice/bowling, exercises/practice/run-length-encoding · high confidence

Added Scala example solution and metadata for Grade School exercise

The Grade School exercise now includes a reference implementation (Example.scala) that demonstrates how to manage a school roster using an immutable sorted map, along with the necessary metadata files (config.json and tests.toml) to support the Scala track. This allows Scala users to see a working solution and ensures the exercise is properly configured for testing and validation within the track.

exercises/practice/grade-school/.meta · high confidence

Added Scala exercise stubs and tests for Complex Numbers and Simple Linked List

New Scala exercise files have been added for the Complex Numbers and Simple Linked List tracks. The Complex Numbers exercise provides a test suite covering arithmetic operations (addition, subtraction, multiplication, division), absolute value, conjugate, and exponential functions, alongside an empty stub for the \ComplexNumber\ class. The Simple Linked List exercise introduces a \SimpleLinkedList\ trait defining core operations like \add\, \next\, \reverse\, and \toSeq\, accompanied by a test suite that validates list creation, traversal, reversal, and generic type handling using ScalaCheck property tests.

exercises/practice/complex-numbers, exercises/practice/simple-linked-list · high confidence

Added example solution and configuration for the Lens Person exercise

The Lens Person exercise now includes a reference implementation in \.meta/Example.scala\ and its configuration in \.meta/config.json\. The example provides two distinct approaches for users to study: one using the Monocle library and another using Scalaz, both demonstrating how to manipulate nested immutable data structures (Person, Name, Born, Address) using lenses. The configuration file defines the exercise metadata, including the solution and test file paths, and credits the authors and contributors.

exercises/practice/lens-person/.meta · high confidence

Initial release of the Scala track configuration and tooling

This change introduces the foundational structure for the Scala track, including the \config.json\ manifest that defines the track's metadata, exercise list (with slugs, names, difficulties, and topics), and file patterns for solutions, tests, and examples. It also adds essential repository files such as \.gitignore\ to exclude build artifacts and IDE files, \.scalafmt.conf\ to enforce Scala 3 code formatting, and standard documentation files like \README.md\, \LICENSE\, and \CODE\_OF\_CONDUCT.md\.

(repo-wide) · high confidence

Introduce Scala test generation infrastructure for the Exercism track

The testgen module now provides a framework for automatically generating Scala test suites from canonical data. This includes a CanonicalDataParser to read exercise specifications, a TestGenerator trait for defining per-exercise generation logic (with WordCount as the initial implementation), and a Twirl template that produces ScalaTest FunSuite code. A runner script allows invoking the generator for specific exercises, and a version-check-ignore file is added to exclude certain numeric formats from validation.

testgen · high confidence

Introduce automated test generation and CI tooling scripts

The repository now includes a suite of new scripts in the \bin/\ directory to streamline development and CI workflows. \bin/generate-tests\ renders ScalaTest suites from canonical data using Jinja2 templates, ensuring tests stay in sync with upstream specifications. \bin/fetch-configlet\ downloads the latest version of the configlet tool for the current OS and architecture. \bin/test\ runs all exercise tests in a single sbt session, while \bin/verify-exercises-in-docker\ validates solutions against the official test runner image. These changes shift the track from manual test maintenance to an automated, canonical-data-driven approach.

bin · high confidence

Saddle Points exercise metadata and example solution added

The Saddle Points practice exercise now includes its configuration metadata, test suite mapping, and an example solution. The config.json defines the file structure (solution, test, and example files) and credits the authors and contributors. The tests.toml file maps the canonical test cases to their descriptions, ensuring the exercise aligns with the standard problem specification. The Example.scala file provides a reference implementation using a Matrix case class that calculates saddle points by comparing row maximums and column minimums.

(repo-wide) · high confidence

Behavioural changes

Add v3 exercise metadata and example solutions

Practice exercises now include .meta/config.json files that define file paths, authors, contributors, and blurbs, alongside .meta/Example.scala files providing reference solutions and tests.toml files mapping canonical test cases. This structure supports the v3 track configuration and allows the configlet tool to sync metadata and validate test coverage.

(repo-wide) · high confidence

Introduce sbt-based build system with exercise automation

The project now uses sbt (version 1.13.0) as its build tool, replacing the previous setup. A new \ExercisesPlugin\ and \Exercises\ object dynamically generate an sbt subproject for each exercise, enabling a single session to verify all concept and practice exercises. The build compiles the exemplar solution and runs all tests (with 'pending' markers blanked out) to ensure comprehensive validation, while keeping build artifacts out of the exercise directories. The \sbt-twirl\ plugin (version 2.0.7) is also added.

project · high confidence

Kindergarten Garden exercise scaffold updated for Scala

The Kindergarten Garden exercise now provides a Scala implementation scaffold using Scala 2.13 and ScalaTest 3.2.10. The test suite has been synchronized with the canonical data, introducing tests for parsing garden rows and determining plants for multiple students (such as Alice, Bob, and others) based on their seating position. The main source file is initialized as a stub for students to implement the \Garden\ class and \Plant\ enumeration.

exercises/practice/darts, exercises/practice/kindergarten-garden · high confidence

Leap Year exercise scaffold updated for Scala 2.13 and ScalaTest 3.2.10

The Leap Year exercise has been migrated to the new \exercises/practice\ directory structure and updated to use Scala 2.13 with ScalaTest 3.2.10. The test suite now uses \AnyFunSuite\ and \Matchers\, and the \Leap\ object provides a \leapYear\ method stub for users to implement. Several test cases are marked as \pending\, indicating they are not yet active checks.

exercises/practice/leap · high confidence

Migrate Scala exercises to Scala 2.13 and ScalaTest 3.2.10

The Scala track exercises have been updated to use Scala 2.13 and ScalaTest 3.2.10. This migration updates the test suites to use the modern ScalaTest API, such as \AnyFlatSpec\ and \AnyFunSuite\, and adjusts the test structure to match the new framework conventions. Users will now run tests against the updated versions of the language and testing library.

(repo-wide) · high confidence

Migrate Scala exercises to Scala 2.13 and ScalaTest 3.2.10

The Scala track exercises have been updated to use Scala 2.13 and ScalaTest 3.2.10. This migration updates the test suites to use the modern ScalaTest API, such as \AnyFlatSpec\ and \AnyFunSuite\, and adjusts the test structure to match the new framework conventions. Users will now run tests against the updated versions of the language and testing library.

exercises/practice/sum-of-multiples · high confidence

Saddle Points exercise updated to Scala 2.13 and v3 test structure

The Saddle Points exercise has been migrated to the new v3 directory structure and updated to use Scala 2.13 with ScalaTest 3.2.10. The test suite now uses the AnyFunSuite style and includes tests for identifying single and multiple saddle points, handling empty matrices, and processing non-square matrices, with most cases marked as pending to guide implementation.

exercises/practice/saddle-points · high confidence

Simplified Scala stub for Hello World exercise

The Scala stub for the Hello World exercise has been simplified to reduce initial syntax complexity for students. The provided \HelloWorld.scala\ now contains a minimal object with a \hello\ method that returns a placeholder string, allowing learners to focus on the core task of implementing the correct return value without being distracted by boilerplate.

exercises/practice/hello-world · high confidence

Update canonical class names for LargestSeriesProduct and PrimeFactors exercises

The Scala track exercises for LargestSeriesProduct and PrimeFactors have been updated to use canonical class names. The test suites now reference \Series.largestProduct\ and \PrimeFactors.factors\ respectively, aligning the expected API with the canonical naming convention for these practice problems.

exercises/practice/largest-series-product, exercises/practice/prime-factors · high confidence

Updated Scala 'say' exercise with v3 test suite

The 'say' exercise has been moved to the standard exercises/practice directory and its test suite has been synchronized with the canonical data. The tests now use ScalaTest's AnyFunSuite and verify the Say.inEnglish method for converting numbers to their English word representation, covering ranges from zero to one billion and handling out-of-range inputs.

exercises/practice/say · high confidence

Dependencies

Migrate Scala track to Scala 3.9.0 and update test dependencies

The Scala track exercises and test generator have been upgraded to use Scala version 3.9.0. The test framework dependency has been updated to ScalaTest 3.2.19, and the test generator tooling now requires Jinja2 \>= 3.1. Several exercises that require parsing (such as alphametics, forth, matching-brackets, sgf-parsing, and wordy) now include the scala-parser-combinators library version 2.4.0, and the lens-person exercise includes monocle 3.2.0 for optics support.

(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 63 → 63 (+0.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 56 → 56 (+0.0)
  • Architecture 100 → 100 (+0.0)
  • Maturity 57 → 59 (+2.8)
  • Readiness 74 → 74 (+0.0)
  • Security 87 → 78 (-8.2)

Resolved (4)

  • Documentation: no contributor guidance (README.md)
  • Documentation: no installation or build instructions (README.md)
  • Documentation: no usage examples (README.md)
  • Off-boarding risk: anonymized user #1

New (1)

  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 4 commits — 3 feature/other, 1 fixes

By area

  • exercises/practice — 2 commits
  • .github/CODEOWNERS — 1 commit
  • .github/workflows — 1 commit

Notable commits

  • fix: Sync sum-of-multiples' test suite with the canonical data, and fix the example (#901)
  • change: Add a sign-up snippet (#908)
  • change: Bump actions/setup-java from 6.0.0 to 6.1.0 (#907)
  • change: Generate the leap, saddle-points and kindergarten-garden suites (#903)

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/scala 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 7 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 181b66fba657276f52b5e3b5efb5629b8ac1ceff — the exact code this score is about.
  • Scored under rubric-2026.11.2 — 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.3+preprod-110e4fee044f.