trackler 2.2.1.56 → 2.2.1.57

data/tracks/delphi/exercises/phone-number/README.md

@@ -14,7 +14,7 @@ The format is usually represented as
 
 where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
 
-Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.
+Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code (1) if present.
 
 For example, the inputs
 - `+1 (613)-995-0253`

data/tracks/erlang/config.json

@@ -102,6 +102,16 @@
 
       ]
     },
+    {
+      "uuid": "97f3c252-09c1-b380-5f5f-45b6eebec416e2a0830",
+      "slug": "isogram",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "d3cbfc9a-a495-4bf2-87d0-811d5f71fda6",
       "slug": "nucleotide-count",

data/tracks/erlang/exercises/isogram/README.md

@@ -0,0 +1,65 @@
+# Isogram
+
+Determine if a word or phrase is an isogram.
+
+An isogram (also known as a "nonpattern word") is a word or phrase without a
+repeating letter, however spaces and hyphens are allowed to appear multiple times.
+
+Examples of isograms:
+
+- lumberjacks
+- background
+- downstream
+- six-year-old
+
+The word *isograms*, however, is not an isogram, because the s repeats.
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Isogram](https://en.wikipedia.org/wiki/Isogram)
+
+## Running tests
+
+In order to run the tests, issue the following command from the exercise
+directory:
+
+For running the tests provided, `rebar3` is used as it is the official build and
+dependency management tool for erlang now. Please refer to [the tracks installation
+instructions](http://exercism.io/languages/erlang/installation) on how to do that.
+
+In order to run the tests, you can issue the following command from the exercise
+directory.
+
+```bash
+$ rebar3 eunit
+```
+
+### Test versioning
+
+Each problem defines a macro `TEST_VERSION` in the test file and
+verifies that the solution defines and exports a function `test_version`
+returning that same value.
+
+To make tests pass, add the following to your solution:
+
+```erlang
+-export([test_version/0]).
+
+test_version() ->
+  1.
+```
+
+The benefit of this is that reviewers can see against which test version
+an iteration was written if, for example, a previously posted solution
+does not solve the current problem or passes current tests.
+
+## Questions?
+
+For detailed information about the Erlang track, please refer to the
+[help page](http://exercism.io/languages/erlang) on the Exercism site.
+This covers the basic information on setting up the development
+environment expected by the exercises.
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/erlang/exercises/isogram/include/exercism.hrl

@@ -0,0 +1,11 @@
+-include_lib("eunit/include/eunit.hrl").
+
+sut(Module) ->
+  {ok, Files} = file:list_dir("./src"),
+  case lists:member("example.erl", Files) of
+    true  -> example;
+    false -> Module
+  end.
+
+version_test() ->
+  ?assertMatch(?TEST_VERSION, ?TESTED_MODULE:test_version()).

data/tracks/erlang/exercises/isogram/rebar.config

@@ -0,0 +1,30 @@
+%% Erlang compiler options
+{erl_opts, [debug_info]}.
+
+{deps, []}.
+
+{dialyzer, [
+  {warnings, [underspecs, no_return]},
+  {get_warnings, true},
+  {plt_apps, top_level_deps}, % top_level_deps | all_deps
+  {plt_extra_apps, []},
+  {plt_location, local}, % local | "/my/file/name"
+  {plt_prefix, "rebar3"},
+  {base_plt_apps, [stdlib, kernel, crypto]},
+  {base_plt_location, global}, % global | "/my/file/name"
+  {base_plt_prefix, "rebar3"}
+]}.
+
+%% eunit:test(Tests)
+{eunit_tests, []}.
+%% Options for eunit:test(Tests, Opts)
+{eunit_opts, [verbose]}.
+
+%% == xref ==
+
+{xref_warnings, true}.
+
+%% xref checks to run
+{xref_checks, [undefined_function_calls, undefined_functions,
+  locals_not_used, exports_not_used,
+  deprecated_function_calls, deprecated_functions]}.

data/tracks/erlang/exercises/isogram/src/example.erl

@@ -0,0 +1,16 @@
+-module(example).
+
+-export([is_isogram/1, test_version/0]).
+
+is_isogram(String) ->
+    check_isogram([C || C <- string:to_lower(String), ($a =< C), (C =< $z)]).
+
+check_isogram("") ->
+    true;
+check_isogram([H|T]) ->
+    is_not_found_in(H, T) andalso check_isogram(T).
+
+is_not_found_in(C, S) ->
+    lists:all(fun(X) -> X /= C end, S).
+
+test_version() -> 1.

data/tracks/erlang/exercises/isogram/src/isogram.app.src

@@ -0,0 +1,9 @@
+{application, isogram,
+  [{description, "exercism.io - isogram"},
+    {vsn, "0.0.1"},
+    {modules, []},
+    {registered, []},
+    {applications, [kernel,
+      stdlib]},
+    {env, []}
+  ]}.

data/tracks/erlang/exercises/isogram/src/isogram.erl

@@ -0,0 +1,9 @@
+-module(isogram).
+
+-export([is_isogram/1, test_version/0]).
+
+is_isogram(String) ->
+    undefined.
+
+test_version() ->
+    1.

data/tracks/erlang/exercises/isogram/test/isogram_tests.erl

@@ -0,0 +1,32 @@
+-module(isogram_tests).
+
+-define(TESTED_MODULE, (sut(isogram))).
+-define(TEST_VERSION, 1).
+-include("exercism.hrl").
+
+empty_string_test() ->
+    ?assert(?TESTED_MODULE:is_isogram("")).
+
+isogram_with_only_lower_case_characters_test() ->
+    ?assert(?TESTED_MODULE:is_isogram("isogram")).
+
+word_with_one_duplicated_character_test() ->
+    ?assertNot(?TESTED_MODULE:is_isogram("eleven")).
+
+longest_reported_english_isogram_test() ->
+    ?assert(?TESTED_MODULE:is_isogram("subdermatoglyphic")).
+
+word_with_duplicated_character_in_mixed_case_test() ->
+    ?assertNot(?TESTED_MODULE:is_isogram("Alphabet")).
+
+hypothetical_isogrammic_word_with_hyphen_test() ->
+    ?assert(?TESTED_MODULE:is_isogram("thumbscrew-japingly")).
+
+isogram_with_duplicated_hyphen_test() ->
+    ?assert(?TESTED_MODULE:is_isogram("six-year-old")).
+
+made_up_name_that_is_an_isogram_test() ->
+    ?assert(?TESTED_MODULE:is_isogram("Emily Jung Schwartzkopf")).
+
+duplicated_character_in_the_middle_test() ->
+    ?assertNot(?TESTED_MODULE:is_isogram("accentor")).

data/tracks/fsharp/exercises/binary-search/BinarySearch.fs

@@ -1,3 +1,3 @@
 module BinarySearch
 
-let binarySearch input value = failwith "You need to implement this function."
+let find input value = failwith "You need to implement this function."

data/tracks/fsharp/exercises/binary-search/BinarySearchTest.fs

@@ -1,51 +1,79 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module BinarySearchTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open BinarySearch
 
 [<Fact>]
-let ``Should return None when an empty array is searched`` () =
-    let input = [||]
-    binarySearch input 6 |> should equal None
+let ``Finds a value in an array with one element`` () =
+    let array = [|6|]
+    let value = 6
+    let expected = Some 0
+    find array value |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Finds a value in the middle of an array`` () =
+    let array = [|1; 3; 4; 6; 8; 9; 11|]
+    let value = 6
+    let expected = Some 3
+    find array value |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should be able to find a value in a single element array with one access`` () =
-    let input = [|6|]
-    binarySearch input 6 |> should equal <| Some 0
-    
+let ``Finds a value at the beginning of an array`` () =
+    let array = [|1; 3; 4; 6; 8; 9; 11|]
+    let value = 1
+    let expected = Some 0
+    find array value |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Should return None if a value is less than the element in a single element array`` () =
-    let input = [|94|]
-    binarySearch input 6 |> should equal None
-    
+let ``Finds a value at the end of an array`` () =
+    let array = [|1; 3; 4; 6; 8; 9; 11|]
+    let value = 11
+    let expected = Some 6
+    find array value |> should equal expected
+
 [<Fact(Skip = "Remove to run test")>]
-let ``Should return None if a value is greater than the element in a single element array`` () =
-    let input = [|94|]
-    binarySearch input 602 |> should equal None
+let ``Finds a value in an array of odd length`` () =
+    let array = [|1; 3; 5; 8; 13; 21; 34; 55; 89; 144; 233; 377; 634|]
+    let value = 144
+    let expected = Some 9
+    find array value |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find an element in a longer array`` () =
-    let input = [|6; 67; 123; 345; 456; 457; 490; 2002; 54321; 54322|]
-    binarySearch input 2002 |> should equal <| Some 7
+let ``Finds a value in an array of even length`` () =
+    let array = [|1; 3; 5; 8; 13; 21; 34; 55; 89; 144; 233; 377|]
+    let value = 21
+    let expected = Some 5
+    find array value |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find elements at the beginning of an array`` () =
-    let input = [|6; 67; 123; 345; 456; 457; 490; 2002; 54321; 54322|]
-    binarySearch input 6 |> should equal <| Some 0
+let ``Identifies that a value is not included in the array`` () =
+    let array = [|1; 3; 4; 6; 8; 9; 11|]
+    let value = 7
+    let expected = None
+    find array value |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should find elements at the end of an array`` () =
-    let input = [|6; 67; 123; 345; 456; 457; 490; 2002; 54321; 54322|]
-    binarySearch input 54322 |> should equal <| Some 9
+let ``A value smaller than the array's smallest value is not included`` () =
+    let array = [|1; 3; 4; 6; 8; 9; 11|]
+    let value = 0
+    let expected = None
+    find array value |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should return None if a value is less than all elements in a long array`` () =
-    let input = [|6; 67; 123; 345; 456; 457; 490; 2002; 54321; 54322|]
-    binarySearch input 2 |> should equal None
+let ``A value larger than the array's largest value is not included`` () =
+    let array = [|1; 3; 4; 6; 8; 9; 11|]
+    let value = 13
+    let expected = None
+    find array value |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Should return None if a value is greater than all elements in a long array`` () =
-    let input = [|6; 67; 123; 345; 456; 457; 490; 2002; 54321; 54322|]
-    binarySearch input 54323 |> should equal None
+let ``Nothing is included in an empty array`` () =
+    let array = [||]
+    let value = 1
+    let expected = None
+    find array value |> should equal expected
+

data/tracks/fsharp/exercises/binary-search/Example.fs

@@ -12,6 +12,6 @@ let rec binarySearchAux index value =
         elif value > middleValue then binarySearchAux (index + middle + 1) value input.[middle + 1 ..]
         else Some (index + middle)
 
-let binarySearch input value =
+let find input value =
     if Array.sort input <> input then failwith "The input must be an ordered lists"
     else binarySearchAux 0 value input

data/tracks/fsharp/exercises/poker/Example.fs

@@ -28,11 +28,11 @@ type PokerHand =
     | HighCard of Rank * Rank * Rank * Rank * Rank
     | OnePair of Rank * Rank * Rank * Rank 
     | TwoPair of Rank * Rank * Rank
-    | ThreeOfAKind of Rank
+    | ThreeOfAKind of Rank * Rank * Rank
     | Straight of Rank
     | Flush of Rank * Rank * Rank * Rank * Rank
     | FullHouse of Rank * Rank
-    | FourOfAKind of Rank
+    | FourOfAKind of Rank * Rank
     | StraightFlush of Rank
     
 let tuple5ToList = function (one, two, three, four, five) -> [one; two; three; four; five]
@@ -74,23 +74,27 @@ let parseSuit =
         
 let parseRank =
     function
-    | '2' -> Two
-    | '3' -> Three
-    | '4' -> Four
-    | '5' -> Five
-    | '6' -> Six
-    | '7' -> Seven
-    | '8' -> Eight
-    | '9' -> Nine
-    | 'T' -> Ten
-    | 'J' -> Jack 
-    | 'Q' -> Queen
-    | 'K' -> King
-    | 'A' -> Ace 
+    | "2" -> Two
+    | "3" -> Three
+    | "4" -> Four
+    | "5" -> Five
+    | "6" -> Six
+    | "7" -> Seven
+    | "8" -> Eight
+    | "9" -> Nine
+    | "10" -> Ten
+    | "J" -> Jack 
+    | "Q" -> Queen
+    | "K" -> King
+    | "A" -> Ace 
     | _   -> failwith "Invalid rank"
         
-let parseCard (input: string) = parseRank input.[0], parseSuit input.[1]
-        
+let parseCard (input: string) = 
+    if input.Length = 2 then
+        parseRank input.[0..0], parseSuit input.[1]
+    else
+        parseRank input.[0..1], parseSuit input.[2]
+
 let parseHand (input: string) =
     input.Split(' ') 
     |> List.ofArray 
@@ -125,12 +129,12 @@ let (|StraightFlush|_|) hand =
     
 let (|FourOfAKind|_|) hand =
     match ranksWithCount hand with
-    | (rank1, 4)::_ -> PokerHand.FourOfAKind rank1 |> Some 
+    | (rank1, 4)::(rank2, 1)::[] -> PokerHand.FourOfAKind (rank1, rank2) |> Some 
     | _ -> None
     
 let (|ThreeOfAKind|_|) hand =
     match ranksWithCount hand with
-    | (rank1, 3)::_ -> PokerHand.ThreeOfAKind rank1 |> Some 
+    | (rank1, 3)::(rank2, 1)::(rank3, 1)::[] -> PokerHand.ThreeOfAKind (rank1, rank2, rank3) |> Some 
     | _ -> None
 
 let (|TwoPair|_|) hand =
@@ -166,7 +170,6 @@ let parsePokerHand (input: string) =
 let bestHands hands =
     let pokerHands = List.map (fun hand -> hand, parsePokerHand hand) hands
     let bestHand = pokerHands |> List.map snd |> List.max 
-    
     pokerHands
     |> List.filter (snd >> (=) bestHand)
     |> List.map fst

data/tracks/fsharp/exercises/poker/PokerTest.fs

@@ -1,118 +1,177 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module PokerTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Poker
 
 [<Fact>]
-let ``One hand`` () =
-    let hand = "4S 5S 7H 8D JC"
-    bestHands [hand] |> should equal [hand]
+let ``Single hand always wins`` () =
+    let input = ["4S 5S 7H 8D JC"]
+    let expected = ["4S 5S 7H 8D JC"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Highest card out of all hands wins`` () =
+    let input = ["4D 5S 6S 8D 3C"; "2S 4C 7S 9H 10H"; "3S 4S 5D 6H JH"]
+    let expected = ["3S 4S 5D 6H JH"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``A tie has multiple winners`` () =
+    let input = ["4D 5S 6S 8D 3C"; "2S 4C 7S 9H 10H"; "3S 4S 5D 6H JH"; "3H 4H 5C 6C JD"]
+    let expected = ["3S 4S 5D 6H JH"; "3H 4H 5C 6C JD"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Multiple hands with the same high cards, tie compares next highest ranked, down to last card`` () =
+    let input = ["3S 5H 6S 8D 7H"; "2S 5D 6D 8C 7S"]
+    let expected = ["3S 5H 6S 8D 7H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Nothing vs one pair`` () =
-    let nothing = "4S 5H 6S 8D JH"
-    let pairOf4 = "2S 4H 6S 4D JH"
-    bestHands [nothing; pairOf4] |> should equal [pairOf4]
+let ``One pair beats high card`` () =
+    let input = ["4S 5H 6C 8D KH"; "2S 4H 6S 4D JH"]
+    let expected = ["2S 4H 6S 4D JH"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two pairs`` () =
-    let pairOf2 = "4S 2H 6S 2D JH"
-    let pairOf4 = "2S 4H 6S 4D JH"
-    bestHands [pairOf2; pairOf4] |> should equal [pairOf4]
+let ``Highest pair wins`` () =
+    let input = ["4S 2H 6S 2D JH"; "2S 4H 6C 4D JD"]
+    let expected = ["2S 4H 6C 4D JD"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``One pair vs double pair`` () =
-    let pairOf8 = "2S 8H 6S 8D JH"
-    let doublePair = "4S 5H 4S 8D 5H"
-    bestHands [pairOf8; doublePair] |> should equal [doublePair]
+let ``Two pairs beats one pair`` () =
+    let input = ["2S 8H 6S 8D JH"; "4S 5H 4C 8C 5C"]
+    let expected = ["4S 5H 4C 8C 5C"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two double pairs`` () =
-    let doublePair2and8 = "2S 8H 2S 8D JH"
-    let doublePair4and5 = "4S 5H 4S 8D 5H"
-    bestHands [doublePair2and8; doublePair4and5] |> should equal [doublePair2and8]
+let ``Both hands have two pairs, highest ranked pair wins`` () =
+    let input = ["2S 8H 2D 8D 3H"; "4S 5H 4C 8S 5D"]
+    let expected = ["2S 8H 2D 8D 3H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Double pair vs three`` () =
-    let doublePair2and8 = "2S 8H 2S 8D JH"
-    let threeOf4 = "4S 5H 4S 8D 4H"
-    bestHands [doublePair2and8; threeOf4] |> should equal [threeOf4]
+let ``Both hands have two pairs, with the same highest ranked pair, tie goes to low pair`` () =
+    let input = ["2S QS 2C QD JH"; "JD QH JS 8D QC"]
+    let expected = ["JD QH JS 8D QC"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two threes`` () =
-    let threeOf2 = "2S 2H 2S 8D JH"
-    let threeOf1 = "4S AH AS 8D AH"
-    bestHands [threeOf2; threeOf1] |> should equal [threeOf1]
+let ``Both hands have two identically ranked pairs, tie goes to remaining card (kicker)`` () =
+    let input = ["JD QH JS 8D QC"; "JS QS JC 2D QD"]
+    let expected = ["JD QH JS 8D QC"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Three vs straight`` () =
-    let threeOf4 = "4S 5H 4S 8D 4H"
-    let straight = "3S 4H 2S 6D 5H"
-    bestHands [threeOf4; straight] |> should equal [straight]
+let ``Three of a kind beats two pair`` () =
+    let input = ["2S 8H 2H 8D JH"; "4S 5H 4C 8S 4H"]
+    let expected = ["4S 5H 4C 8S 4H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two straights`` () =
-    let straightTo8 = "4S 6H 7S 8D 5H"
-    let straightTo9 = "5S 7H 8S 9D 6H"
-    bestHands [straightTo8; straightTo9] |> should equal [straightTo9]
+let ``Both hands have three of a kind, tie goes to highest ranked triplet`` () =
+    let input = ["2S 2H 2C 8D JH"; "4S AH AS 8C AD"]
+    let expected = ["4S AH AS 8C AD"]
+    bestHands input |> should equal expected
 
-    let straightTo1 = "AS QH KS TD JH"
-    let straightTo5 = "4S AH 3S 2D 5H"
-    bestHands [straightTo1; straightTo5] |> should equal [straightTo1]
+[<Fact(Skip = "Remove to run test")>]
+let ``With multiple decks, two players can have same three of a kind, ties go to highest remaining cards`` () =
+    let input = ["4S AH AS 7C AD"; "4S AH AS 8C AD"]
+    let expected = ["4S AH AS 8C AD"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``A straight beats three of a kind`` () =
+    let input = ["4S 5H 4C 8D 4H"; "3S 4D 2S 6D 5C"]
+    let expected = ["3S 4D 2S 6D 5C"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Straight vs flush`` () =
-    let straightTo8 = "4S 6H 7S 8D 5H"
-    let flushTo7 = "2S 4S 5S 6S 7S"
-    bestHands [straightTo8; flushTo7] |> should equal [flushTo7]
+let ``Aces can end a straight (10 J Q K A)`` () =
+    let input = ["4S 5H 4C 8D 4H"; "10D JH QS KD AC"]
+    let expected = ["10D JH QS KD AC"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two flushes`` () =
-    let flushTo8 = "3H 6H 7H 8H 5H"
-    let flushTo7 = "2S 4S 5S 6S 7S"
-    bestHands [flushTo8; flushTo7] |> should equal [flushTo8]
+let ``Aces can start a straight (A 2 3 4 5)`` () =
+    let input = ["4S 5H 4C 8D 4H"; "4D AH 3S 2D 5C"]
+    let expected = ["4D AH 3S 2D 5C"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Flush vs full`` () =
-    let flushTo8 = "3H 6H 7H 8H 5H"
-    let full = "4S 5H 4S 5D 4H"
-    bestHands [full; flushTo8] |> should equal [full]
+let ``Both hands with a straight, tie goes to highest ranked card`` () =
+    let input = ["4S 6C 7S 8D 5H"; "5S 7H 8S 9D 6H"]
+    let expected = ["5S 7H 8S 9D 6H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two fulls`` () =
-    let fullOf4by9 = "4H 4S 4D 9S 9D"
-    let fullOf5by8 = "5H 5S 5D 8S 8D"
-    bestHands [fullOf4by9; fullOf5by8] |> should equal [fullOf5by8]
+let ``Even though an ace is usually high, a 5-high straight is the lowest-scoring straight`` () =
+    let input = ["2H 3C 4D 5D 6H"; "4S AH 3S 2D 5H"]
+    let expected = ["2H 3C 4D 5D 6H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Full vs square`` () =
-    let full = "4S 5H 4S 5D 4H"
-    let squareOf3 = "3S 3H 2S 3D 3H"
-    bestHands [full; squareOf3] |> should equal [squareOf3]
+let ``Flush beats a straight`` () =
+    let input = ["4C 6H 7D 8D 5H"; "2S 4S 5S 6S 7S"]
+    let expected = ["2S 4S 5S 6S 7S"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two squares`` () =
-    let squareOf2 = "2S 2H 2S 8D 2H"
-    let squareOf5 = "4S 5H 5S 5D 5H"
-    bestHands [squareOf2; squareOf5] |> should equal [squareOf5]
+let ``Both hands have a flush, tie goes to high card, down to the last one if necessary`` () =
+    let input = ["4H 7H 8H 9H 6H"; "2S 4S 5S 6S 7S"]
+    let expected = ["4H 7H 8H 9H 6H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Square vs straight flush`` () =
-    let squareOf5 = "4S 5H 5S 5D 5H"
-    let straightFlushTo9 = "5S 7S 8S 9S 6S"
-    bestHands [squareOf5; straightFlushTo9] |> should equal [straightFlushTo9]
+let ``Full house beats a flush`` () =
+    let input = ["3H 6H 7H 8H 5H"; "4S 5H 4C 5D 4H"]
+    let expected = ["4S 5H 4C 5D 4H"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two straight flushes`` () =
-    let straightFlushTo8 = "4H 6H 7H 8H 5H"
-    let straightFlushTo9 = "5S 7S 8S 9S 6S"
-    bestHands [straightFlushTo8; straightFlushTo9] |> should equal [straightFlushTo9]
+let ``Both hands have a full house, tie goes to highest-ranked triplet`` () =
+    let input = ["4H 4S 4D 9S 9D"; "5H 5S 5D 8S 8D"]
+    let expected = ["5H 5S 5D 8S 8D"]
+    bestHands input |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Three hand with tie`` () =
-    let spadeStraightTo9 = "9S 8S 7S 6S 5S"
-    let diamondStraightTo9 = "9D 8D 7D 6D 5D"
-    let threeOf4 = "4D 4S 4H QS KS"
-    bestHands [spadeStraightTo9; diamondStraightTo9; threeOf4] |> should equal [spadeStraightTo9; diamondStraightTo9]
+let ``With multiple decks, both hands have a full house with the same triplet, tie goes to the pair`` () =
+    let input = ["5H 5S 5D 9S 9D"; "5H 5S 5D 8S 8D"]
+    let expected = ["5H 5S 5D 9S 9D"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Four of a kind beats a full house`` () =
+    let input = ["4S 5H 4D 5D 4H"; "3S 3H 2S 3D 3C"]
+    let expected = ["3S 3H 2S 3D 3C"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Both hands have four of a kind, tie goes to high quad`` () =
+    let input = ["2S 2H 2C 8D 2D"; "4S 5H 5S 5D 5C"]
+    let expected = ["4S 5H 5S 5D 5C"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``With multiple decks, both hands with identical four of a kind, tie determined by kicker`` () =
+    let input = ["3S 3H 2S 3D 3C"; "3S 3H 4S 3D 3C"]
+    let expected = ["3S 3H 4S 3D 3C"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Straight flush beats four of a kind`` () =
+    let input = ["4S 5H 5S 5D 5C"; "7S 8S 9S 6S 10S"]
+    let expected = ["7S 8S 9S 6S 10S"]
+    bestHands input |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Both hands have straight flush, tie goes to highest-ranked card`` () =
+    let input = ["4H 6H 7H 8H 5H"; "5S 7S 8S 9S 6S"]
+    let expected = ["5S 7S 8S 9S 6S"]
+    bestHands input |> should equal expected
+