cyber-dojo

create a new practice

choose your exercise

100 doors

12 Days of Xmas

ABC Problem

Align Columns

Anagrams

Array Shuffle

Balanced Parentheses

Best Shuffle

Bowling Game

Calc Stats

Closest To Zero

Combined Number

Count Coins

Diff Selector

Diversion

Eight Queens

Filename Range

Fisher-Yates Shuffle

Five Weekends

Fizz Buzz

Fizz Buzz Plus

Friday 13th

Game of Life

Gray Code

Group Neighbours

Haiku Review

Harry Potter

ISBN

Knight's Tour

LCD Digits

Leap Years

Levenshtein Distance

Longest Common Prefix

Magic Square

Mars Rover

Mine Field

Mine Sweeper

Monty Hall

Number Chains

Number Names

Phone Numbers

Poker Hands

Prime Factors

Print Diamond

Recently Used List

Remove Duplicates

Reordering

Reverse Roman

Reversi

Roman Numerals

Saddle Points

Tennis

Tiny Maze

Unsplice

Vending Machine

Wonderland Number

Word Wrap

Yatzy

Yatzy Cutdown

Zeckendorf Number

Write the smallest program that outputs the lyrics of the Xmas carol The Twelve Days of Xmas.
You must reproduce the words in the correct order, but case, format, and punctuation are left to your discretion.

The lyrics are as follows:

On the first day of Christmas
My true love gave to me:
A partridge in a pear tree.

On the second day of Christmas
My true love gave to me:
Two turtle doves and
A partridge in a pear tree.

On the third day of Christmas
My true love gave to me:
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the fourth day of Christmas
My true love gave to me:
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the fifth day of Christmas
My true love gave to me:
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the sixth day of Christmas,
My true love gave to me:
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the seventh day of Christmas,
My true love gave to me:
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the eight day of Christmas,
My true love gave to me:
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the ninth day of Christmas,
My true love gave to me:
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the tenth day of Christmas,
My true love gave to me:
Ten lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the eleventh day of Christmas,
My true love gave to me:
Eleven pipers piping
Ten lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

On the twelfth day of Christmas,
My true love gave to me:
Twelve drummers drumming
Eleven pipers piping
Ten lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree.

[Source https://rosettacode.org]

You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:

(B O)
 (X K)
 (D Q)
 (C P)
 (N A)
 (G T)
 (R E)
 (T G)
 (Q D)
 (F S)
 (J W)
 (H U)
 (V I)
 (A N)
 (O B)
 (E R)
 (F S)
 (L Y)
 (P C)
 (Z M)

Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
   1. Once a letter on a block is used that block cannot be used again
   2. The function should be case-insensitive
   3. Show the output on this page for the following 7 words in the following example

Example

>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True

[Source https://rosettacode.org/wiki/ABC_Problem]

Given a text file of many lines, where fields within a line are delineated by a single 'dollar' character, write a program that aligns each column of fields by ensuring that words in each column are separated by at least one space.

For Example:

Given$a$text$file$of$many$lines,$where$fields$within$a$line$
are$delineated$by$a$single$'dollar'$character,$write$a$program
that$aligns$each$column$of$fields$by$ensuring$that$words$in$each$
column$are$separated$by$at$least$one$space.

Notes:
- The example input texts lines may, or may not, have trailing dollar characters.
- Lines may, or may not, contain the same number of fields.
- All columns should share the same alignment.
- Consecutive space characters produced adjacent to the end of lines are insignificant for the purposes of the task.
- Assume output text will be viewed in a mono-spaced font on a plain text editor or basic terminal.
- The minimum space between columns should be computed from the text and not hard-coded.

[Source https://rosettacode.org]

Write a program to score a game of Ten-Pin Bowling.

Input: string (described below) representing a bowling game
Output: integer score

The scoring rules:

Each game, or "line" of bowling, includes ten turns, or "frames" for the bowler.

In each frame, the bowler gets up to two tries to knock down all ten pins.

If the first ball in a frame knocks down all ten pins, this is called a "strike". The frame is over. The score for the frame is ten plus the total of the pins knocked down in the next two balls.

If the second ball in a frame knocks down all ten pins,  this is called a "spare". The frame is over. The score for the frame is ten plus the number of pins knocked down in the next ball.

If, after both balls, there is still at least one of the ten pins standing the score for that frame is simply the total number of pins knocked down in those two balls.

If you get a spare in the last (10th) frame you get one  more bonus ball.

If you get a strike in the last (10th)  frame you get two more bonus balls.

These bonus throws are taken as part of the same turn.  If a bonus ball knocks down all the pins, the process  does not repeat. The bonus balls are only used to calculate the score of the final frame.

The game score is the total of all frame scores.

Examples:

X indicates a strike
/ indicates a spare
- indicates a miss
| indicates a frame boundary
The characters after the || indicate bonus balls

X|X|X|X|X|X|X|X|X|X||XX
Ten strikes on the first ball of all ten frames.
Two bonus balls, both strikes.
Score for each frame == 10 + score for next two
balls == 10 + 10 + 10 == 30
Total score == 10 frames x 30 == 300

9-|9-|9-|9-|9-|9-|9-|9-|9-|9-||
Nine pins hit on the first ball of all ten frames.
Second ball of each frame misses last remaining pin.
No bonus balls.
Score for each frame == 9
Total score == 10 frames x 9 == 90

5/|5/|5/|5/|5/|5/|5/|5/|5/|5/||5
Five pins on the first ball of all ten frames.
Second ball of each frame hits all five remaining
pins, a spare.
One bonus ball, hits five pins.
Score for each frame == 10 + score for next one
ball == 10 + 5 == 15
Total score == 10 frames x 15 == 150

X|7/|9-|X|-8|8/|-6|X|X|X||81
Total score == 167

When reviewing a traffic-light, cyber-dojo uses a
function to select one of the files.

Your task is to write this selection function.

The function has two parameters:
  o) previous-filename; a string
     the filename of the previously viewed traffic-light
  o) diffs; an array
     diff data, one per file.

The function returns the index of the selected diff
(in diffs) according to the following cascading rules:

Rule 1:
If any diff is for a changed, previous-filename,
select it.

Rule 2:
If any diff is for a changed, non .txt file,
select one with the (possibly equal) largest change-count.

Rule 3:
If any diff is for an identically renamed, non .txt file,
select one with the (possibly equal) largest same-count.

Rule 4:
If any diff is for an empty, created, non .txt file,
select one.

Rule 5:
If any diff is for an empty, deleted, non .txt file,
select one.

Rule 6:
If any diff is for a changed, .txt file,
select one with the (possibly equal) largest change-count.

Rule 7:
If any diff is for an identically renamed, .txt file,
select one with the (possibly equal) largest same-count.

Rule 8:
If any diff is for the (unchanged) previous-filename,
select it.

Rule 9:
Select the diff whose filename is 'cyber-dojo.sh'

Note:
o) 'changed' means 'change-count' is greater than zero.

o) 'change-count' means the sum of the
   added line-count and the deleted line-count.

o) a diff for 'cyber-dojo.sh' will always exist.

The diff data for each file is in JSON format.
For example:
  {
    "type": "changed",
    "old_filename": "hiker.h",
    "new_filename": "hiker.h",
    "line_counts: {
      "added":4, "deleted":3, "same":27
    }
  }

o) "type" is a string

One of ["deleted","created","renamed","unchanged","changed"]

o) "old_filename" is a string
o) "new_filename" is a string

if "type" is "deleted"
     "old_filename" will be the filename
     "new_filename" will be null
   if type is "created"
     "old_filename" will be null
     "new_filename" will be the filename
   if type is "renamed"
      "old_filename" will be the old filename
      "new_filename" will be the new (different) filename
   if "type" is "unchanged"
      "old_filename" will be the filename
      "new_filename" will be the (same) filename
       (neither the file's content nor its name has changed)
   if "type" is "changed"
      "old_filename" will be the filename
      "new_filename" will be the (same) filename
      (the file's content has changed, but not its name)

o) "line_counts"

if "type" is "deleted"
     "added" is zero
     "same" is zero
     "deleted" was the number of lines in the deleted file
       (zero if the deleted file was empty)

if "type" is "created"
     "deleted" is zero
     "same" is zero
     "added" is the number of lines in the created file
       (zero if the created file was empty)

if "type" is "renamed"
     "added" is the number of added lines
     "deleted" is the number of deleted lines
     "same" is the number of unchanged lines
       (for an identical rename, "added" and "deleted"
        will both be zero)

if "type" is "unchanged"
     "added" is zero
     "deleted" is zero
     "same" is the number of lines in the unchanged file

if "type" is "changed"
     "added" is the number of added lines
     "deleted" is the number of deleted lines
     "same" is the number of unchanged lines.
       ("added" or "deleted" or both will be non-zero)

When you rename a file, cyber-dojo tries to be helpful and selects
only the part of the filename it thinks you will want to change.

Your task is to write a function that is given a string filename
and which returns a pair of integers specifying the start and
end indexes (into the filename) of the selected range.

First, it assumes you will want to keep the extension.
Eg

"hiker.cpp" ==> "hiker" is selected.
   "diamond.h" ==> "diamond" is selected.

Second, if the filename includes the word "tests", "test", "spec", or
"step" (case insensitive) it assumes you will want to keep those too,
together with any 'separator' characters (dot, underscore, hyphen).
Eg

"HikerTest.js"  ==> "Hiker" is selected.
   "Diamond_Spec.feature" => "Diamond" is selected.
   "fizz.buzz-tests.js" => "fizz.buzz" is selected.

Third, if the filename is in a dir/
it assumes you will also want to keep that.
Eg

"test/FizzBuzz_test.exs" => "FizzBuzz" is selected.
   "src/test/Roman.spec.re" => "Roman" is selected.

Here is a JSON data structure you can use in your tests.

{
  "src/Hiker_spec.re": [4,9],
  "test/hiker_test.exs": [5,10],
  "wibble/test/hiker_spec.rb": [12,17],
  "hiker_steps.rb": [0,5],
  "hiker_spec.rb": [0,5],
  "test_hiker.rb": [5,10],
  "test_hiker.py": [5,10],
  "test_hiker.sh": [5,10],
  "tests_hiker.sh": [6,11],
  "test_hiker.coffee": [5,10],
  "hiker_spec.coffee": [0,5],
  "hikerTest.chpl": [0,5],
  "hiker.tests.c": [0,5],
  "hiker_tests.c": [0,5],
  "hiker_test.c": [0,5],
  "hiker_Test.c": [0,5],
  "HikerTests.cpp": [0,5],
  "hikerTests.cpp": [0,5],
  "HikerTest.cs": [0,5],
  "HikerTest.java": [0,5],
  "DiamondTest.kt": [0,7],
  "HikerTest.php": [0,5],
  "hikerTest.js": [0,5],
  "hiker-test.js": [0,5],
  "hiker-spec.js": [0,5],
  "hiker.test.js": [0,5],
  "hiker.tests.ts": [0,5],
  "hiker_tests.erl": [0,5],
  "hiker_test.clj": [0,5],
  "fizzBuzz_test.d": [0,8],
  "hiker_test.go": [0,5],
  "hiker.tests.R": [0,5],
  "hikertests.swift": [0,5],
  "HikerSpec.groovy": [0,5],
  "hikerSpec.feature": [0,5],
  "hiker.feature": [0,5],
  "hiker.fun": [0,5],
  "hiker.t": [0,5],
  "hiker.plt": [0,5],
  "hiker": [0,5],
};

When doing a cyber-dojo group exercise, you can review
the files from any active avatar in the group!

The [<] button moves you to the previous avatar.
The [>] button moves you to the next avatar.

The previous/next ordering is based on the
avatar's indexes, which have a range of [0..64)
 0==alligator
 1==antelope
 ...
62==wolf
63==zebra

Your task is to implement a function called groupNeighbours()
which is passed two arguments:
  o) the current avatar's id (String)
  o) data for all the avatars (Hash)

For example:
  groupNeighbours("Q55b8b", {
    "15": { id:"EEJSkR", events:[0,1,2]     }, // 15==fox
     "3": { id:"w34rd5", events:[0]         }, //  2==bear
    "23": { id:"Q55b8b", events:[0,1,2,3]   }, // 23==jellyfish
    "44": { id:"REf1t7", events:[0,1,2,3,4] }, // 44==rhino
  })

The function must return three pieces of data:
  o) the id of the previous avatar
  o) the avatar-index matching the id (1st arg)
  o) the id of the next avatar

0) The keys of the Hash are Strings not Integers.

1) The Hash always contains an entry whose id matches the 1st arg.

2) If there is no previous avatar, return an empty string.
   For example
     groupNeighbours("2z4449", {
       "36": { id:"2z4449", events:[0,1,2,3]     }, // 36==parrot
       "49": { id:"s86eR4", events:[0,1,2,3,4,5] }, // 49==snake
     })
   returns
       [ "", 36, "s86eR4" ]

3) If there is no next avatar, return an empty string.
   For example
     groupNeighbours("s86eR4", {
       "36": { id:"2z4449", events:[0,1,2,3]     }, // 36==parrot
       "49": { id:"s86eR4", events:[0,1,2,3,4,5] }, // 49==snake
     })
   returns
     [ "2z4449", 49, "" ]

4) Ignore inactive avatars - whose events array has less than 2 entries.
   For example:
     groupNeighbours("Q55b8b", {
       "15": { id:"EEJSkR", events:[0,1,2]     }, // 15==fox
        "3": { id:"w34rd5", events:[0]         }, //  3==bear (inactive)
       "23": { id:"Q55b8b", events:[0,1,2,3]   }, // 23==jellyfish
       "44": { id:"REf1t7", events:[0,1,2,3,4] }, // 44==rhino
     })
   returns
     [ "EEJSkR", 23, "REf1t7" ]
   not
     [ "w34rd5", 23, "REf1t7" ]

5) Return the avatar-index as an integer.
   For example
     [ "EEJSkR", 23, "REf1t7" ]
   not
     [ "EEJSkR", "23", "REf1t7" ]

Haiku is an ancient form of Japanese poetry. A haiku is a three-line poem with seventeen syllables, where the first line must contain five syllables, the second line must contain seven syllables, and the third line must contain five syllables. The lines do not have to rhyme. Here is an example, where slashes separate the lines:

Computer programs/The bugs try to eat my code/I must not let them.

You must write a program that will review a haiku and check that each line contains the correct number of syllables.

Input

The input contains one or more lines, each of which contains a single haiku. A haiku will contain at least three words, and words will be separated by either a single space or a slash ('/'). Slashes also separate the three lines of a haiku, so each haiku will contain exactly two slashes. (The three lines of the haiku will be contained within one physical line of the file.)

A haiku will contain only lowercase letters ('a'-'z'), forward slashes ('/'), and spaces, and will be no more than 200 characters long (not counting the end-of-line characters).

Each haiku is guaranteed to contain three lines, and each line will contain at least one word. Your job is to determine whether each line has the correct number of syllables (5/7/5). For the purposes of this problem, every contiguous sequence of one or more vowels counts as one syllable, where the vowels are a, e, i, o, u, and y. Every word will contain at least one syllable.

(Note that this method of counting syllables does not always agree with English conventions. In the second example below, your program must consider the word 'code' to have two syllables because the 'o' and the 'e' are not consecutive. However, in English the 'e' is silent and so 'code' actually has only one syllable.)

Output

For each haiku, output a comma-separated single line that contains the number of syllables in each haiku, together with the letter Y if it is a haiku, or N if it is not a haiku (see below).

Sample Input

happy purple frog/eating bugs in the marshes/get indigestion
computer programs/the bugs try to eat my code/i will not let them

Sample Output

5,7,5,Yes
5,8,5,No

[Source: https://uva.onlinejudge.org/]

To try and encourage more sales of the 5 different Harry Potter books they sell, a bookshop has decided to offer discounts of multiple-book purchases.

One copy of any of the five books costs 8 EUR.

If, however, you buy two different books, you get a 5% discount on those two books.

If you buy 3 different books, you get a 10% discount.

If you buy 4 different books, you get a 20% discount.

If you go the whole hog, and buy all 5, you get a huge 25% discount.

Note that if you buy, say, four books, of which 3 are different titles, you get a 10% discount on the 3 that form part of a set, but the fourth book still costs 8 EUR.

Your mission is to write a piece of code to calculate the price of any conceivable shopping basket (containing only Harry Potter books), giving as big a discount as possible.

For example, how much does this basket of books cost?

2 copies of the first book
2 copies of the second book
2 copies of the third book
1 copy of the fourth book
1 copy of the fifth book

One way of group these 8 books is:
 1 group of 5 --> 25% discount (1st,2nd,3rd,4th,5th)
+1 group of 3 --> 10% discount (1st,2nd,3rd)
This would give a total of
 5 books at a 25% discount
+3 books at a 10% discount
Giving
 5 x (8 - 2.00) == 5 x 6.00 == 30.00
+3 x (8 - 0.80) == 3 x 7.20 == 21.60
For a total of 51.60

However, a different way to group these 8 books is:
 1 group of 4 books --> 20% discount  (1st,2nd,3rd,4th)
+1 group of 4 books --> 20% discount  (1st,2nd,3rd,5th)
This would give a total of
 4 books at a 20% discount
+4 books at a 20% discount
Giving
 4 x (8-1.60) == 4 x 6.40 == 25.60
+4 x (8-1.60) == 4 x 6.40 == 25.60
For a total of 51.20

And 51.20 is the price with the biggest discount.

ISBN - International Standard Book Number
-----------------------------------------
There are two ISBN standards: ISBN-10 and ISBN-13. Support for ISBN-13 is essential, whereas support for ISBN-10 is optional.
Here are some valid examples of each:

ISBN-10:
0471958697
0 471 60695 2
0-470-84525-2
0-321-14653-0

ISBN-13:
9780470059029
978 0 471 48648 0
978-0596809485
978-0-13-149505-0
978-0-262-13472-9

ISBN-10 is made up of 9 digits plus a check digit (which may be 'X') and ISBN-13 is made up of 12 digits plus a check digit. Spaces and hyphens may be included in a code, but are not significant. This means that 9780471486480 is equivalent to 978-0-471-48648-0 and 978 0 471 48648 0.

The check digit for ISBN-10 is calculated by multiplying each digit by its position (i.e., 1 x 1st digit, 2 x 2nd digit, etc.), summing these products together and taking modulo 11 of the result (with 'X' being used if the result is 10).

The check digit for ISBN-13 is calculated by multiplying each digit alternately by 1 or 3 (i.e., 1 x 1st digit, 3 x 2nd digit, 1 x 3rd digit, 3 x 4th digit, etc.), summing these products together, taking modulo 10 of the result and subtracting this value from 10, and then taking the modulo 10 of the result again to produce a single digit.

Basic task:
Create a function that takes a string and returns true if that is a valid ISBN-13 and false otherwise.

Advanced task:
Also return true if the string is a valid ISBN-10.

In information theory and computer science, the Levenshtein distance is a metric for measuring the amount of difference between two sequences (i.e. an edit distance). The Levenshtein distance between two strings is defined as the minimum number of edits needed to transform one string into the other, with the allowable edit operations being insertion, deletion, or substitution of a single character.

Examples:
The Levenshtein distance between "kitten" and "sitting" is 3, since the following three edits change one into the other, and there isn't a way to do it with fewer than three edits:

kitten   sitten    (substitution of 'k' with 's')
              sitten   sittin    (substitution of 'e' with 'i')
              sittin   sitting   (insert 'g' at the end).

The Levenshtein distance between "rosettacode", "raisethysword" is 8.

Note:
The distance between two strings is same as that when both strings are reversed.

Task:
Implements a Levenshtein distance function, or uses a library function.
Show the Levenshtein distance between "kitten" and "sitting".

[Source https://rosettacode.org]

Your task is to create a mine-sweeper style game.
You start at the bottom of an 8x8 grid with 5 lives.
You must move to the top whilst trying to avoid the hidden mines.
You move up/down/left/right each turn.
If you step on a mine:
  o) the mine is revealed and shown as '*'
  o) you lose a life
  o) you do not move into the mine's square
  o) the mine remains explosive
Your current position is shown as 'O'
Squares you have previously stepped on are shown as 'o'
If you reach the top of the grid you win and the game ends.
If you run out of lives you lose and the game ends.
If you attempt to move off the grid:
  o) you stay in the same square
  o) you do not lose a life
A parameter holds the likelihood each square contains a mine:
  o) this parameter ranges from 0 (inclusive) to 1 (exclusive)
  o) a value of 0 means no square contains a mine
  o) a value of 0.5 means a 50% chance any square is mined
  o) reject generated grids with no mine-free path to the top
  o) in other words, each game must be winnable
Your initial starting position at the bottom:
  o) is randomly chosen
  o) does not contain a mine

Suppose you're on a game show and you're given the choice of three doors. Behind one door is a car; behind the others, goats. The car and the goats were placed randomly behind the doors before the show.

The rules of the game show are as follows:

After you have chosen a door, the door remains closed for the time being. The game show host, Monty Hall, who knows what is behind the doors, now has to open one of the two remaining doors, and the door he opens must have a goat behind it. If both remaining doors have goats behind them, he chooses one randomly. After Monty Hall opens a door with a goat, he will ask you to decide whether you want to stay with your first choice or to switch to the last remaining door.

For example:
Imagine that you chose Door 1 and the host opens Door 3, which has a goat. He then asks you "Do you want to switch to Door Number 2?" Is it to your advantage to change your choice?

Note that the player may initially choose any of the three doors (not just Door 1), that the host opens a different door revealing a goat (not necessarily Door 3), and that he gives the player a second choice between the two remaining unopened doors.

Simulate at least a thousand games using three doors for each strategy and show the results in such a way as to make it easy to compare the effects of each strategy.

[Source https://rosettacode.org]

Given a number, we can form a number chain by

1) arranging its digits in descending order
2) arranging its digits in ascending order
3) subtracting the number obtained in (2) from the number obtained (1) to form a new number
4) and repeat these steps unless the new number has already appeared in the chain

Note that 0 is a permitted digit. The number of distinct numbers in the chain is the length of the chain. You are to write a program that reads numbers and outputs the number chain and the length of that chain for each number read.

Input and Output
----------------
The input consists of a positive number, less than 10^9. The output consists of the number chain generated by the input number, followed by its lengths exactly in the format indicated below.

Example-1
---------
Input
123456789

Output
Original number was 123456789
987654321 - 123456789 = 864197532
987654321 - 123456789 = 864197532
Chain length 2

Example-2
---------
Input
1234

Output
Original number was 1234
4321 - 1234 = 3087
8730 - 378 = 8352
8532 - 2358 = 6174
7641 - 1467 = 6174
Chain length 4

Example-3
---------
Input
444

Output
Original number was 444
444 - 444 = 0
0 - 0 = 0
Chain length 2

[Source: https://uva.onlinejudge.org/]

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.

A poker hand consists of 5 cards dealt from the deck. Poker hands are ranked by the following partial order from lowest to highest.

High Card:
Hands which do not fit any higher category are ranked by the value of their highest card. If the highest cards have the same value, the hands are ranked by the next highest, and so on.

Pair:
2 of the 5 cards in the hand have the same value. Hands which both contain a pair are ranked by the value of the cards forming the pair. If these values are the same, the hands are ranked by the values of the cards not forming the pair, in decreasing order.

Two Pairs:
The hand contains 2 different pairs. Hands which both contain 2 pairs are ranked by the value of their highest pair. Hands with the same highest pair are ranked by the value of their other pair. If these values are the same the hands are ranked by the value of the remaining card.

Three of a Kind:
Three of the cards in the hand have the same value. Hands which both contain three of a kind are ranked by the value of the 3 cards.

Straight:
Hand contains 5 cards with consecutive values. Hands which both contain a straight are ranked by their highest card.

Flush:
Hand contains 5 cards of the same suit. Hands which are both flushes are ranked using the rules for High Card.

Full House:
3 cards of the same value, with the remaining 2 cards forming a pair. Ranked by the value of the 3 cards.

Four of a kind:
4 cards with the same value. Ranked by the value of the 4 cards.

Straight flush:
5 cards of the same suit with consecutive values. Ranked by the highest card in the hand.

Your job is to rank pairs of poker hands and to indicate which, if either, has a higher rank.

Examples:
Input: Black: 2H 3D 5S 9C KD White: 2C 3H 4S 8C AH
Output: White wins - high card: Ace

Input: Black: 2H 4S 4C 2D 4H White: 2S 8S AS QS 3S
Output: Black wins - full house

Input: Black: 2H 3D 5S 9C KD White: 2C 3H 4S 8C KH
Output: Black wins - high card: 9

Input: Black: 2H 3D 5S 9C KD White: 2D 3H 5C 9S KH
Output: Tie

Vending Machine Kata
====================

In this exercise you will build the brains of a vending machine.  It will accept money, make change, maintain
inventory, and dispense products.  All the things that you might expect a vending machine to accomplish.

The point of this kata to to provide a larger than trivial exercise that can be used to practice TDD.  A significant
portion of the effort will be in determining what tests should be written and, more importantly, written next.

Features
========

Accept Coins
------------
  
_As a vendor_  
_I want a vending machine that accepts coins_  
_So that I can collect money from the customer_

The vending machine will accept valid coins (nickels, dimes, and quarters) and reject invalid ones (pennies).  When a
valid coin is inserted the amount of the coin will be added to the current amount and the display will be updated.
When there are no coins inserted, the machine displays INSERT COIN.  Rejected coins are placed in the coin return.

NOTE: The temptation here will be to create Coin objects that know their value.  However, this is not how a real
  vending machine works.  Instead, it identifies coins by their weight and size and then assigns a value to what
  was inserted.  You will need to do something similar.  This can be simulated using strings, constants, enums,
  symbols, or something of that nature.

Select Product
--------------

_As a vendor_  
_I want customers to select products_  
_So that I can give them an incentive to put money in the machine_

There are three products: cola for $1.00, chips for $0.50, and candy for $0.65.  When the respective button is pressed
and enough money has been inserted, the product is dispensed and the machine displays THANK YOU.  If the display is
checked again, it will display INSERT COIN and the current amount will be set to $0.00.  If there is not enough money
inserted then the machine displays PRICE and the price of the item and subsequent checks of the display will display
either INSERT COIN or the current amount as appropriate.

Make Change
-----------

_As a vendor_  
_I want customers to receive correct change_  
_So that they will use the vending machine again_

When a product is selected that costs less than the amount of money in the machine, then the remaining amount is placed
in the coin return.

Return Coins
------------

_As a customer_  
_I want to have my money returned_  
_So that I can change my mind about buying stuff from the vending machine_

When the return coins button is pressed, the money the customer has placed in the machine is returned and the display shows
INSERT COIN.

Sold Out
--------

_As a customer_  
_I want to be told when the item I have selected is not available_  
_So that I can select another item_

When the item selected by the customer is out of stock, the machine displays SOLD OUT.  If the display is checked again,
it will display the amount of money remaining in the machine or INSERT COIN if there is no money in the machine.

Exact Change Only
-----------------

_As a customer_  
_I want to be told when exact change is required_  
_So that I can determine if I can buy something with the money I have before inserting it_

When the machine is not able to make change with the money in the machine for any of the items that it sells, it will
display EXACT CHANGE ONLY instead of INSERT COIN.

The game of yatzy is a simple dice game. Each player rolls five six-sided dice. The player places the roll in a category, such as ones, twos, fives, pair, two pairs etc (see below). If the roll is compatible with the category, the player gets a score for the roll according to the rules. If the roll is not compatible with the category, the player scores zero for the roll.

For example, if a player rolls 5,6,5,5,2 and scores the dice in the fives category they would score 15 (three fives).

Your task is to score a GIVEN roll in a GIVEN category.
You do NOT have to program the random dice rolling.
You do NOT have to program re-rolls (as in the real game).
You do NOT play by letting the computer choose the highest scoring category for a given roll.

Yatzy Categories and Scoring Rules
==================================

Chance:
The player scores the sum of all dice, no matter what they read.
For example,
   1,1,3,3,6 placed on "chance" scores 14 (1+1+3+3+6)
   4,5,5,6,1 placed on "chance" scores 21 (4+5+5+6+1)

Yatzy:
If all dice have the same number, the player scores 50 points.
For example,
   1,1,1,1,1 placed on "yatzy" scores 50
   5,5,5,5,5 placed on "yatzy" scores 50
   1,1,1,2,1 placed on "yatzy" scores 0

Ones, Twos, Threes, Fours, Fives, Sixes:
The player scores the sum of the dice that reads one, two, three, four, five or six, respectively.
For example,
   1,1,2,4,4 placed on "fours" scores 8 (4+4)
   2,3,2,5,1 placed on "twos" scores 4  (2+2)
   3,3,3,4,5 placed on "ones" scores 0

Pair:
If exactly two dice have the same value then the player scores the sum of the two highest matching dice.
For example, when placed on "pair"
   3,3,3,4,4 scores 8 (4+4)
   1,1,6,2,6 scores 12 (6+6)
   3,3,3,4,1 scores 0
   3,3,3,3,1 scores 0

Two pairs:
If exactly two dice have the same value and exactly two dice have a different value then the player scores the sum of these four dice.
For example, when placed on "two pairs"
   1,1,2,3,3 scores 8 (1+1+3+3)
   1,1,2,3,4 scores 0
   1,1,2,2,2 scores 0

Three of a kind:
If there are exactly three dice with the same number then the player scores the sum of these dice.
For example, when placed on "three of a kind"
    3,3,3,4,5 scores 9 (3+3+3)
    3,3,4,5,6 scores 0
    3,3,3,3,1 scores 0

Four of a kind:
If there are exactly four dice with the same number then the player scores the sum of these dice.
For example, when placed on "four of a kind"
    2,2,2,2,5 scores 8 (2+2+2+2)
    2,2,2,5,5 scores 0
    2,2,2,2,2 scores 0

Small straight:
When placed on "small straight", if the dice read
  1,2,3,4,5, the player scores 15 (the sum of all the dice).

Large straight:
When placed on "large straight", if the dice read
  2,3,4,5,6, the player scores 20 (the sum of all the dice).

Full house:
If the dice are two of a kind and three of a different kind then the player scores the sum of all five dice.
For example, when placed on "full house"
    1,1,2,2,2 scores 8 (1+1+2+2+2)
    2,2,3,3,4 scores 0
    4,4,4,4,4 scores 0

The game of yatzy is a simple dice game. Each player rolls five six-sided dice. The player places the roll in a category, such as one-pair, two-pair, small-straight etc (see below). If the roll is compatible with the category, the player gets a score for the roll according to the rules. If the roll is not compatible with the category, the player scores zero for the roll.

For example, if a player rolls 5,6,5,6,2 and scores the dice in the two-pairs category they would score 22 (5+5+6+6).

Yatzy Categories and Scoring Rules
==================================

Yatzy:
If all dice have the same number, the player scores 50 points, otherwise 0.
For example,
   1,1,1,1,1 placed on "yatzy" scores 50
   5,5,5,5,5 placed on "yatzy" scores 50
   1,1,1,2,1 placed on "yatzy" scores 0

Small straight:
When placed on "small straight", if the dice read
  1,2,3,4,5, the player scores 15 (the sum of all the dice).

Large straight:
When placed on "large straight", if the dice read
  2,3,4,5,6, the player scores 20 (the sum of all the dice).

Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series.

Recall that the first six distinct Fibonacci numbers are: 1, 2, 3, 5, 8, 13.
The decimal number eleven can be written as

0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1

or 010100 in positional notation where the columns represent multiplication by a particular member of the sequence. Leading zeroes are dropped so that eleven decimal becomes 10100.

10100 is not the only way to make eleven from the Fibonacci numbers however;

0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1

or 010011 would also represent decimal 11. For a true Zeckendorf number there is the added restriction that no two consecutive Fibonacci numbers can be used which leads to the former unique solution.

Your task is to generate and show here a table of the Zeckendorf number representations of the decimal numbers zero to twenty, in order.

[Source https://rosettacode.org]