trackler 2.2.1.101 → 2.2.1.102

data/tracks/fsharp/exercises/sublist/SublistTest.fs

@@ -1,81 +1,111 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module SublistTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Sublist
 
 [<Fact>]
-let ``Empty equals empty`` () =
-    sublist [] [] |> should equal Equal
+let ``Empty lists`` () =
+    let listOne = []
+    let listTwo = []
+    sublist listOne listTwo |> should equal Equal
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Empty is a sublist of anything`` () =
-    sublist [] [1; 2; 3; 4] |> should equal Sublist
+let ``Empty list within non empty list`` () =
+    let listOne = []
+    let listTwo = [1; 2; 3]
+    sublist listOne listTwo |> should equal Sublist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Anything is a superlist of empty`` () =
-    sublist [1; 2; 3; 4] [] |> should equal Superlist
+let ``Non empty list contains empty list`` () =
+    let listOne = [1; 2; 3]
+    let listTwo = []
+    sublist listOne listTwo |> should equal Superlist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``1 is not 2`` () =
-    sublist [1] [2] |> should equal Unequal
+let ``List equals itself`` () =
+    let listOne = [1; 2; 3]
+    let listTwo = [1; 2; 3]
+    sublist listOne listTwo |> should equal Equal
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Compare larger equal lists`` () =
-    let xs = List.replicate 1000 'x'
-    sublist xs xs |> should equal Equal
+let ``Different lists`` () =
+    let listOne = [1; 2; 3]
+    let listTwo = [2; 3; 4]
+    sublist listOne listTwo |> should equal Unequal
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sublist at start`` () =
-    sublist [1; 2; 3] [1; 2; 3; 4; 5] |> should equal Sublist
+let ``False start`` () =
+    let listOne = [1; 2; 5]
+    let listTwo = [0; 1; 2; 3; 1; 2; 5; 6]
+    sublist listOne listTwo |> should equal Sublist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sublist in middle`` () =
-    sublist [4; 3; 2] [5; 4; 3; 2; 1] |> should equal Sublist
+let ``Consecutive`` () =
+    let listOne = [1; 1; 2]
+    let listTwo = [0; 1; 1; 1; 2; 1; 2]
+    sublist listOne listTwo |> should equal Sublist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sublist at end`` () =
-    sublist [3; 4; 5] [1; 2; 3; 4; 5] |> should equal Sublist
+let ``Sublist at start`` () =
+    let listOne = [0; 1; 2]
+    let listTwo = [0; 1; 2; 3; 4; 5]
+    sublist listOne listTwo |> should equal Sublist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Partially matching sublist at start`` () =
-    sublist [1; 1; 2] [1; 1; 1; 2] |> should equal Sublist
+let ``Sublist in middle`` () =
+    let listOne = [2; 3; 4]
+    let listTwo = [0; 1; 2; 3; 4; 5]
+    sublist listOne listTwo |> should equal Sublist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Sublist early in huge list`` () =
-    sublist [3; 4; 5] [1 .. 1000000]  |> should equal Sublist
- 
-[<Fact(Skip = "Remove to run test")>]
-let ``Huge sublist not in huge list`` () =
-    sublist [10 .. 1000001] [1 .. 1000000] |> should equal Unequal
+let ``Sublist at end`` () =
+    let listOne = [3; 4; 5]
+    let listTwo = [0; 1; 2; 3; 4; 5]
+    sublist listOne listTwo |> should equal Sublist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Superlist at start`` () =
-    sublist [1; 2; 3; 4; 5] [1; 2; 3] |> should equal Superlist
+let ``At start of superlist`` () =
+    let listOne = [0; 1; 2; 3; 4; 5]
+    let listTwo = [0; 1; 2]
+    sublist listOne listTwo |> should equal Superlist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Superlist in middle`` () =
-    sublist [5; 4; 3; 2; 1] [4; 3; 2] |> should equal Superlist
+let ``In middle of superlist`` () =
+    let listOne = [0; 1; 2; 3; 4; 5]
+    let listTwo = [2; 3]
+    sublist listOne listTwo |> should equal Superlist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Superlist at end`` () =
-    sublist [1; 2; 3; 4; 5] [3; 4; 5] |> should equal Superlist
+let ``At end of superlist`` () =
+    let listOne = [0; 1; 2; 3; 4; 5]
+    let listTwo = [3; 4; 5]
+    sublist listOne listTwo |> should equal Superlist
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Partially matching superlist at start`` () =
-    sublist [1; 1; 1; 2] [1; 1; 2] |> should equal Superlist
+let ``First list missing element from second list`` () =
+    let listOne = [1; 3]
+    let listTwo = [1; 2; 3]
+    sublist listOne listTwo |> should equal Unequal
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Superlist early in huge list`` () =
-    sublist [1 .. 1000000] [3; 4; 5] |> should equal Superlist
+let ``Second list missing element from first list`` () =
+    let listOne = [1; 2; 3]
+    let listTwo = [1; 3]
+    sublist listOne listTwo |> should equal Unequal
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Recurring values sublist`` () =
-    sublist [1; 2; 1; 2; 3] [1; 2; 3; 1; 2; 1; 2; 3; 2; 1] |> should equal Sublist
+let ``Order matters to a list`` () =
+    let listOne = [1; 2; 3]
+    let listTwo = [3; 2; 1]
+    sublist listOne listTwo |> should equal Unequal
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Recurring values unequal`` () =
-    sublist [1; 2; 1; 2; 3] [1; 2; 3; 1; 2; 3; 2; 3; 2; 1] |> should equal Unequal
+let ``Same digits but different numbers`` () =
+    let listOne = [1; 0; 1]
+    let listTwo = [10; 1]
+    sublist listOne listTwo |> should equal Unequal
+

data/tracks/fsharp/exercises/tournament/TournamentTest.fs

@@ -1,68 +1,135 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.4.0 of the canonical data.
 
 module TournamentTest
-    
-open Xunit
+
 open FsUnit.Xunit
+open Xunit
 
 open Tournament
 
 [<Fact>]
-let ``Correctly displays the tournament table`` () =
-    let actual = 
-        ["Αllegoric Alaskians;Blithering Badgers;win";
-         "Devastating Donkeys;Courageous Californians;draw";
-         "Devastating Donkeys;Αllegoric Alaskians;win";
-         "Courageous Californians;Blithering Badgers;loss";
-         "Blithering Badgers;Devastating Donkeys;loss";
-         "Αllegoric Alaskians;Courageous Californians;win"]
+let ``Just the header if no input`` () =
+    let rows = []
+    let expected = ["Team                           | MP |  W |  D |  L |  P"]
+    tally rows |> should equal expected
 
+[<Fact(Skip = "Remove to run test")>]
+let ``A win is three points, a loss is zero points`` () =
+    let rows = ["Allegoric Alaskans;Blithering Badgers;win"]
     let expected = 
-        ["Team                           | MP |  W |  D |  L |  P";
-         "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7";
-         "Αllegoric Alaskians            |  3 |  2 |  0 |  1 |  6";
-         "Blithering Badgers             |  3 |  1 |  0 |  2 |  3";
-         "Courageous Californians        |  3 |  0 |  1 |  2 |  1"]
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3";
+          "Blithering Badgers             |  1 |  0 |  0 |  1 |  0" ]
+    tally rows |> should equal expected
 
-    tally actual |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``A win can also be expressed as a loss`` () =
+    let rows = ["Blithering Badgers;Allegoric Alaskans;loss"]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3";
+          "Blithering Badgers             |  1 |  0 |  0 |  1 |  0" ]
+    tally rows |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Ignores incorrect input`` () =
-    let actual = 
-        ["Allegoric Alaskians;Blithering Badgers;win";
-         "Devastating Donkeys_Courageous Californians;draw";
-         "Devastating Donkeys;Allegoric Alaskians;win";
-         "";
-         "Courageous Californians;Blithering Badgers;loss";
-         "Bla;Bla;Bla";
-         "Blithering Badgers;Devastating Donkeys;loss";
-         "# Yackity yackity yack";
-         "Allegoric Alaskians;Courageous Californians;win";
-         "Devastating Donkeys;Courageous Californians;draw";
-         "Devastating Donkeys@Courageous Californians;draw"]
+let ``A different team can win`` () =
+    let rows = ["Blithering Badgers;Allegoric Alaskans;win"]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Blithering Badgers             |  1 |  1 |  0 |  0 |  3";
+          "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0" ]
+    tally rows |> should equal expected
 
+[<Fact(Skip = "Remove to run test")>]
+let ``A draw is one point each`` () =
+    let rows = ["Allegoric Alaskans;Blithering Badgers;draw"]
     let expected = 
-        ["Team                           | MP |  W |  D |  L |  P";
-         "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7";
-         "Allegoric Alaskians            |  3 |  2 |  0 |  1 |  6";
-         "Blithering Badgers             |  3 |  1 |  0 |  2 |  3";
-         "Courageous Californians        |  3 |  0 |  1 |  2 |  1"]
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1";
+          "Blithering Badgers             |  1 |  0 |  1 |  0 |  1" ]
+    tally rows |> should equal expected
 
-    tally actual |> should equal expected    
+[<Fact(Skip = "Remove to run test")>]
+let ``There can be more than one match`` () =
+    let rows = 
+        [ "Allegoric Alaskans;Blithering Badgers;win";
+          "Allegoric Alaskans;Blithering Badgers;win" ]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6";
+          "Blithering Badgers             |  2 |  0 |  0 |  2 |  0" ]
+    tally rows |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Correctly displays another tournament table`` () =
-    let actual = 
-        ["Allegoric Alaskians;Blithering Badgers;win";
-         "Devastating Donkeys;Allegoric Alaskians;win";
-         "Courageous Californians;Blithering Badgers;loss";
-         "Allegoric Alaskians;Courageous Californians;win"]
+let ``There can be more than one winner`` () =
+    let rows = 
+        [ "Allegoric Alaskans;Blithering Badgers;loss";
+          "Allegoric Alaskans;Blithering Badgers;win" ]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3";
+          "Blithering Badgers             |  2 |  1 |  0 |  1 |  3" ]
+    tally rows |> should equal expected
 
+[<Fact(Skip = "Remove to run test")>]
+let ``There can be more than two teams`` () =
+    let rows = 
+        [ "Allegoric Alaskans;Blithering Badgers;win";
+          "Blithering Badgers;Courageous Californians;win";
+          "Courageous Californians;Allegoric Alaskans;loss" ]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6";
+          "Blithering Badgers             |  2 |  1 |  0 |  1 |  3";
+          "Courageous Californians        |  2 |  0 |  0 |  2 |  0" ]
+    tally rows |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Typical input`` () =
+    let rows = 
+        [ "Allegoric Alaskans;Blithering Badgers;win";
+          "Devastating Donkeys;Courageous Californians;draw";
+          "Devastating Donkeys;Allegoric Alaskans;win";
+          "Courageous Californians;Blithering Badgers;loss";
+          "Blithering Badgers;Devastating Donkeys;loss";
+          "Allegoric Alaskans;Courageous Californians;win" ]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7";
+          "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6";
+          "Blithering Badgers             |  3 |  1 |  0 |  2 |  3";
+          "Courageous Californians        |  3 |  0 |  1 |  2 |  1" ]
+    tally rows |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Incomplete competition (not all pairs have played)`` () =
+    let rows = 
+        [ "Allegoric Alaskans;Blithering Badgers;loss";
+          "Devastating Donkeys;Allegoric Alaskans;loss";
+          "Courageous Californians;Blithering Badgers;draw";
+          "Allegoric Alaskans;Courageous Californians;win" ]
+    let expected = 
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6";
+          "Blithering Badgers             |  2 |  1 |  1 |  0 |  4";
+          "Courageous Californians        |  2 |  0 |  1 |  1 |  1";
+          "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0" ]
+    tally rows |> should equal expected
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Ties broken alphabetically`` () =
+    let rows = 
+        [ "Courageous Californians;Devastating Donkeys;win";
+          "Allegoric Alaskans;Blithering Badgers;win";
+          "Devastating Donkeys;Allegoric Alaskans;loss";
+          "Courageous Californians;Blithering Badgers;win";
+          "Blithering Badgers;Devastating Donkeys;draw";
+          "Allegoric Alaskans;Courageous Californians;draw" ]
     let expected = 
-        ["Team                           | MP |  W |  D |  L |  P";
-         "Allegoric Alaskians            |  3 |  2 |  0 |  1 |  6";
-         "Blithering Badgers             |  2 |  1 |  0 |  1 |  3";
-         "Devastating Donkeys            |  1 |  1 |  0 |  0 |  3";
-         "Courageous Californians        |  2 |  0 |  0 |  2 |  0"]
+        [ "Team                           | MP |  W |  D |  L |  P";
+          "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7";
+          "Courageous Californians        |  3 |  2 |  1 |  0 |  7";
+          "Blithering Badgers             |  3 |  0 |  1 |  2 |  1";
+          "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1" ]
+    tally rows |> should equal expected
 
-    tally actual |> should equal expected

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

@@ -1,29 +1,26 @@
 module Transpose
 
-let transpose (input: string) = 
-    let rows = input.Split '\n'
-
+let transpose (rows: string list): string list =
     let transposedCoordinates =
         rows
-        |> Array.mapi (fun row str -> str |> Seq.mapi (fun col char -> (col, (row, char))) |> Seq.toArray)
-        |> Array.concat
+        |> List.mapi (fun row str -> str |> Seq.mapi (fun col char -> (col, (row, char))) |> List.ofSeq)
+        |> List.concat
 
     let groupedByTransposedColumns =
         transposedCoordinates
-        |> Array.groupBy fst
-        |> Array.map (fun (row, chars) -> (row, chars |> Array.map snd))
+        |> List.groupBy fst
+        |> List.map (fun (row, chars) -> (row, chars |> List.map snd))
 
-    let transposedColToRow (input: (int * char)[]) =
-        let maxCol = input |> Array.map fst |> Array.max
+    let transposedColToRow (input: (int * char) list) =
+        let maxCol = input |> List.map fst |> List.max
         let findCharacter col = 
-            match Array.tryFind (fun (c, _) -> c = col) input with
+            match List.tryFind (fun (c, _) -> c = col) input with
             | Some y -> snd y
             | None -> ' '
-                
+
         [| 0..maxCol |] 
         |> Array.map findCharacter
         |> System.String
 
     groupedByTransposedColumns
-    |> Seq.map (snd >> transposedColToRow)
-    |> String.concat "\n"
+    |> List.map (snd >> transposedColToRow)

data/tracks/fsharp/exercises/transpose/TransposeTest.fs

@@ -1,256 +1,187 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module TransposeTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Transpose
 
 [<Fact>]
-let ``Empty string`` () = 
-    let input = ""
-    let expected = ""
-
-    transpose input |> should equal expected
+let ``Empty string`` () =
+    let lines: string list = []
+    let expected: string list = []
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two characters in a row`` () = 
-    let input =
-        "A1"
-
+let ``Two characters in a row`` () =
+    let lines = ["A1"]
     let expected = 
-        "A\n" +
-        "1"
-
-    transpose input |> should equal expected
+        [ "A";
+          "1" ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two characters in a column`` () = 
-    let input =
-        "A\n" +
-        "1";
-
-    let expected = 
-        "A1"
-
-    transpose input |> should equal expected
+let ``Two characters in a column`` () =
+    let lines = 
+        [ "A";
+          "1" ]
+    let expected = ["A1"]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Simple`` () = 
-    let input =
-        "ABC\n" +
-        "123"
-
+let ``Simple`` () =
+    let lines = 
+        [ "ABC";
+          "123" ]
     let expected = 
-        "A1\n" +
-        "B2\n" +
-        "C3"
-
-    transpose input |> should equal expected
+        [ "A1";
+          "B2";
+          "C3" ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Single line`` () = 
-    let input =
-        "Single line."
-
+let ``Single line`` () =
+    let lines = ["Single line."]
     let expected = 
-        "S\n" +
-        "i\n" +
-        "n\n" +
-        "g\n" +
-        "l\n" +
-        "e\n" +
-        " \n" +
-        "l\n" +
-        "i\n" +
-        "n\n" +
-        "e\n" +
-        "."
-
-    transpose input |> should equal expected
+        [ "S";
+          "i";
+          "n";
+          "g";
+          "l";
+          "e";
+          " ";
+          "l";
+          "i";
+          "n";
+          "e";
+          "." ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``First line longer than second line`` () = 
-    let input = 
-        "The fourth line.\n" + 
-        "The fifth line."
-
+let ``First line longer than second line`` () =
+    let lines = 
+        [ "The fourth line.";
+          "The fifth line." ]
     let expected = 
-        "TT\n" +
-        "hh\n" +
-        "ee\n" +
-        "  \n" +
-        "ff\n" +
-        "oi\n" +
-        "uf\n" +
-        "rt\n" +
-        "th\n" +
-        "h \n" +
-        " l\n" +
-        "li\n" +
-        "in\n" +
-        "ne\n" +
-        "e.\n" +
-        "."
-
-    transpose input |> should equal expected
+        [ "TT";
+          "hh";
+          "ee";
+          "  ";
+          "ff";
+          "oi";
+          "uf";
+          "rt";
+          "th";
+          "h ";
+          " l";
+          "li";
+          "in";
+          "ne";
+          "e.";
+          "." ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Second line longer than first line`` () = 
-    let input = 
-        "The first line.\n" + 
-        "The second line."
-
+let ``Second line longer than first line`` () =
+    let lines = 
+        [ "The first line.";
+          "The second line." ]
     let expected = 
-        "TT\n" +
-        "hh\n" +
-        "ee\n" +
-        "  \n" +
-        "fs\n" +
-        "ie\n" +
-        "rc\n" +
-        "so\n" +
-        "tn\n" +
-        " d\n" +
-        "l \n" +
-        "il\n" +
-        "ni\n" +
-        "en\n" +
-        ".e\n" +
-        " ."
-
-    transpose input |> should equal expected
+        [ "TT";
+          "hh";
+          "ee";
+          "  ";
+          "fs";
+          "ie";
+          "rc";
+          "so";
+          "tn";
+          " d";
+          "l ";
+          "il";
+          "ni";
+          "en";
+          ".e";
+          " ." ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Square`` () = 
-    let input = 
-        "HEART\n" +
-        "EMBER\n" +
-        "ABUSE\n" +
-        "RESIN\n" +
-        "TREND"
-
+let ``Mixed line length`` () =
+    let lines = 
+        [ "The longest line.";
+          "A long line.";
+          "A longer line.";
+          "A line." ]
     let expected = 
-        "HEART\n" +
-        "EMBER\n" +
-        "ABUSE\n" +
-        "RESIN\n" +
-        "TREND"
-
-    transpose input |> should equal expected
+        [ "TAAA";
+          "h   ";
+          "elll";
+          " ooi";
+          "lnnn";
+          "ogge";
+          "n e.";
+          "glr";
+          "ei ";
+          "snl";
+          "tei";
+          " .n";
+          "l e";
+          "i .";
+          "n";
+          "e";
+          "." ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Rectangle`` () = 
-    let input = 
-        "FRACTURE\n" +
-        "OUTLINED\n" +
-        "BLOOMING\n" +
-        "SEPTETTE"
-
+let ``Square`` () =
+    let lines = 
+        [ "HEART";
+          "EMBER";
+          "ABUSE";
+          "RESIN";
+          "TREND" ]
     let expected = 
-        "FOBS\n"+ 
-        "RULE\n"+ 
-        "ATOP\n"+ 
-        "CLOT\n"+ 
-        "TIME\n"+ 
-        "UNIT\n"+ 
-        "RENT\n"+ 
-        "EDGE"
-
-    transpose input |> should equal expected
+        [ "HEART";
+          "EMBER";
+          "ABUSE";
+          "RESIN";
+          "TREND" ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Triangle`` () = 
-    let input = 
-        "T\n" +
-        "EE\n" +
-        "AAA\n" +
-        "SSSS\n" +
-        "EEEEE\n" +
-        "RRRRRR"
-
+let ``Rectangle`` () =
+    let lines = 
+        [ "FRACTURE";
+          "OUTLINED";
+          "BLOOMING";
+          "SEPTETTE" ]
     let expected = 
-        "TEASER\n" + 
-        " EASER\n" + 
-        "  ASER\n" + 
-        "   SER\n" + 
-        "    ER\n" + 
-        "     R"
-
-    transpose input |> should equal expected
+        [ "FOBS";
+          "RULE";
+          "ATOP";
+          "CLOT";
+          "TIME";
+          "UNIT";
+          "RENT";
+          "EDGE" ]
+    transpose lines |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Many lines`` () = 
-    let input = 
-        "Chor. Two households, both alike in dignity,\n" +
-        "In fair Verona, where we lay our scene,\n" +
-        "From ancient grudge break to new mutiny,\n" +
-        "Where civil blood makes civil hands unclean.\n" +
-        "From forth the fatal loins of these two foes\n" +
-        "A pair of star-cross'd lovers take their life;\n" +
-        "Whose misadventur'd piteous overthrows\n" +
-        "Doth with their death bury their parents' strife.\n" +
-        "The fearful passage of their death-mark'd love,\n" +
-        "And the continuance of their parents' rage,\n" +
-        "Which, but their children's end, naught could remove,\n" +
-        "Is now the two hours' traffic of our stage;\n" +
-        "The which if you with patient ears attend,\n" +
-        "What here shall miss, our toil shall strive to mend."
+let ``Triangle`` () =
+    let lines = 
+        [ "T";
+          "EE";
+          "AAA";
+          "SSSS";
+          "EEEEE";
+          "RRRRRR" ]
+    let expected = 
+        [ "TEASER";
+          " EASER";
+          "  ASER";
+          "   SER";
+          "    ER";
+          "     R" ]
+    transpose lines |> should equal expected
 
-    let expected =      
-        "CIFWFAWDTAWITW\n" +
-        "hnrhr hohnhshh\n" +
-        "o oeopotedi ea\n" +
-        "rfmrmash  cn t\n" +
-        ".a e ie fthow \n" +
-        " ia fr weh,whh\n" +
-        "Trnco miae  ie\n" +
-        "w ciroitr btcr\n" +
-        "oVivtfshfcuhhe\n" +
-        " eeih a uote  \n" +
-        "hrnl sdtln  is\n" +
-        "oot ttvh tttfh\n" +
-        "un bhaeepihw a\n" +
-        "saglernianeoyl\n" +
-        "e,ro -trsui ol\n" +
-        "h uofcu sarhu \n" +
-        "owddarrdan o m\n" +
-        "lhg to'egccuwi\n" +
-        "deemasdaeehris\n" +
-        "sr als t  ists\n" +
-        ",ebk 'phool'h,\n" +
-        "  reldi ffd   \n" +
-        "bweso tb  rtpo\n" +
-        "oea ileutterau\n" +
-        "t kcnoorhhnatr\n" +
-        "hl isvuyee'fi \n" +
-        " atv es iisfet\n" +
-        "ayoior trr ino\n" +
-        "l  lfsoh  ecti\n" +
-        "ion   vedpn  l\n" +
-        "kuehtteieadoe \n" +
-        "erwaharrar,fas\n" +
-        "   nekt te  rh\n" +
-        "ismdsehphnnosa\n" +
-        "ncuse ra-tau l\n" +
-        " et  tormsural\n" +
-        "dniuthwea'g t \n" +
-        "iennwesnr hsts\n" +
-        "g,ycoi tkrttet\n" +
-        "n ,l r s'a anr\n" +
-        "i  ef  'dgcgdi\n" +
-        "t  aol   eoe,v\n" +
-        "y  nei sl,u; e\n" +
-        ",  .sf to l   \n" +
-        "     e rv d  t\n" +
-        "     ; ie    o\n" +
-        "       f, r   \n" +
-        "       e  e  m\n" +
-        "       .  m  e\n" +
-        "          o  n\n" +
-        "          v  d\n" +
-        "          e  .\n" +
-        "          ,"
-    
-    transpose input |> should equal expected