trackler 2.2.1.45 → 2.2.1.46

data/tracks/fsharp/exercises/run-length-encoding/RunLengthEncodingTest.fs

@@ -1,49 +1,61 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module RunLengthEncodingTest
 
-open Xunit
 open FsUnit.Xunit
-open System.Text
+open Xunit
 
 open RunLengthEncoding
 
 [<Fact>]
-let ``Encode simple`` () =
-    let input = "AABBBCCCC"
-    let expected = "2A3B4C"
-    encode input |> should equal expected
+let ``Encode empty string`` () =
+    encode "" |> should equal ""
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Encode single characters only are encoded without count`` () =
+    encode "XYZ" |> should equal "XYZ"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Encode string with no single characters`` () =
+    encode "AABBBCCCC" |> should equal "2A3B4C"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Encode single characters mixed with repeated characters`` () =
+    encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB" |> should equal "12WB12W3B24WB"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Encode multiple whitespace mixed in string`` () =
+    encode "  hsqq qww  " |> should equal "2 hs2q q2w2 "
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Encode lowercase characters`` () =
+    encode "aabbbcccc" |> should equal "2a3b4c"
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Decode empty string`` () =
+    decode "" |> should equal ""
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Decode simple`` () =
-    let input = "2A3B4C"
-    let expected = "AABBBCCCC"
-    decode input |> should equal expected
+let ``Decode single characters only`` () =
+    decode "XYZ" |> should equal "XYZ"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Encode with single values`` () =
-    let input = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
-    let expected = "12WB12W3B24WB"
-    encode input |> should equal expected
+let ``Decode string with no single characters`` () =
+    decode "2A3B4C" |> should equal "AABBBCCCC"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Decode with single values`` () =
-    let input = "12WB12W3B24WB"
-    let expected = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
-    decode input |> should equal expected
+let ``Decode single characters with repeated characters`` () =
+    decode "12WB12W3B24WB" |> should equal "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Encode and then decode`` () =
-    let input = "zzz ZZ  zZ"
-    let expected = "zzz ZZ  zZ"
-    encode input |> decode |> should equal expected
+let ``Decode multiple whitespace mixed in string`` () =
+    decode "2 hs2q q2w2 " |> should equal "  hsqq qww  "
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Encode unicode`` () =
-    let input = Encoding.Unicode.GetString([|240uy; 35uy; 189uy; 38uy; 189uy; 38uy; 189uy; 38uy; 80uy; 43uy; 80uy; 43uy; 240uy; 35uy|])
-    let expected = Encoding.Unicode.GetString([|240uy; 35uy; 51uy; 0uy; 189uy; 38uy; 50uy; 0uy; 80uy; 43uy; 240uy; 35uy|])
-    encode input |> should equal expected
+let ``Decode lower case string`` () =
+    decode "2a3b4c" |> should equal "aabbbcccc"
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Decode unicode`` () =
-    let input = Encoding.Unicode.GetString([|240uy; 35uy; 51uy; 0uy; 189uy; 38uy; 50uy; 0uy; 80uy; 43uy; 240uy; 35uy|])
-    let expected = Encoding.Unicode.GetString([|240uy; 35uy; 189uy; 38uy; 189uy; 38uy; 189uy; 38uy; 80uy; 43uy; 80uy; 43uy; 240uy; 35uy|])
-    decode input |> should equal expected
+let ``Encode followed by decode gives original string`` () =
+    "zzz ZZ  zZ" |> encode |> decode |> should equal "zzz ZZ  zZ"
+

data/tracks/fsharp/generators/Generators.fs

@@ -2,6 +2,7 @@ module Generators.Generators
 
 open System
 open System.Globalization
+open Humanizer
 open Newtonsoft.Json.Linq
 open Output
 open Exercise
@@ -179,14 +180,8 @@ type QueenAttack() =
 
     override this.RenderInput (canonicalDataCase, key, value) =
         let parsePositionTuple (tupleValue: obj) =
-            let parts = 
-                (tupleValue :?> JToken)
-                    .SelectToken("position")
-                    .ToObject<string>()
-                    .TrimStart('(')
-                    .TrimEnd(')')
-                    .Split(',')
-            formatValue (int parts.[0], int parts.[1])
+            let position = (tupleValue :?> JToken).SelectToken("position")
+            formatValue (position.["row"].ToObject<int>(), position.["column"].ToObject<int>())
 
         match key with
         | "queen" | "white_queen" | "black_queen" -> parsePositionTuple value
@@ -203,6 +198,24 @@ type RnaTranscription() =
     override this.RenderExpected (canonicalDataCase, key, value) =
         value |> Option.ofObj |> formatValue |> backwardPipe
 
+type RunLengthEncoding() =
+    inherit Exercise()
+
+    override this.RenderSut canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "consistency" ->
+            let parameters = this.RenderSutParameters canonicalDataCase |> String.concat " "
+            sprintf "%s |> encode |> decode" parameters
+        | _ -> 
+            base.RenderSut canonicalDataCase
+
+    override this.RenderTestMethodName canonicalDataCase =
+        match canonicalDataCase.Property with
+        | "consistency" -> 
+            base.RenderTestMethodName canonicalDataCase
+        | _ -> 
+            sprintf "%s %s" canonicalDataCase.Property canonicalDataCase.Description |> String.upperCaseFirst
+
 type RomanNumerals() =
     inherit Exercise()
 

data/tracks/gnu-apl/test.apl

@@ -1,18 +1,18 @@
 #!/usr/bin/env apl --script
 
 ⍝ Clear logfile with given filename.
-∇test∆clear_log filename
+∇test∆clear_log filename;handle;_
   handle←'w' ⎕FIO[3] filename
   _←⎕FIO[4] handle
 ∇
 
 ⍝ )COPY file relative to current directory.
-∇test∆copy_relative path
+∇test∆copy_relative path;_
   _←⍎ ')COPY ',test¯pwd,'/',path
 ∇
 
 ⍝ Write logfile with given filename to stderr as UTF-8.
-∇test∆show_log filename
+∇test∆show_log filename;cr
   cr←⎕ucs 10
   test¯warn cr,'***** TEST LOG *****',cr,cr
   test¯warn test¯read_unicode filename
@@ -31,6 +31,6 @@
 ∇
 
 ⍝ Write string to stderr.
-∇test¯warn string
+∇test¯warn string;_
   _←'%s' string ⎕FIO[22] 2
 ∇

data/tracks/go/README.md

@@ -112,8 +112,7 @@ So let's quickly run through each file and briefly describe it:
 
 * **.meta/metadata.yml** - Like the `meta/*.md` files, this will
   override the exercise metadata from the problem-specifications
-  repository. For now **the metadata file must be present** for the
-  `description.md` file to be used: see exercism/configlet#65.
+  repository.
 
 In some exercises there can be extra files, for instance the
 [series](exercises/series/) exercise contains extra test files.

data/tracks/go/config/maintainers.json

@@ -26,13 +26,12 @@
     },
     {
       "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
+      "bio": "Passionate Developer",
       "github_username": "ferhatelmas",
-      "link_text": null,
-      "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "link_text": "ferhatelmas.com",
+      "link_url": "https://ferhatelmas.com",
+      "name": "ferhat elmas",
+      "show_on_website": true
     },
     {
       "github_username": "tleen",

data/tracks/groovy/config.json

@@ -154,6 +154,16 @@
         "regular expressions"
       ]
     },
+    {
+      "uuid": "1cbf382-0aa4-4e80-ea21-70bf38c1cb91546a3ea",
+      "slug": "triangle",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "mathematics"
+      ]
+    },
     {
       "uuid": "1d098fb3-0a27-5380-3849-73f2ca77ff2f84ca698",
       "slug": "scrabble-score",
@@ -164,6 +174,19 @@
         "strings",
         "mathematics"
       ]
+    },
+    {
+      "uuid": "a42fe79f-039a-be80-880c-1d691f7b84e85f59148",
+      "slug": "binary-search",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "collections",
+        "lists",
+        "algorithms",
+        "searching"
+      ]
     }
   ]
 }

data/tracks/groovy/exercises/binary-search/BinarySearch.groovy

@@ -0,0 +1,14 @@
+class BinarySearch {
+
+    List data
+
+    // You may assume for this exercise that the input data is sorted in ascending order.
+    BinarySearch(List data) {
+        this.data = data
+    }
+
+    int indexOf(item) {
+        throw new UnsupportedOperationException('indexOf method not implemented')
+    }
+
+}

data/tracks/groovy/exercises/binary-search/BinarySearchSpec.groovy

@@ -0,0 +1,56 @@
+@Grab("org.spockframework:spock-core:1.0-groovy-2.4")
+import spock.lang.*
+
+class BinarySearchSpec extends Specification {
+
+    def "finds a value in an array with one element"() {
+        expect:
+        new BinarySearch([6]).indexOf(6) == 0
+    }
+
+    def "finds a value in the middle of an array"() {
+        expect:
+        new BinarySearch([1, 3, 4, 6, 8, 9, 11]).indexOf(6) == 3
+    }
+
+    def "finds a value at the beginning of an array"() {
+        expect:
+        new BinarySearch([1, 3, 4, 6, 8, 9, 11]).indexOf(1) == 0
+    }
+
+    def "finds a value at the end of an array"() {
+        expect:
+        new BinarySearch([1, 3, 4, 6, 8, 9, 11]).indexOf(11) == 6
+    }
+
+    def "finds a value in an array of odd length"() {
+        expect:
+        new BinarySearch([1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634]).indexOf(144) == 9
+    }
+
+    def "finds a value in an array of even length"() {
+        expect:
+        new BinarySearch([1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]).indexOf(21) == 5
+    }
+
+    def "identifies that a value is not included in the array"() {
+        expect:
+        new BinarySearch([1, 3, 4, 6, 8, 9, 11]).indexOf(7) == -1
+    }
+
+    def "a value smaller than the array's smallest value is not included"() {
+        expect:
+        new BinarySearch([1, 3, 4, 6, 8, 9, 11]).indexOf(0) == -1
+    }
+
+    def "a value larger than the array's largest value is not included"() {
+        expect:
+        new BinarySearch([1, 3, 4, 6, 8, 9, 11]).indexOf(13) == -1
+    }
+
+    def "nothing is included in an empty array"() {
+        expect:
+        new BinarySearch([]).indexOf(1) == -1
+    }
+
+}

data/tracks/groovy/exercises/binary-search/Example.groovy

@@ -0,0 +1,43 @@
+class BinarySearch {
+
+    List data
+
+    // You may assume for this exercise that the input data is sorted in ascending order.
+    BinarySearch(List data) {
+        this.data = data
+    }
+
+    int indexOf(item) {
+        if (data.empty) { return -1 }
+        if (item < data.first()) { return -1 }
+        if (item > data.last()) { return -1 }
+        
+        int left = 0
+        int right = data.size() - 1
+
+        while (true) {
+            int middle = (left + right) / 2
+            def value = data[middle]
+
+            if (item == value) {
+                // Found it, return index.
+                return middle
+            }
+
+            if (left >= right) {
+                // Nothing left to search!
+                return -1
+            }
+
+            if (item < value) {
+                // Search left half.
+                right = middle - 1
+            }
+            else {
+                // Search right half.
+                left = middle + 1
+            }
+        }
+    }
+
+}

data/tracks/groovy/exercises/binary-search/README.md

@@ -0,0 +1,59 @@
+## Binary Search
+
+Implement a binary search algorithm.
+
+Searching a sorted collection is a common task. A dictionary is a sorted
+list of word definitions. Given a word, one can find its definition. A
+telephone book is a sorted list of people's names, addresses, and
+telephone numbers. Knowing someone's name allows one to quickly find
+their telephone number and address.
+
+If the list to be searched contains more than a few items (a dozen, say)
+a binary search will require far fewer comparisons than a linear search,
+but it imposes the requirement that the list be sorted.
+
+In computer science, a binary search or half-interval search algorithm
+finds the position of a specified input value (the search "key") within
+an array sorted by key value.
+
+In each step, the algorithm compares the search key value with the key
+value of the middle element of the array.
+
+If the keys match, then a matching element has been found and its index,
+or position, is returned.
+
+Otherwise, if the search key is less than the middle element's key, then
+the algorithm repeats its action on the sub-array to the left of the
+middle element or, if the search key is greater, on the sub-array to the
+right.
+
+If the remaining array to be searched is empty, then the key cannot be
+found in the array and a special "not found" indication is returned.
+
+A binary search halves the number of items to check with each iteration,
+so locating an item (or determining its absence) takes logarithmic time.
+A binary search is a dichotomic divide and conquer search algorithm.
+
+## Source
+
+Additional information at: [http://en.wikipedia.org/wiki/Binary_search_algorithm](http://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+## Need help?
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/groovy).
+
+## Running the Tests
+Run the tests by executing the test script.
+
+```
+$ groovy ./BinarySearchSpec.groovy
+```
+
+After the first test(s) pass, continue by commenting out or removing the `@Ignore` annotations on other tests.
+
+When all tests pass, congratulations!
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

data/tracks/groovy/exercises/triangle/Example.groovy

@@ -0,0 +1,23 @@
+class Triangle {
+
+    // To be valid, the triangle must have positive sides and satisfy the triangle inequality.
+    static boolean isLegal(Number a, Number b, Number c) {
+        (a > 0) && (b > 0) && (c > 0) && (a <= b + c) && (b <= c + a) && (c <= a + b)
+    }
+
+    // Equilateral triangles have all sides equal.
+    static boolean isEquilateral(Number a, Number b, Number c) {
+        isLegal(a, b, c) && (a == b) && (b == c)
+    }
+
+    // To be isosceles, at least two of the three sides must be equal.
+    static boolean isIsosceles(Number a, Number b, Number c) {
+        isLegal(a, b, c) && ( (a == b) || (b == c) || (c == a) )
+    }
+
+    // Scalene triangles have all three sides different.
+    static boolean isScalene(Number a, Number b, Number c) {
+        isLegal(a, b, c) && (a != b) && (b != c) && (c != a)
+    }
+
+}

data/tracks/groovy/exercises/triangle/README.md

@@ -0,0 +1,42 @@
+## Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.
+
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)
+
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
+## Need help?
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/groovy).
+
+## Running the Tests
+Run the tests by executing the test script.
+
+```
+$ groovy ./TriangleSpec.groovy
+```
+
+After the first test(s) pass, continue by commenting out or removing the `@Ignore` annotations prepending other tests.
+
+When all tests pass, congratulations!
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.