trackler 2.2.1.54 → 2.2.1.55

data/tracks/erlang/testgen/src/tgs.erl

@@ -0,0 +1,80 @@
+-module(tgs).
+
+-export([
+    atom/1,
+    call_fun/2,
+    call_macro/2,
+    define/2,
+    export/1,
+    include/1,
+    module/1,
+    parens/1,
+    raw/1,
+    simple_fun/2,
+    simple_fun/3,
+    value/1
+]).
+
+module(Name) when is_atom(Name) ->
+    do_module(erl_syntax:abstract(Name));
+module(Name) when is_binary(Name) ->
+    module(binary_to_list(Name));
+module(Name) when is_list(Name) ->
+    do_module(erl_syntax:atom(Name)).
+
+do_module(NameAbstract) ->
+    erl_syntax:attribute(
+        erl_syntax:text("module"), [
+            NameAbstract]).
+
+export(Exports) when is_list(Exports) ->
+    erl_syntax:attribute(
+        erl_syntax:text("export"), [
+            erl_syntax:list(lists:map(fun fun_tuple_to_text/1, Exports))]).
+
+fun_tuple_to_text({Name, Args}) when (is_list(Name) orelse is_binary(Name)) andalso is_list(Args) ->
+    Text = io_lib:format("~s/~B", [Name, length(Args)]),
+    erl_syntax:text(Text).
+
+include(File) when is_list(File) ->
+    erl_syntax:attribute(
+        erl_syntax:text("include"), [
+            erl_syntax:abstract(File)]).
+
+define(Name, Substitution) when is_list(Name) ->
+    erl_syntax:attribute(
+        erl_syntax:text("define"), [
+            erl_syntax:text(Name),
+            Substitution]).
+
+parens(Tree) ->
+    erl_syntax:parentheses(Tree).
+
+call_fun(Name, Args) when is_list(Name) ->
+    erl_syntax:application(
+        erl_syntax:text(Name), Args).
+
+call_macro(Name, Args) when is_list(Name) ->
+    call_fun("?" ++ Name, Args).
+
+atom(Name) when is_list(Name); is_atom(Name) ->
+    erl_syntax:atom(Name);
+atom(Name) when is_binary(Name) ->
+    atom(binary_to_list(Name)).
+
+simple_fun(Name, Body) ->
+    erl_syntax:function(
+        atom(Name), [erl_syntax:clause(none, Body)]).
+
+simple_fun(Name, Args, Body) when is_list(Args) ->
+    erl_syntax:function(
+        atom(Name), [erl_syntax:clause(
+            lists:map(fun (Arg) -> erl_syntax:text(Arg) end, Args),
+            none,
+            Body)]).
+
+raw(Text) when is_list(Text) ->
+    erl_syntax:text(Text).
+
+value(Value) ->
+    erl_syntax:abstract(Value).

data/tracks/fsharp/exercises/alphametics/AlphameticsTest.fs

@@ -1,52 +1,107 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module AlphameticsTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open Alphametics
 
 [<Fact>]
 let ``Puzzle with three letters`` () =
-    let actual = solve "I + BB == ILL"
-    let expected = ['I', 1; 'B', 9; 'L', 0] |> Map.ofList |> Some
-    actual |> should equal expected
+    let puzzle = "I + BB == ILL"
+    let expected = 
+        [ ('I', 1)
+          ('B', 9)
+          ('L', 0) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Solution must have unique value for each letter`` () =
-    let actual = solve "A == B"
-    actual |> should equal None
+    let puzzle = "A == B"
+    let expected = None
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Leading zero solution is invalid`` () =
-    let actual = solve "ACA + DD == BD"        
-    actual |> should equal None
+    let puzzle = "ACA + DD == BD"
+    let expected = None
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with four letters`` () =
-    let actual = solve "AS + A == MOM"
-    let expected = ['A', 9; 'S', 2; 'M', 1; 'O', 0] |> Map.ofList |> Some
-    actual |> should equal expected
+    let puzzle = "AS + A == MOM"
+    let expected = 
+        [ ('A', 9)
+          ('S', 2)
+          ('M', 1)
+          ('O', 0) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with six letters`` () =
-    let actual = solve "NO + NO + TOO == LATE"
-    let expected = ['N', 7; 'O', 4; 'T', 9; 'L', 1; 'A', 0; 'E', 2] |> Map.ofList |> Some
-    actual |> should equal expected
+    let puzzle = "NO + NO + TOO == LATE"
+    let expected = 
+        [ ('N', 7)
+          ('O', 4)
+          ('T', 9)
+          ('L', 1)
+          ('A', 0)
+          ('E', 2) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with seven letters`` () =
-    let actual = solve "HE + SEES + THE == LIGHT"
-    let expected = ['E', 4; 'G', 2; 'H', 5; 'I', 0; 'L', 1; 'S', 9; 'T', 7] |> Map.ofList |> Some
-    actual |> should equal expected
+    let puzzle = "HE + SEES + THE == LIGHT"
+    let expected = 
+        [ ('E', 4)
+          ('G', 2)
+          ('H', 5)
+          ('I', 0)
+          ('L', 1)
+          ('S', 9)
+          ('T', 7) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with eight letters`` () =
-    let actual = solve "SEND + MORE == MONEY"
-    let expected = ['S', 9; 'E', 5; 'N', 6; 'D', 7; 'M', 1; 'O', 0; 'R', 8; 'Y', 2] |> Map.ofList |> Some
-    actual |> should equal expected
+    let puzzle = "SEND + MORE == MONEY"
+    let expected = 
+        [ ('S', 9)
+          ('E', 5)
+          ('N', 6)
+          ('D', 7)
+          ('M', 1)
+          ('O', 0)
+          ('R', 8)
+          ('Y', 2) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Puzzle with ten letters`` () =
-    let actual = solve "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"
-    let expected = ['A', 5; 'D', 3; 'E', 4; 'F', 7; 'G', 8; 'N', 0; 'O', 2; 'R', 1; 'S', 6; 'T', 9] |> Map.ofList |> Some
-    actual |> should equal expected
+    let puzzle = "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"
+    let expected = 
+        [ ('A', 5)
+          ('D', 3)
+          ('E', 4)
+          ('F', 7)
+          ('G', 8)
+          ('N', 0)
+          ('O', 2)
+          ('R', 1)
+          ('S', 6)
+          ('T', 9) ]
+        |> Map.ofList
+        |> Some
+    solve puzzle |> should equal expected
+

data/tracks/fsharp/exercises/anagram/AnagramTest.fs

@@ -1,57 +1,89 @@
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
 module AnagramTest
 
-open System
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open Anagram
 
 [<Fact>]
 let ``No matches`` () =
-    let words = ["hello"; "world"; "zombies"; "pants"]
-    anagrams words "diaper" |> should be Empty
+    let candidates = ["hello"; "world"; "zombies"; "pants"]
+    anagrams candidates "diaper" |> should be Empty
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Detects simple anagram`` () =
+    let candidates = ["tan"; "stand"; "at"]
+    anagrams candidates "ant" |> should equal ["tan"]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Does not detect false positives`` () =
+    let candidates = ["eagle"]
+    anagrams candidates "galea" |> should be Empty
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Detects two anagrams`` () =
+    let candidates = ["stream"; "pigeon"; "maters"]
+    anagrams candidates "master" |> should equal ["stream"; "maters"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Detect simple anagram`` () =
-    let words = ["tan"; "stand"; "at"]
-    let expected = ["tan"]
-    anagrams words "ant" |> should equal expected
+let ``Does not detect anagram subsets`` () =
+    let candidates = ["dog"; "goody"]
+    anagrams candidates "good" |> should be Empty
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Detect multiple anagrams`` () =
-    let words = ["stream"; "pigeon"; "maters"]
-    let expected = ["stream"; "maters"]
-    anagrams words "master" |> should equal expected;
+let ``Detects anagram`` () =
+    let candidates = ["enlists"; "google"; "inlets"; "banana"]
+    anagrams candidates "listen" |> should equal ["inlets"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Does not confuse different duplicates`` () =
-    let words = ["eagle"]
-    anagrams words "galea" |> should be Empty
+let ``Detects three anagrams`` () =
+    let candidates = ["gallery"; "ballerina"; "regally"; "clergy"; "largely"; "leading"]
+    anagrams candidates "allergy" |> should equal ["gallery"; "regally"; "largely"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Identical word is not anagram`` () =
-    let words = ["corn"; "dark"; "Corn"; "rank"; "CORN"; "cron"; "park"]
-    let expected = ["cron"]
-    anagrams words "corn" |> should equal expected
+let ``Does not detect identical words`` () =
+    let candidates = ["corn"; "dark"; "Corn"; "rank"; "CORN"; "cron"; "park"]
+    anagrams candidates "corn" |> should equal ["cron"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Eliminate anagrams with same checksum`` () =
-    let words = ["last"]
-    anagrams words "mass" |> should be Empty
+let ``Does not detect non-anagrams with identical checksum`` () =
+    let candidates = ["last"]
+    anagrams candidates "mass" |> should be Empty
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Eliminate anagram subsets`` () =
-    let words = ["dog"; "goody"]
-    anagrams words "good" |> should be Empty
+let ``Detects anagrams case-insensitively`` () =
+    let candidates = ["cashregister"; "Carthorse"; "radishes"]
+    anagrams candidates "Orchestra" |> should equal ["Carthorse"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Detect anagrams`` () =
-    let words = ["gallery"; "ballerina"; "regally"; "clergy"; "largely"; "leading"]
-    let expected = ["gallery"; "regally"; "largely"]
-    let actual = anagrams words "allergy"
-    actual |> should equal expected
+let ``Detects anagrams using case-insensitive subject`` () =
+    let candidates = ["cashregister"; "carthorse"; "radishes"]
+    anagrams candidates "Orchestra" |> should equal ["carthorse"]
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Anagrams are case insensitive`` () =
-    let words = ["cashregister"; "Carthorse"; "radishes"]
-    let expected = ["Carthorse"]
-    anagrams words "Orchestra" |> should equal expected
+let ``Detects anagrams using case-insensitive possible matches`` () =
+    let candidates = ["cashregister"; "Carthorse"; "radishes"]
+    anagrams candidates "orchestra" |> should equal ["Carthorse"]
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Does not detect a word as its own anagram`` () =
+    let candidates = ["Banana"]
+    anagrams candidates "banana" |> should be Empty
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Does not detect a anagram if the original word is repeated`` () =
+    let candidates = ["go Go GO"]
+    anagrams candidates "go" |> should be Empty
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Anagrams must use all letters exactly once`` () =
+    let candidates = ["patter"]
+    anagrams candidates "tapper" |> should be Empty
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Capital word is not own anagram`` () =
+    let candidates = ["Banana"]
+    anagrams candidates "BANANA" |> should be Empty
+

data/tracks/fsharp/exercises/connect/ConnectTest.fs

@@ -1,89 +1,102 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module ConnectTest
 
-open Xunit
 open FsUnit.Xunit
-open System
+open Xunit
 
 open Connect
 
-let makeBoard (board: string list) = board |> List.map (fun x -> x.Replace(" ", "")) 
-
 [<Fact>]
-let ``Empty board has no winner`` () =
-    let lines = [". . . . .    ";
-                 " . . . . .   ";
-                 "  . . . . .  ";
-                 "   . . . . . ";
-                 "    . . . . ."]
-    let board = makeBoard lines
-    resultFor board |> should equal None
+let ``An empty board has no winner`` () =
+    let board = 
+        [ ". . . . .    "
+          " . . . . .   "
+          "  . . . . .  "
+          "   . . . . . "
+          "    . . . . ." ]
+    winner board |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``1x1 board with black stone`` () =
-    let lines = ["X"]
-    let board = makeBoard lines  
-    resultFor board |> should equal <| Some Black
+let ``X can win on a 1x1 board`` () =
+    let board = ["X"]
+    winner board |> should equal (Some Black)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``1x1 board with white stone`` () =
-    let lines = ["O"]
-    let board = makeBoard lines  
-    resultFor board |> should equal <| Some White
+let ``O can win on a 1x1 board`` () =
+    let board = ["O"]
+    winner board |> should equal (Some White)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Convoluted path`` () =
-    let lines = [". X X . .    ";
-                 " X . X . X   ";
-                 "  . X . X .  ";
-                 "   . X X . . ";
-                 "    O O O O O"]
-    let board = makeBoard lines  
-    resultFor board |> should equal <| Some Black
+let ``Only edges does not make a winner`` () =
+    let board = 
+        [ "O O O X   "
+          " X . . X  "
+          "  X . . X "
+          "   X O O O" ]
+    winner board |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Rectangle, black wins`` () =
-    let lines = [". O . .    ";
-                 " O X X X   ";
-                 "  O X O .  ";
-                 "   X X O X ";
-                 "    . O X ."]
-    let board = makeBoard lines  
-    resultFor board |> should equal <| Some Black
+let ``Illegal diagonal does not make a winner`` () =
+    let board = 
+        [ "X O . .    "
+          " O X X X   "
+          "  O X O .  "
+          "   . O X . "
+          "    X X O O" ]
+    winner board |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Rectangle, white wins`` () =
-    let lines = [". O . .    ";
-                 " O X X X   ";
-                 "  O O O .  ";
-                 "   X X O X ";
-                 "    . O X ."]
-    let board = makeBoard lines  
-    resultFor board |> should equal <| Some White
+let ``Nobody wins crossing adjacent angles`` () =
+    let board = 
+        [ "X . . .    "
+          " . X O .   "
+          "  O . X O  "
+          "   . O . X "
+          "    . . O ." ]
+    winner board |> should equal None
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Spiral, black wins`` () =
-    let lines = ["OXXXXXXXX";
-                 "OXOOOOOOO";
-                 "OXOXXXXXO";
-                 "OXOXOOOXO";
-                 "OXOXXXOXO";
-                 "OXOOOXOXO";
-                 "OXXXXXOXO";
-                 "OOOOOOOXO";
-                 "XXXXXXXXO"]
-    let board = makeBoard lines
-    resultFor board |> should equal <| Some Black
+let ``X wins crossing from left to right`` () =
+    let board = 
+        [ ". O . .    "
+          " O X X X   "
+          "  O X O .  "
+          "   X X O X "
+          "    . O X ." ]
+    winner board |> should equal (Some Black)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Spiral, nobody wins`` () =
-    let lines = ["OXXXXXXXX";
-                 "OXOOOOOOO";
-                 "OXOXXXXXO";
-                 "OXOXOOOXO";
-                 "OXOX.XOXO";
-                 "OXOOOXOXO";
-                 "OXXXXXOXO";
-                 "OOOOOOOXO";
-                 "XXXXXXXXO"]
-    let board = makeBoard lines
-    resultFor board |> should equal None
+let ``O wins crossing from top to bottom`` () =
+    let board = 
+        [ ". O . .    "
+          " O X X X   "
+          "  O O O .  "
+          "   X X O X "
+          "    . O X ." ]
+    winner board |> should equal (Some White)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``X wins using a convoluted path`` () =
+    let board = 
+        [ ". X X . .    "
+          " X . X . X   "
+          "  . X . X .  "
+          "   . X X . . "
+          "    O O O O O" ]
+    winner board |> should equal (Some Black)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``X wins using a spiral path`` () =
+    let board = 
+        [ "O X X X X X X X X        "
+          " O X O O O O O O O       "
+          "  O X O X X X X X O      "
+          "   O X O X O O O X O     "
+          "    O X O X X X O X O    "
+          "     O X O O O X O X O   "
+          "      O X X X X X O X O  "
+          "       O O O O O O O X O "
+          "        X X X X X X X X O" ]
+    winner board |> should equal (Some Black)
+