This Kata was posted as the problem to be solved in a “self-documenting code contest”.
The results of the code contest can be found here.
Write a program that generates all two-word anagrams of the string “documenting”.
You must focus on the readability of your code, and you must not include any kind of documentations to it.
The goal is to create a code that everybody can read and understand easily.
Here’s a word list you might want to use.
This Kata is presented in Robert C.. Martin’s book “Clean Code”, chapter 14.
Most of us have had to parse command-line arguments from time to time. If we don’t have a convenient utility, then we simply walk the array of strings that is passed into the main function. There are several good utilities available from various sources, but they probably don’t do exactly what we want. So let’s write another one!
This Kata was presented at XP2006 by EmmanuelGaillot and ChristopheThibaut .
Contents:
You work for a bank, which has recently purchased an ingenious machine to assist in reading letters and faxes sent in by branch offices. The machine scans the paper documents, and produces a file with a number of entries which each look like this:
As you’re a very friendly person, you would like to send a birthday note to all the friends you have. But you have a lot of friends and a bit lazy, it may take some times to write all the notes by hand.
The good news is that computers can do it automatically for you.
Imagine you have a flat file with all your friends :
last_name, first_name, date_of_birth, email
Doe, John, 1982/10/08, john.doe@foobar.com
Ann, Mary, 1975/09/11, mary.ann@foobar.com
And you want to send them a happy birthday email on their birth date :
This description is based on that at Adventures in C#: The Bowling Game
Create a program, which, given a valid sequence of rolls for one line of American Ten-Pin Bowling, produces the total score for the game. Here are some things that the program will not do:
Depending on the application, this might or might not be a valid way to define a complete story, but we do it here for purposes of keeping the kata light. I think you’ll see that improvements like those above would go in readily if they were needed for real.
This exercise is based on the Brainfuck langage.
Brainfuck is an esoteric programming language created in 1993 by Urban Müller. It’s a minimalist langage composed of one character instructions while remaining Turing complete.
This kata is largely inspired by the work of Joe Wright in https://code.joejag.com/coding-dojo/christmas-delivery/
Due to huge population growth in the world, Santa Claus is having to change his existing process.
Currently only one Elf can put a present on his Sleigh at a time and Santa wants to be able to be able to use multiple Elves. Specification
In order to receive presents yourself this year, you’ll have to design a system to support his changing process.
Code Cracker
Given an alphabet decryption key like the one below, create a program that can crack any message using the decryption key.
Alphabet
a b c d e f g h i j k l m n o p q r s t u v w x y z
Decryption Key
! ) " ( £ * % & > < @ a b c d e f g h i j k l m n o
You could also create a encryption program that will encrypt any message you give it using the key.
You should implement a simple booking solution in CQRS architecture.
CQRS for Command Query Responsibility Segregation Pattern.
A query returns data and does not alter the state of the object. A command changes the state of an object but does not return any data.
We will split our code in read and write code to really live this pattern.
We want to make a booking solution for one hotel.
This kata was originally made to implement the decorator and composite pattern.
Write a program that can build many cakes with many toppings like : “Cupcake with chocolate and nuts” Or “🧁 with black 🍫 and 🥜 and 🍬”. Be carful the order of topping is very important.
Write a function or method that can show the name of cake.
Write a function that can show the price of cake. The price is composed of base cake price and topping price.
Difficulty: easy
Good for teaching: recursion
Related Katas: KataBreadthFirstSearch
Depth-first search is not just an AI technique it is also the standard way that trees (ubiquitous in computer science) are traversed.
For this (easiest) form of depth-first search, steer towards using the function-call stack, rather than a stack data structure.
Try to avoid implementing a Graph or Maze or Problem class (even as a mocked interface) for your depth-first-searcher to traverse. Instead, ask questions of a “human” user (e.g. standard in/standard out or whatever your language uses). For example, “What are the exits?” and “Where are we?”. This allows exploratory testing, which is fun. Having to build a Graph or Maze by initializing data, or parsing a file, slows down the group and is distant from the main thrust of the kata.
Alistair Cockburn wrote a blog post about this kata, in response to the Seb Rose kata proposition.
Given a letter, print a diamond starting with ‘A’ with the supplied letter at the widest point.
This kata is about making a simple string replacer. It is inspired by Corey Haines Lightning talk about practicing. (aac2009.confreaks.com/06-feb-2009-20-30-lightning-talk-under-your-fingers-corey-haines.html)
Create a method that takes a string and a dictionary, and replaces every key in the dictionary pre and suffixed with a dollar sign, with the corresponding value from the Dictionary.
Tests
input : “”, dict empty, output:""
input : “$temp$”, dict [“temp”, “temporary”], output: “temporary”
input : “$temp$ here comes the name $name$”, dict [“temp”, “temporary”] [“name”, “John Doe”], output : “temporary here comes the name John Doe”
This kata is based on the classic chess rules. You must put eight chess queens on an 8×8 chessboard such that none of them is able to capture any other using the standard chess queen’s moves.
Tips: you could have only one queen by row and column.
Use multiple TDD loops to build a programm they find all solutions.
In this part we whant to find only one solution.
Largely inspired by : https://docs.google.com/document/d/1Ls6pTmhY_LV8LwFiboUXoFXenXZl0qVZWPZ8J4uoqpI
We manufacture a point of sale capable of issuing cash register tickets.
This Kata was developed to show how overspecification of assertions harms maintainability of tests. A blog post with a possible solution can be found here: https://dev.to/webpapaya/writing-better-test-assertions-lml
You’re building an employee management system of a local grocery store. The shop-owner wants to open the shop on Sunday and due to legal restrictions employees younger than 18 years are not allowed to work Sundays. The employee asks for a reporting feature so she can schedule work shifts. All employees are already stored somewhere and have the following properties:
This Kata was posted here by someone anonymously. Michael Feathers and EmilyBache performed it at agile2008 when competing in “Programming with the stars” in python, in 4 minutes.
Difficulty: Easy Good for teaching: TDD , BabySteps
Imagine the scene. You are eleven years old, and in the five minutes before the end of the lesson, your Maths teacher decides he should make his class more “fun” by introducing a “game”. He explains that he is going to point at each pupil in turn and ask them to say the next number in sequence, starting from one. The “fun” part is that if the number is divisible by three, you instead say “Fizz” and if it is divisible by five you say “Buzz”. So now your maths teacher is pointing at all of your classmates in turn, and they happily shout “one!”, “two!”, “Fizz!”, “four!”, “Buzz!”… until he very deliberately points at you, fixing you with a steely gaze… time stands still, your mouth dries up, your palms become sweatier and sweatier until you finally manage to croak “Fizz!”. Doom is avoided, and the pointing finger moves on.
You should implement a function String compute(String) which implements the following rules.
1 => 1
2 => 2
3 => FooFoo (divisible by 3, contains 3)
4 => 4
5 => BarBar (divisible by 5, contains 5)
6 => Foo (divisible by 3)
7 => QixQix (divisible by 7, contains 7)
8 => 8
9 => Foo
10 => Bar
13 => Foo
15 => FooBarBar (divisible by 3, divisible by 5, contains 5)
21 => FooQix
33 => FooFooFoo (divisible by 3, contains two 3)
51 => FooBar
53 => BarFoo
We have a new business request: we must keep a trace of 0 in numbers, each 0 must be replaced by char “*”.
This was presented as a PreparedKata at XP2005, by Emmanuel Gaillot.
Difficulty - medium
Similar Katas - KataMinesweeper , KataReversi
This Kata is about calculating the next generation of Conway’s game of life, given any starting position. See http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life for background.
You start with a two dimensional grid of cells, where each cell is either alive or dead. In this version of the problem, the grid is finite, and no life can exist off the edges. When calcuating the next generation of the grid, follow these rules:
## About this Kata
A refactoring Kata, bases on existing code.
Hi and welcome to team Gilded Rose. As you know, we are a small inn with a prime location in a prominent city ran by a friendly innkeeper named Allison. We also buy and sell only the finest goods. Unfortunately, our goods are constantly degrading in quality as they approach their sell by date. We have a system in place that updates our inventory for us. It was developed by a no-nonsense type named Leeroy, who has moved on to new adventures. Your task is to add the new feature to our system so that we can begin selling a new category of items. First an introduction to our system:
http://en.wikipedia.org/wiki/Greed_%28dice_game%29
Greed (Dice Game)
Write a class Greed with a score() method that accepts an array of die values (up to 6). Scoring rules are as follows:
Note that the scorer should work for any number of dice up to 6.
This is the famous " [Hello World] " program. Hello World is perhaps the first Kata – it predates even the term “kata”. But people have been doing Hello World as effectively a kata for over thirty years. The seminal book [The C Programming Language] has created the tradition of making it the first program in any new language, environment, or methodology. So it follows that the first kata should be Hello World.
In this Kata, your a programmer at ABC Corp and you’re making a new web app from scratch. After the head architect started working on this, it’s now up to you to make sure these tasks are completed:
However, you’re not the only programmer (team) adressing this web app, so the LDAP is written by another team and what you have right now is this interface:
This kata seems simple at first a glance, but wait to explore it before said it’s an easy one.
ABEAS Corp is a little company with only one plane. ABEAS Corp’s customers ask for this plane to help them sometimes. They send rent request with start time, travel duration, and a price they will paid.
You could help ABEAS Corp by finding the best request combination to maximize gain.
The purpose is to build a cellular automaton : Langton Ant
Squares on a plane are colored variously either black or white. We arbitrarily identify one square as the “ant”. The ant can travel in any of the four cardinal directions at each step it takes. The “ant” moves according to the rules below:
Langton’s ant can also be described as a cellular automaton, where the grid is colored black or white and the “ant” square has one of eight different colors assigned to encode the combination of black/white state and the current direction of motion of the ant.
This short and simple Kata should be performed in pairs using Test Driven Development (TDD).
Prior to 1582, the Julian Calendar was in wide use and defined leap years as every year divisible by 4. However, it was found in the late 16th century that the calendar year had drifted from the solar year by approximately 10 days. The Gregorian Calendar was defined in order to thin out the number of leap years and to more closely align the calendar year with the solar year. It was adopted in Papal countries on October 15, 1582, skipping 10 days from the Julian Calendar date. Protestant countries adopted the Gregorian Calendar after some time.
Manhattan distance is the distance between two points in a grid (like the grid-like street geography of the New York borough of Manhattan) calculated by only taking a vertical and/or horizontal path.
Write a function int manhattanDistance(Point, Point) that returns the Manhattan Distance between the two points.
manhattanDistance( Point(1, 1), Point(1, 1) ) should returns 0manhattanDistance( Point(5, 4), Point(3, 2) ) should returns 4manhattanDistance( Point(1, 1), Point(0, 3) ) should returns 3Build a text generator based on a Markov Chain.
Faire un programme qui prend deux paramètres : un entier (pour demander un nombre de mots) et un texte (qui sert de base d’apprentissage); et qui génère un autre texte (de la longueur du paramètre.
Alternative : Il faut faire un logiciel en deux partie.
Une première partie qui analyse un texte pour en extraire des statistiques. Chaque mot doit avoir la liste des mots possible suivant avec un pourcentage d’apparition.
You’re part of the team that make Mars Rover. Develop the simulator program that takes commands and a map, they translate the commands and show the result position and direction of the Rover.
Your program takes in input
x, y) and the direction (N, S, E, W) it is facingWhen the rover encounters an obstacle, it does nothing.
Difficulty: medium
Have you ever played Mastermind ? This game where one player, a codemaker, has to choose a secret combination of colored pegs and then make it guess to someone else, a codebreaker. The codemaker is answering to each guess attempt of the codebreaker by indicating only the number of well placed colors and the number of correct but misplaced colors.
If you remember playing the game, being the one who guesses is very brain demanding, whereas the other player get bored rapidly.
This kata was originaly write to implement the visitor pattern
Write a program they build and Abstract Syntax Tree of a RPN mathematical expression from a string like:
(+)
Mathematical.parse("3 6 +") be produce / \
/ \
3 6
and
(+)
/ \
/ \
3 (×)
Mathematical.parse("3 6 -6 * +") be produce / \
/ \
6 -6
For the first test You must chose objects or structs you will have in your AST.
Kata originated here: acm.uva.es/p/v101/10189.html
Difficulty: Easy
Have you ever played Minesweeper? It’s a cute little game which comes within a certain Operating System whose name we can’t really remember. Well, the goal of the game is to find all the mines within an MxN field. To help you, the game shows a number in a square which tells you how many mines there are adjacent to that square. For instance, take the following 4x4 field with 2 mines (which are represented by an * character):
The Martin Fowler’s book “Refactoring, Improving the Design of Existing Code” start with a (very) simple example of refactoring of code.
Actualy the statement method prints out a simple text output of a rental statement
Rental Record for martin
Ran 3.5
Trois Couleurs: Bleu 2
Amount owed is 5.5
You earned 2 frequent renter points
We want to write an HTML version of the statement method :
<h1>Rental Record for <em>martin</em></h1>
<table>
<tr><td>Ran</td><td>3.5</td></tr>
<tr><td>Trois Couleurs: Bleu</td><td>2</td></tr>
</table>
<p>Amount owed is <em>5.5</em></p>
<p>You earned <em>2</em> frequent renter points</p>
First refactor the program to make it easy to add the feature, then add the feature.
A color is composed by an amount of red, green and blue.
In computer science, a way to represent a color is to compose between these three amount of colors.
Each amount of color have a presence from 0 (the color is absent) to 255 (full presence of color).
But, because some developers love hexadecimal, they decided to use numbers between 0 and F. So, 00 means 0 in decimal and FF means 255 in decimal.
Basic informations about Nim Game : https://en.wikipedia.org/wiki/Nim
Difficulty: Easy
Build a Nim Game where you can play with two players.
Start with 10 sticks, then you can add some game setup difficulty with variable started stick and players name, you can build an beautiful GUI too or just play in terminal.
https://gist.github.com/arikfr/11362378#file-gistfile1-txt Goal: write a program that displays LCD style numbers.
Write a program that given a number (with arbitrary number of digits), converts it into LCD style numbers using the following format:
_ _ _ _ _ _ _
| _| _||_||_ |_ ||_||_|
||_ _| | _||_| ||_| _|
(each digit is 3 lines high)
Note: Please do NOT read the second part before completing the first. Part of the purpose of this kata is to make you practice refactoring and adapting to changing requirements.
It occurs now and then in real life that people want to write about money, especially about a certain amount of money. If it comes to cheques or contracts for example some nations have laws that state that you should write out the amount in words additionally to the amount in numbers to avoid fraud and mistakes. So if you want to transfer 745 $ to someone via cheque you have to fill out two fields:
Write a contacts program they use an ORM to read and write Persons from an sqlite3 database
Person has 3 attributes :
we want to have one test DB named tests.db and one production db file set by environment variable DB_URL
In production Data base we have all this contacts :
add a version schema in your code and database
Difficulty: easy
Good for teaching: does doing a SDUF (Small Design Up Front) taking monsters into account make a big difference in design and (initial and/or ongoing) velocity?
Related Katas: GameOfLife - the board design was taken from there. We simulate a game you play continuously with turns.
First performed January 6 during a devnology.nl event at Marktplaats.nl. Kicked off by Marc Evers and Rob Westgeest, initial steps brainstormed and facilitated by Willem van den Ende, programmed by a majority of the participants :)
Pagination can be found in many websites on the Internet. Most of the time you can see the current page and going to the previous and the next page. Sometimes you can go to the first and the last page. Some information like total pages number can be shown.
Aware of the need for all these contraints, we found a lot of pagination example like:
Simple pagination:
< 42 >
Advanced pagination:
This kata is blatantly stolen from acm.uva.es/p/v103/10315.html It is a subset of KataTexasHoldEm , which is a very large Kata.
Your job is to compare several pairs of poker hands and to indicate which, if either, has a higher rank.
A poker deck contains 52 cards - each card has a suit which is one of clubs, diamonds, hearts, or spades (denoted C, D, H, and S in the input data). Each card also has a value which is one of 2, 3, 4, 5, 6, 7, 8, 9, 10, jack, queen, king, ace (denoted 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K, A). For scoring purposes, the suits are unordered while the values are ordered as given above, with 2 being the lowest and ace the highest value.
If you want to try this Kata for yourself or at your dojo meeting, read the problem description and see if the Kata appeals to you. The rest is commentary and helpful clues for if you get stuck solving it. I would recommend trying the Kata for yourself before reading too much of it.
Once upon a time there was a series of 5 books about a very English hero called Harry. (At least when this Kata was invented, there were only 5. Since then they have multiplied) Children all over the world thought he was fantastic, and, of course, so did the publisher. So in a gesture of immense generosity to mankind, (and to increase sales) they set up the following pricing model to take advantage of Harry’s magical powers.
I teach web applications programming to undergraduates. I usually explain the stuff, point them to the book, and ask them to produce a finished web application as part of their examination. On some people it works and they make great apps. On other people it doesn’t. This year I’m trying a new approach, to teach with katas. I started with this small kata.
There are two main differences with respect to the usual TDD katas. The way I describe it, there is no TDD. My students can’t do that yet, and the main purpose is to teach about the web. So I replace the feedback from the tests with the feedback of reloading the page on the web. I’m still doing BabySteps though.
Range has a lot of nifty issues.
[2,6) contains {2,4}
[2,6) doesn’t contain {-1,1,6,10}
[2,6) allPoints = {2,3,4,5}
[2,5) doesn’t contain [7,10)
[2,5) doesn’t contain [3,10)
[3,5) doesn’t contain [2,10)
[2,10) contains [3,5]
[3,5] contains [3,5)
[2,6) endPoints = {2,5}
[2,6] endPoints = {2,6}
(2,6) endPoints = {3,5}
(2,6] endPoints = {3,6}
[2,5) doesn’t overlap with [7,10)
[2,10) overlaps with [3,5)
[3,5) overlaps with [3,5)
This Kata was introduced to me by LaurentBossavit – EmilyBache
Difficulty: Medium
Reversi is a board game for two players. More information can be found on Wikipedia en.wikipedia.org/wiki/Reversi . This Kata is to write a program that takes a current board position together with information about whose turn it is, and returns a list of the legal moves for that player. A move is only legal if it results in at least one of the opponent’s counters being flipped.
CodersDojoSweden , running in Linköping, was looking for a new Kata which was sufficiently simple to get beginners up and running. ThomasNilsson suggested a calculator using Roman numerals.
“As a Roman Bookkeeper I want to add Roman numbers because doing it manually is too tedious.” Given the Roman numerals, (IVXLCDM which mean one, five, ten, fifty, hundred, fivehundred and a thousand respectively), create two numbers and add them. As we are in Ancient Rome there is no such thing as decimals or int, we need to do this with the strings. An example would be “XIV” + “LX” = “LXXIV”
I wasn’t there, but I believe this Kata was performed at XP2001 by Kent Beck. Here is [a video of Karl Scotland doing this Kata in Excel at agile 2008] Here is [a video of JonJagger doing this Kata in Ruby using CyberDojo]
Difficulty - Easy.
The Romans were a clever bunch. They conquered most of Europe and ruled it for hundreds of years. They invented concrete and straight roads and even bikinis [1]. One thing they never discovered though was the number zero. This made writing and dating extensive histories of their exploits slightly more challenging, but the system of numbers they came up with is still in use today. For example the BBC uses Roman numerals to date their programmes.
An RPN calculator computes expressions written in Reverse Polish Notation.
An RPN expression or postfix expression is one of the following :
X, in wich case the value of the expression is that of X,E1 E2 OP where E1 and E2 are RPN expressions and OP is an arithmetic operation.Samples :
20 5 / => 20/5 = 4
4 2 + 3 - => (4+2)-3 = 3
3 5 8 * 7 + * => ((5*8)+7)*3 = 141
Add the SQRT operation :
RSA (Rivest–Shamir–Adleman) is a public-key cryptosystem that is widely used for secure data transmission. It is also one of the oldest.
In this kata we will encrypt and decrypt a message with RSA algorythm.
p and q such that (2^24 + 1) < p × q < 2^32N = p × qn = (p − 1) × (q − 1)c a coprime number with n such that 1 < c < n(N, c) is the public key
A very large subject to learn the exemple mapping workshop.
Idea is to build a very light social network.
This classic kata guides you step by step through the implementation of a calculator that receives a String as input.
It is a good exercise on refactoring and incremental implementation. It is also a good candidate for practising TDD.
Create a function add that takes a String and returns a String:
String add(String number)
- The method can take 0, 1 or 2 numbers separated by comma, and returns their sum.
- An empty string will return “0”.
- Example of inputs:
"","1","1.1,2.2".
Allow the add method to handle an unknow number of arguments.
Inspired from Thien Que Nguyen and Pascal Van Cauwenberghe
This kata whan to experience TDD and concurrent programming.
Build a Cell class or struct they follow this rules :
A Cell can answer 1 question :
This Kata is about implementing a simple tennis game. I came up with it while thinking about Wii tennis, where they have simplified tennis, so each set is one game.
The scoring system is rather simple:
Alternate description of the rules per Wikipedia (http://en.wikipedia.org/wiki/Tennis#Scoring ):
by Matthew D Moss, blatantly stolen from www.rubyquiz.com/quiz24.html
If you want to try this Kata for yourself or at your dojo meeting, read the problem description and see if the Kata appeals to you. The rest is commentary and helpful clues for if you get stuck solving it. I would recommend trying the Kata for yourself before reading too much of it. For an easier kata, try KataPokerHands first.
Difficulty: hard
You work for a cable network; specifically, you are the resident hacker for a Texas Hold’Em Championship show.
Like many game kata, it’s a good introduction to double loop TDD or BDD.
The rules of the tic tac toe game are the following:
Given this game board
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
| 4 | 5 | 6 |
+---+---+---+
| 7 | 8 | 9 |
+---+---+---+
And it's the turn of player X
When it play on cell 5
Then the board is now
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
| 4 | X | 6 |
+---+---+---+
| 7 | 8 | 9 |
+---+---+---+
And it's not the end of game.
In this Kata you will be implementing a rudimentary two-player trading card game. The rules are loosely based on Blizzard Hearthstone ( http://us.battle.net/hearthstone/en/ ) which itself is an already much simpler and straight-forward game compared to other TCGs like Magic: The Gathering ( http://www.wizards.com/magic/ ).
When approached iteratively with TDD you can take different starting points, like the player state or the game loop. It is your own choice whether you implement the game for human or computer players - or both. Game visualization can be anything between System.out and a GUI. You can also increase the difficulty by adding more rules, like Healing cards, Damage independent from Mana cost or introducing individual Deck building. You will find some examples of Advanced Variations from the Kata’s author at https://github.com/bkimminich/kata-tcg . Even without extra rules the toughest part of this Kata might be coming up with actually smart CPU player decision-making algorithms.
Kata for legacy code hands-on session. The objective is to test and refactor the legacy TripService class.
The end result should be well-crafted code that express the domain.
You can watch the video with my solution. Although quite long, I explain my whole thought process while writting tests, how I break dependencies, the reasons for refactoring and re-desining the code (tests and production code), and why certain steps are important. I also cover how often I commit and why I do it.
Given a Wallet containing Stocks, build a function that compute the value of wallet in a currency.
The Stocks have a quantity and a StockType. The StockType can be for example petroleum, Euros, bitcoins and Dollars.
To value the portfilio in a Currency you can use external api to provide rate exchanges (some are provided below).
Value value = Wallet(Stock(5, PETROLEUM)).value(EUR, rateProvider)
With rateProvider an implementation of this interface :
This kata is from Robert Martin and his blog includes a solution in Java [1] .
You write a class called Wrapper, that has a single static function named wrap that takes two arguments, a string, and a column number. The function returns the string, but with line breaks inserted at just the right places to make sure that no line is longer than the column number. You try to break lines at word boundaries.
This problem is based on Ruby Quiz #19 ( http://rubyquiz.com/quiz19.html ). The kata takes about 20 minutes with practice and 2 hours in a dojo setting.
The game of yahtzee is a simple dice game. Each round, each player rolls five six sided dice. The player may choose to reroll some or all of the dice up to three times (including the original roll). The player then places the roll at a category, such as ones, twos, sixes, pair, two pairs etc. If the roll is compatible with the score, the player gets a score for this roll according to the rules. If the roll is not compatible, the player gets a score of zero for this roll.