trackler 2.2.1.139 → 2.2.1.140

data/tracks/erlang/exercises/pascals-triangle/rebar.config

@@ -0,0 +1,30 @@
+%% Erlang compiler options
+{erl_opts, [debug_info]}.
+
+{deps, [{erl_exercism, "0.1.1"}]}.
+
+{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/pascals-triangle/src/example.erl

@@ -0,0 +1,30 @@
+-module(example).
+
+-export([gen_pascals_triangle/1, test_version/0]).
+
+gen_pascals_triangle(N) when N < 0 -> -1;
+gen_pascals_triangle(0) -> [];
+gen_pascals_triangle(N) -> 
+	gen_pascals_triangle_helper(1, N, []).
+
+gen_pascals_triangle_helper(Count, N, CurrentResult) ->
+	case Count > N of 
+		true -> CurrentResult;
+		false -> 
+			gen_pascals_triangle_helper(
+				Count + 1, 
+				N, 
+				CurrentResult ++ gen_next(CurrentResult))
+	end.
+
+gen_next([]) -> [[1]];
+gen_next(CurrentResult) ->
+	LastRowDropLast = lists:droplast(lists:last(CurrentResult)),
+	ReverseLastRowDropLast = lists:reverse(LastRowDropLast),
+	ZipList = lists:zipwith(
+		fun(X, Y) -> X + Y end,
+		LastRowDropLast, 
+		ReverseLastRowDropLast),
+	[[1] ++ ZipList ++ [1]].
+
+test_version() -> 1.

data/tracks/erlang/exercises/pascals-triangle/src/pascals_triangle.app.src

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

data/tracks/erlang/exercises/pascals-triangle/src/pascals_triangle.erl

@@ -0,0 +1,8 @@
+-module(pascals_triangle).
+
+-export([gen_pascals_triangle/1, test_version/0]).
+
+gen_pascals_triangle(N) -> 
+	undefined.
+
+test_version() -> 1.

data/tracks/erlang/exercises/pascals-triangle/test/pascals_triangle_tests.erl

@@ -0,0 +1,51 @@
+-module(pascals_triangle_tests).
+
+-include_lib("erl_exercism/include/exercism.hrl").
+-include_lib("eunit/include/eunit.hrl").
+
+
+% test cases adapted from `x-common//canonical-data.json` @ version: 1.3.0
+
+zero_row_test() ->
+  ?assertEqual([], pascals_triangle:gen_pascals_triangle(0)).
+
+one_row_test() ->
+  ?assertEqual([[1]], pascals_triangle:gen_pascals_triangle(1)).
+
+two_rows_test() ->
+  ?assertEqual([[1], [1, 1]], pascals_triangle:gen_pascals_triangle(2)).
+
+three_rows_test() ->
+  ?assertEqual([[1], [1, 1], [1, 2, 1]], pascals_triangle:gen_pascals_triangle(3)).
+
+four_rows_test() ->
+  ?assertEqual(
+    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]], 
+    pascals_triangle:gen_pascals_triangle(4)).
+
+five_rows_test() ->
+  ?assertEqual(
+    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]], 
+    pascals_triangle:gen_pascals_triangle(5)).
+
+six_rows_test() ->
+  ?assertEqual(
+    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1]], 
+    pascals_triangle:gen_pascals_triangle(6)).
+
+ten_rows_test() ->
+  ?assertEqual(
+    [[1], 
+    [1, 1], 
+    [1, 2, 1], 
+    [1, 3, 3, 1], 
+    [1, 4, 6, 4, 1], 
+    [1, 5, 10, 10, 5, 1], 
+    [1, 6, 15, 20, 15, 6, 1], 
+    [1, 7, 21, 35, 35, 21, 7, 1], 
+    [1, 8, 28, 56, 70, 56, 28, 8, 1], 
+    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]],
+    pascals_triangle:gen_pascals_triangle(10)).
+
+negative_rows_test() ->
+  ?assertEqual(-1, pascals_triangle:gen_pascals_triangle(-1)).

data/tracks/fsharp/exercises/diffie-hellman/DiffieHellmanTest.fs

@@ -1,68 +1,48 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.0.0 of the canonical data.
 
 module DiffieHellmanTest
 
-open System.Numerics
-
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open DiffieHellman
 
 [<Fact>]
-let ``Private key in range`` () =   
-    let primeP = 23I
-    let privateKeys = [for _ in 0 .. 10 -> privateKey primeP]
-    privateKeys |> List.iter (fun x -> x |> should be (greaterThanOrEqualTo 1I))
-    privateKeys |> List.iter (fun x -> x |> should be (lessThanOrEqualTo (primeP - 1I)))
+let ``Private key is in range 1 .. p`` () =
+    let p = 7919I
+    let privateKeys = [for _ in 0 .. 10 -> privateKey p]
+    privateKeys |> List.iter (fun x -> x |> should be (greaterThan 1I))
+    privateKeys |> List.iter (fun x -> x |> should be (lessThan p))
 
-// Note: due to the nature of randomness, there is always a chance that this test fails
-// Be sure to check the actual generated values
-[<Fact(Skip = "Remove to run test")>]
-let ``Private key randomly generated`` () =   
-    let primeP = 7919I
-    let privateKeys = [for _ in 0 .. 5 -> privateKey primeP]
-    privateKeys.Length |> should equal <| List.length (List.distinct privateKeys) 
-    
 [<Fact(Skip = "Remove to run test")>]
-let ``Public key correctly calculated`` () =
-    let primeP = 23I
-    let primeG = 5I
-    let privateKey = 6I
-
-    let actual = publicKey primeP primeG privateKey    
-    actual |> should equal 8I
+let ``Private key is random`` () =
+    let p = 7919I
+    let privateKeys = [for _ in 0 .. 10 -> privateKey p]
+    List.distinct privateKeys |> List.length |> should equal (List.length privateKeys)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Secret key correctly calculated`` () =
-    let primeP = 23I
-    let publicKey = 19I
+let ``Can calculate public key using private key`` () =
+    let p = 23I
+    let g = 5I
     let privateKey = 6I
-
-    let actual = secret primeP publicKey privateKey
-    actual |> should equal 2I
+    publicKey p g privateKey |> should equal 8I
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Secret key correctly calculated when using large primes`` () =
-    let primeP = 120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543I
-    let publicKey = 75205441154357919442925546169208711235485855904969178206313309299205868312399046149367516336607966149689640419216591714331722664409474612463910928128055994157922930443733535659848264364106037925315974095321112757711756912144137705613776063541350548911512715512539186192176020596861210448363099541947258202188I
-    let privateKey = 2483479393625932939911081304356888505153797135447327501792696199190469015215177630758617902200417377685436170904594686456961202706692908603181062371925882I
-    let expected = 70900735223964890815905879227737819348808518698920446491346508980461201746567735331455825644429877946556431095820785835497384849778344216981228226252639932672153547963980483673419756271345828771971984887453014488572245819864454136618980914729839523581263886740821363010486083940557620831348661126601106717071I
-    let actual = secret primeP publicKey privateKey
-    actual |> should equal expected
+let ``Can calculate secret using other party's public key`` () =
+    let p = 23I
+    let theirPublicKey = 19I
+    let myPrivateKey = 6I
+    secret p theirPublicKey myPrivateKey |> should equal 2I
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Test exchange`` () =
-    let primeP = 23I
-    let primeG = 5I
-
-    let privateKeyA = privateKey primeP
-    let privateKeyB = privateKey primeP
-    
-    let publicKeyA = publicKey primeP primeG privateKeyA
-    let publicKeyB = publicKey primeP primeG privateKeyB
-    
-    let secretA = secret primeP publicKeyB privateKeyA
-    let secretB = secret primeP publicKeyA privateKeyB
+let ``Key exchange`` () =
+    let p = 23I
+    let g = 5I
+    let alicePrivateKey = privateKey p
+    let alicePublicKey = publicKey p g alicePrivateKey
+    let bobPrivateKey = privateKey p
+    let bobPublicKey = publicKey p g bobPrivateKey
+    let secretA = secret p bobPublicKey alicePrivateKey
+    let secretB = secret p alicePublicKey bobPrivateKey
+    secretA |> should equal secretB
 
-    secretA |> should equal secretB

data/tracks/fsharp/exercises/yacht/YachtTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module YachtTest
 
@@ -59,6 +59,10 @@ let ``Full house three small, two big`` () =
 let ``Two pair is not a full house`` () =
     score Category.FullHouse [2; 2; 4; 4; 5] |> should equal 0
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Four of a kind is not a full house`` () =
+    score Category.FullHouse [1; 4; 4; 4; 4] |> should equal 0
+
 [<Fact(Skip = "Remove to run test")>]
 let ``Yacht is not a full house`` () =
     score Category.FullHouse [2; 2; 2; 2; 2] |> should equal 0

data/tracks/fsharp/generators/Generators.fs

@@ -431,6 +431,59 @@ type Diamond() =
 type DifferenceOfSquares() =
     inherit GeneratorExercise()
 
+type DiffieHellman() =
+    inherit GeneratorExercise()
+
+    override __.RenderValue (canonicalDataCase, key, value) = 
+        match canonicalDataCase.Property, value.Type with
+        | _, JTokenType.Integer ->
+            sprintf "%dI" (value.ToObject<int>())
+        | "keyExchange", _ ->
+            value.ToObject<string>().Replace(",", "").Replace("(", " ").Replace(")", "")
+        | _ ->
+            base.RenderValue(canonicalDataCase, key, value)
+
+    override __.RenderArrange canonicalDataCase =
+        let arrange = base.RenderArrange canonicalDataCase
+
+        match canonicalDataCase.Property with
+        | "privateKeyIsInRange" | "privateKeyIsRandom" ->
+            List.append arrange ["let privateKeys = [for _ in 0 .. 10 -> privateKey p]" ]
+        | _ -> arrange
+
+    override __.RenderAssert canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "privateKeyIsInRange" ->
+            let greaterThan = canonicalDataCase.Expected.["greaterThan"].ToObject<int>()
+            let lessThan = canonicalDataCase.Expected.["lessThan"].ToObject<string>()
+
+            [ sprintf "privateKeys |> List.iter (fun x -> x |> should be (greaterThan %dI))" greaterThan;
+              sprintf "privateKeys |> List.iter (fun x -> x |> should be (lessThan %s))" lessThan ]
+        | "privateKeyIsRandom" -> 
+            [ "List.distinct privateKeys |> List.length |> should equal (List.length privateKeys)" ]
+        | "keyExchange" ->
+            [ "secretA |> should equal secretB" ]
+        | _ -> base.RenderAssert canonicalDataCase
+
+    override __.MapCanonicalDataCase canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "privateKeyIsInRange" | "privateKeyIsRandom" ->
+            { canonicalDataCase with Input = Map.add "p" (JToken.Parse("7919")) canonicalDataCase.Input }
+        | _ -> base.MapCanonicalDataCase canonicalDataCase
+
+    override this.PropertiesWithIdentifier canonicalDataCase = this.PropertiesUsedAsSutParameter canonicalDataCase
+
+    override __.PropertiesUsedAsSutParameter canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "publicKey" -> 
+            ["p"; "g"; "privateKey"]
+        | "secret" ->
+            ["p"; "theirPublicKey"; "myPrivateKey"]
+        | "keyExchange" ->
+            ["p"; "g"; "alicePrivateKey"; "alicePublicKey"; "bobPrivateKey"; "bobPublicKey"; "secretA"; "secretB"]
+        | _ ->
+            base.PropertiesUsedAsSutParameter canonicalDataCase
+
 type Dominoes() =
     inherit GeneratorExercise()
     

data/tracks/go/config.json

@@ -1060,6 +1060,18 @@
       "unlocked_by": "tree-building",
       "uuid": "7aa53a27-4ff3-4891-809f-2af728eb55a0"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "markdown",
+      "topics": [
+        "refactoring",
+        "strings",
+        "text_formatting"
+      ],
+      "unlocked_by": "twelve-days",
+      "uuid": "a7469032-c4d0-4e15-aa0c-4e9f6588b4c8"
+    },
     { 
       "core": false,
       "difficulty": 4,

data/tracks/go/exercises/markdown/.meta/gen.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"log"
+	"text/template"
+
+	"../../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("markdown", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Exercise string
+	Version  string
+	Comments []string
+	Cases    []oneCase
+}
+
+// Test cases
+type oneCase struct {
+	Description string
+	Property    string
+	Input       struct {
+		Markdown string
+	}
+	Expected string
+}
+
+// Template to generate test cases.
+var tmpl = `package markdown
+
+{{.Header}}
+
+{{range .J.Comments}}
+// {{ . }}
+{{end}}
+
+var testCases = []struct {
+	description	  string
+	input		  string
+	expected	  string
+}{ {{range .J.Cases}} 
+{
+	description:	{{printf "%q"  .Description}},
+	input:		{{printf "%#v"  .Input.Markdown}},
+	expected:	{{printf "%#v"  .Expected}},
+},{{end}}
+}
+`

data/tracks/go/exercises/markdown/README.md

@@ -0,0 +1,35 @@
+# Markdown
+
+Refactor a Markdown parser.
+
+The markdown exercise is a refactoring exercise. There is code that parses a
+given string with [Markdown
+syntax](https://guides.github.com/features/mastering-markdown/) and returns the
+associated HTML for that string. Even though this code is confusingly written
+and hard to follow, somehow it works and all the tests are passing! Your
+challenge is to re-write this code to make it easier to read and maintain
+while still making sure that all the tests keep passing.
+
+It would be helpful if you made notes of what you did in your refactoring in
+comments so reviewers can see that, but it isn't strictly necessary. The most
+important thing is to make the code better!
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+    go test -bench .
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Further information
+
+For more detailed information about the Go track, including how to get help if
+you're having trouble, please visit the exercism.io [Go language page](http://exercism.io/languages/go/about).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/markdown/cases_test.go

@@ -0,0 +1,59 @@
+package markdown
+
+// Source: exercism/problem-specifications
+// Commit: 9713d52 markdown: Apply new "input" policy
+// Problem Specifications Version: 1.2.0
+
+// Markdown is a shorthand for creating HTML from text strings.
+
+var testCases = []struct {
+	description string
+	input       string
+	expected    string
+}{
+	{
+		description: "parses normal text as a paragraph",
+		input:       "This will be a paragraph",
+		expected:    "<p>This will be a paragraph</p>",
+	},
+	{
+		description: "parsing italics",
+		input:       "_This will be italic_",
+		expected:    "<p><em>This will be italic</em></p>",
+	},
+	{
+		description: "parsing bold text",
+		input:       "__This will be bold__",
+		expected:    "<p><strong>This will be bold</strong></p>",
+	},
+	{
+		description: "mixed normal, italics and bold text",
+		input:       "This will _be_ __mixed__",
+		expected:    "<p>This will <em>be</em> <strong>mixed</strong></p>",
+	},
+	{
+		description: "with h1 header level",
+		input:       "# This will be an h1",
+		expected:    "<h1>This will be an h1</h1>",
+	},
+	{
+		description: "with h2 header level",
+		input:       "## This will be an h2",
+		expected:    "<h2>This will be an h2</h2>",
+	},
+	{
+		description: "with h6 header level",
+		input:       "###### This will be an h6",
+		expected:    "<h6>This will be an h6</h6>",
+	},
+	{
+		description: "unordered lists",
+		input:       "* Item 1\n* Item 2",
+		expected:    "<ul><li>Item 1</li><li>Item 2</li></ul>",
+	},
+	{
+		description: "With a little bit of everything",
+		input:       "# Header!\n* __Bold Item__\n* _Italic Item_",
+		expected:    "<h1>Header!</h1><ul><li><strong>Bold Item</strong></li><li><em>Italic Item</em></li></ul>",
+	},
+}

data/tracks/go/exercises/markdown/example.go

@@ -0,0 +1,70 @@
+package markdown
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+)
+
+type charType int
+
+// used to keep track of which tag to close
+const (
+	none charType = iota
+	hash
+	star
+)
+
+// Render translates markdown to HTML
+func Render(markdown string) (html string) {
+	//first the easy one, via regexp substitution
+	reStrong := regexp.MustCompile("(__)(.*)(__)")
+	s := reStrong.ReplaceAll([]byte(markdown), []byte("<strong>$2</strong>"))
+	reEm := regexp.MustCompile("(_)(.*)(_)")
+	s = reEm.ReplaceAll(s, []byte("<em>$2</em>"))
+	//now manage <li> and <hN>
+	var output bytes.Buffer
+	starcount := 0
+	hcount := 0
+	needtoClose := none
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '#':
+			for s[i] == '#' {
+				hcount++
+				i++
+			}
+			output.WriteString(fmt.Sprintf("<h%d>", hcount))
+			needtoClose = hash
+		case '*':
+			if starcount == 0 {
+				output.WriteString("<ul>")
+			}
+			i++
+			starcount++
+			output.WriteString("<li>")
+			needtoClose = star
+		case '\n':
+			if needtoClose == hash {
+				output.WriteString(fmt.Sprintf("</h%d>", hcount))
+			}
+			if needtoClose == star {
+				output.WriteString("</li>")
+			}
+
+		default:
+			output.WriteByte(s[i])
+
+		}
+	}
+	if starcount > 0 || hcount > 0 {
+		if needtoClose == hash {
+			output.WriteString(fmt.Sprintf("</h%d>", hcount))
+		}
+		if needtoClose == star {
+			output.WriteString("</li></ul>")
+		}
+		return output.String()
+	}
+	return fmt.Sprintf("<p>%s</p>", string(s))
+}

data/tracks/go/exercises/markdown/markdown.go

@@ -0,0 +1,66 @@
+package markdown
+
+// implementation to refactor
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Render translates markdown to HTML
+func Render(markdown string) string {
+	header := 0
+	markdown = strings.Replace(markdown, "__", "<strong>", 1)
+	markdown = strings.Replace(markdown, "__", "</strong>", 1)
+	markdown = strings.Replace(markdown, "_", "<em>", 1)
+	markdown = strings.Replace(markdown, "_", "</em>", 1)
+	pos := 0
+	list := 0
+	html := ""
+	for {
+		char := markdown[pos]
+		if char == '#' {
+			for char == '#' {
+				header++
+				pos++
+				char = markdown[pos]
+			}
+			html += fmt.Sprintf("<h%d>", header)
+			pos++
+			continue
+		}
+		if char == '*' {
+			if list == 0 {
+				html += "<ul>"
+			}
+			html += "<li>"
+			list++
+			pos += 2
+			continue
+		}
+		if char == '\n' {
+			if list > 0 {
+				html += "</li>"
+			}
+			if header > 0 {
+				html += fmt.Sprintf("</h%d>", header)
+				header = 0
+			}
+			pos++
+			continue
+		}
+		html += string(char)
+		pos++
+		if pos >= len(markdown) {
+			break
+		}
+	}
+	if header > 0 {
+		return html + fmt.Sprintf("</h%d>", header)
+	}
+	if list > 0 {
+		return html + "</li></ul>"
+	}
+	return "<p>" + html + "</p>"
+
+}

data/tracks/go/exercises/markdown/markdown_test.go

@@ -0,0 +1,21 @@
+package markdown
+
+import "testing"
+
+func TestMarkdown(t *testing.T) {
+	for _, test := range testCases {
+		if html := Render(test.input); html != test.expected {
+			t.Fatalf("FAIL: Render(%q) = %q, want %q.", test.input, html, test.expected)
+		}
+		t.Logf("PASS: %s\n", test.description)
+	}
+}
+
+func BenchmarkMarkdown(b *testing.B) {
+	// Benchmark time to parse all the test cases
+	for i := 0; i < b.N; i++ {
+		for _, test := range testCases {
+			Render(test.input)
+		}
+	}
+}