trackler 2.2.1.47 → 2.2.1.48

data/tracks/elixir/mix.lock

@@ -1 +1,4 @@
-%{"poison": {:hex, :poison, "1.4.0", "cd5afb9db7f0d19487572fa28185b6d4de647f14235746824e77b3139b79b725", [], [], "hexpm"}}
+%{
+  "dialyxir": {:hex, :dialyxir, "0.5.1", "b331b091720fd93e878137add264bac4f644e1ddae07a70bf7062c7862c4b952", [:mix], []},
+  "poison": {:hex, :poison, "1.4.0", "cd5afb9db7f0d19487572fa28185b6d4de647f14235746824e77b3139b79b725", [:mix], []},
+}

data/tracks/erlang/README.md

@@ -9,6 +9,8 @@ Exercism exercises in Erlang
 For general information about how exercism works, please see the
 [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data).
 
+If you create “claiming” PRs with obviously unfinished code, please provide an estimate in the PR description when you will continue to work on the PR or you think it will be finished.
+
 ### Setting up your system for local development on the track
 
 Please make sure you have installed erlang/OTP and `rebar3` as

data/tracks/fsharp/exercises/nth-prime/Example.fs

@@ -20,4 +20,7 @@ let primes =
         yield! Seq.filter isPrime (possiblePrimes 6)
     }
 
-let nthPrime nth = Seq.item (nth - 1) primes
+let prime nth : int option = 
+    match nth with 
+    | n when n < 1 -> None
+    | _ -> Some (Seq.item (nth - 1) primes)

data/tracks/fsharp/exercises/nth-prime/NthPrime.fs

@@ -1,3 +1,3 @@
 module NthPrime
 
-let nthPrime nth = failwith "You need to implement this function."
+let prime nth : int option = failwith "You need to implement this function."

data/tracks/fsharp/exercises/nth-prime/NthPrimeTest.fs

@@ -1,49 +1,29 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module NthPrimeTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
+
 open NthPrime
 
 [<Fact>]
 let ``First prime`` () =
-    nthPrime 1 |> should equal 2
+    prime 1 |> should equal (Some 2)
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second prime`` () =
-    nthPrime 2 |> should equal 3
-
-[<Fact(Skip = "Remove to run test")>]
-let ``Third prime`` () =
-    nthPrime 3 |> should equal 5
-
-[<Fact(Skip = "Remove to run test")>]
-let ``4th prime`` () =
-    nthPrime 4 |> should equal 7
+    prime 2 |> should equal (Some 3)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``5th prime`` () =
-    nthPrime 5 |> should equal 11
+let ``Sixth prime`` () =
+    prime 6 |> should equal (Some 13)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``6th prime`` () =
-    nthPrime 6 |> should equal 13
+let ``Big prime`` () =
+    prime 10001 |> should equal (Some 104743)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``7th prime`` () =
-    nthPrime 7 |> should equal 17
+let ``There is no zeroth prime`` () =
+    prime 0 |> should equal None
 
-[<Fact(Skip = "Remove to run test")>]
-let ``8th prime`` () =
-    nthPrime 8 |> should equal 19
-
-[<Fact(Skip = "Remove to run test")>]
-let ``1000th prime`` () =
-    nthPrime 1000 |> should equal 7919
-
-[<Fact(Skip = "Remove to run test")>]
-let ``10000th prime`` () =
-    nthPrime 10000 |> should equal 104729
-
-[<Fact(Skip = "Remove to run test")>]
-let ``10001th prime`` () =
-    nthPrime 10001 |> should equal 104743

data/tracks/fsharp/exercises/pangram/PangramTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.2.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 module PangramTest
 
@@ -24,8 +24,8 @@ let ``Missing character 'x'`` () =
     isPangram "a quick movement of the enemy will jeopardize five gunboats" |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Another missing character 'x'`` () =
-    isPangram "the quick brown fish jumps over the lazy dog" |> should equal false
+let ``Another missing character, e.g. 'h'`` () =
+    isPangram "five boxing wizards jump quickly at it" |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Pangram with underscores`` () =

data/tracks/fsharp/exercises/perfect-numbers/Example.fs

@@ -1,11 +1,14 @@
 module PerfectNumbers
 
-type Classification = Perfect | Abundant | Deficient 
+type Classification = Perfect | Abundant | Deficient
 
 let sumOfFactors n = [for x in 1..n / 2 do if n % x = 0 then yield x] |> List.sum
 
-let classify n = 
-    match sumOfFactors n with
-    | x when x = n -> Perfect
-    | x when x < n -> Deficient
-    | _ -> Abundant
+let classify n : Classification option = 
+    match n with
+    | x when x <= 0 -> None
+    | _ ->
+        match sumOfFactors n with
+        | x when x = n -> Some Perfect
+        | x when x < n -> Some Deficient
+        | _ -> Some Abundant

data/tracks/fsharp/exercises/perfect-numbers/PerfectNumbers.fs

@@ -2,4 +2,4 @@
 
 type Classification = Perfect | Abundant | Deficient 
 
-let classify n = failwith "You need to implement this function."
+let classify n : Classification option = failwith "You need to implement this function."

data/tracks/fsharp/exercises/perfect-numbers/PerfectNumbersTest.fs

@@ -1,27 +1,61 @@
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
 module PerfectNumbersTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open PerfectNumbers
 
-[<Theory(Skip = "Remove to run test")>]
-[<InlineData(3)>]
-[<InlineData(7)>]
-[<InlineData(13)>]
-let ``Can classify deficient numbers`` (number) =
-    classify number |> should equal Deficient
-
-[<Theory(Skip = "Remove to run test")>]
-[<InlineData(6)>]
-[<InlineData(28)>]
-[<InlineData(496)>]
-let ``Can classify perfect numbers`` (number) =
-    classify number |> should equal Perfect
-
-[<Theory(Skip = "Remove to run test")>]
-[<InlineData(12)>]
-[<InlineData(18)>]
-[<InlineData(20)>]
-let ``Can classify abundant numbers`` (number) =
-    classify number |> should equal Abundant
+[<Fact>]
+let ``Smallest perfect number is classified correctly`` () =
+    classify 6 |> should equal (Some Perfect)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Medium perfect number is classified correctly`` () =
+    classify 28 |> should equal (Some Perfect)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Large perfect number is classified correctly`` () =
+    classify 33550336 |> should equal (Some Perfect)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest abundant number is classified correctly`` () =
+    classify 12 |> should equal (Some Abundant)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Medium abundant number is classified correctly`` () =
+    classify 30 |> should equal (Some Abundant)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Large abundant number is classified correctly`` () =
+    classify 33550335 |> should equal (Some Abundant)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest prime deficient number is classified correctly`` () =
+    classify 2 |> should equal (Some Deficient)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Smallest non-prime deficient number is classified correctly`` () =
+    classify 4 |> should equal (Some Deficient)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Medium deficient number is classified correctly`` () =
+    classify 32 |> should equal (Some Deficient)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Large deficient number is classified correctly`` () =
+    classify 33550337 |> should equal (Some Deficient)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Edge case (no factors other than itself) is classified correctly`` () =
+    classify 1 |> should equal (Some Deficient)
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Zero is rejected (not a natural number)`` () =
+    classify 0 |> should equal None
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Negative integer is rejected (not a natural number)`` () =
+    classify -1 |> should equal None
+

data/tracks/fsharp/generators/Generators.fs

@@ -176,8 +176,26 @@ type Minesweeper() =
         | true  -> Some "string list"
         | false -> None
 
+type NthPrime() =
+    inherit Exercise()
+
+    override this.RenderExpected (canonicalDataCase, key, value) = 
+        match string value with 
+        | "False" -> "None"
+        | _ ->  value :?> int64 |> sprintf "(Some %d)"
+
 type Pangram() =
     inherit Exercise()
+    
+type PerfectNumbers() =
+    inherit Exercise()
+
+    override this.RenderExpected (canonicalDataCase, key, value) = 
+        match value |> string with 
+        | "perfect" -> "(Some Perfect)"
+        | "abundant" -> "(Some Abundant)"
+        | "deficient" -> "(Some Deficient)"
+        | _ -> "None"
 
 type PhoneNumber() =
     inherit Exercise()

data/tracks/gnu-apl/config.json

@@ -17,6 +17,27 @@
       "core": true,
       "difficulty": 1,
       "topics": ["conditions", "dates"]
+    },
+    {
+      "uuid": "bc2c01ff-0e38-b280-5047-2014e184502c67074c0",
+      "slug": "hamming",
+      "core": true,
+      "difficulty": 1,
+      "topics": ["strings", "arrays", "differences"]
+    },
+    {
+      "uuid": "05764380-02d5-2a80-0741-3baa1e10b36b61333ec",
+      "slug": "rna-transcription",
+      "core": true,
+      "difficulty": 1,
+      "topics": ["strings", "arrays", "substitution", "error handling"]
+    },
+    {
+      "uuid": "17c7a5fc-0666-8780-a4f6-fe32a590bb970725b2e",
+      "slug": "raindrops",
+      "core": true,
+      "difficulty": 1,
+      "topics": ["strings", "residue", "conditions"]
     }
   ],
   "deprecated": [

data/tracks/gnu-apl/exercises/hamming/README.md

@@ -0,0 +1,42 @@
+# Hamming
+
+Calculate the Hamming difference between two DNA strands.
+
+A mutation is simply a mistake that occurs during the creation or
+copying of a nucleic acid, in particular DNA. Because nucleic acids are
+vital to cellular functions, mutations tend to cause a ripple effect
+throughout the cell. Although mutations are technically mistakes, a very
+rare mutation may equip the cell with a beneficial attribute. In fact,
+the macro effects of evolution are attributable by the accumulated
+result of beneficial microscopic mutations over many generations.
+
+The simplest and most common type of nucleic acid mutation is a point
+mutation, which replaces one base with another at a single nucleotide.
+
+By counting the number of differences between two homologous DNA strands
+taken from different genomes with a common ancestor, we get a measure of
+the minimum number of point mutations that could have occurred on the
+evolutionary path between the two strands.
+
+This is called the 'Hamming distance'.
+
+It is found by comparing two DNA strands and counting how many of the
+nucleotides are different from their equivalent in the other string.
+
+    GAGCCTACTAACGGGAT
+    CATCGTAATGACGGCCT
+    ^ ^ ^  ^ ^    ^^
+
+The Hamming distance between these two DNA strands is 7.
+
+# Implementation notes
+
+The Hamming distance is only defined for sequences of equal length. This means
+that based on the definition, each language could deal with getting sequences
+of equal length differently.
+## Source
+
+The Calculating Point Mutations problem at Rosalind [http://rosalind.info/problems/hamm/](http://rosalind.info/problems/hamm/)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/gnu-apl/exercises/hamming/hamming-example.apl

@@ -0,0 +1,5 @@
+#!/usr/bin/env apl --script
+
+∇z←x distance y
+  z←↑∊+/(∊x)≠¨∊y
+∇

data/tracks/gnu-apl/exercises/hamming/hamming.tc

@@ -0,0 +1,75 @@
+log←'./hamming.tc.log'
+⍎ ')COPY ',(⎕FIO 30),'/../../test.apl'
+
+test∆copy_relative 'hamming.apl'
+test∆clear_log log
+
+⍝ ∇distance
+
+⍝ empty strands
+  1⎕CR '' distance ''
+0
+
+⍝ identical strands
+  1⎕CR 'A' distance 'A'
+0
+
+⍝ long identical strands
+  1⎕CR 'GGACTGA' distance 'GGACTGA'
+0
+
+⍝ complete distance in single-nucleotide strands
+  1⎕CR 'A' distance 'G'
+1
+
+⍝ complete distance in small strands
+  'AG' distance 'CT'
+2
+
+⍝ small distance in small strands
+  'AT' distance 'CT'
+1
+
+⍝ small distance
+  'GGACG' distance 'GGTCG'
+1
+
+⍝ small distance in long strands
+  'ACCAGGG' distance 'ACTATGG'
+2
+
+⍝ non-unique character in first strand
+  'AGA' distance 'AGG'
+1
+
+⍝ non-unique character in second strand
+  'AGG' distance 'AGA'
+1
+
+⍝ same nucleotides in different positions
+  'TAG' distance 'GAT'
+2
+
+⍝ large distance
+  'GATACA' distance 'GCATAA'
+4
+
+⍝ large distance in off-by-one strand
+  'GGACGGATTCTG' distance 'AGGACGGATTCT'
+9
+
+⍝ disallow first strand longer
+  1⎕CR test∆try '''AATG'' distance ''AAA'''
+1 'LENGTH ERROR'
+
+⍝ disallow single vs. multiple letters
+  1⎕CR test∆try '''AATG'' distance ''A'''
+1 'LENGTH ERROR'
+  1⎕CR test∆try '''A'' distance ''AAA'''
+1 'LENGTH ERROR'
+
+⍝ disallow second strand longer
+  1⎕CR test∆try '''ATA'' distance ''AGTG'''
+1 'LENGTH ERROR'
+
+test∆show_log log

data/tracks/gnu-apl/exercises/hello-world/README.md

@@ -1,5 +1,21 @@
-# 
+# Hello World
 
+The classical introductory exercise. Just say "Hello, World!".
+
+["Hello, World!"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is
+the traditional first program for beginning programming in a new language
+or environment.
+
+The objectives are simple:
+
+- Write a function that returns the string "Hello, World!".
+- Run the test suite and make sure that it succeeds.
+- Submit your solution and check it at the website.
+
+If everything goes well, you will be ready to fetch your first real exercise.
+## Source
+
+This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/gnu-apl/exercises/leap/README.md

@@ -0,0 +1,33 @@
+# Leap
+
+Given a year, report if it is a leap year.
+
+The tricky thing here is that a leap year in the Gregorian calendar occurs:
+
+```plain
+on every year that is evenly divisible by 4
+  except every year that is evenly divisible by 100
+    unless the year is also evenly divisible by 400
+```
+
+For example, 1997 is not a leap year, but 1996 is.  1900 is not a leap
+year, but 2000 is.
+
+If your language provides a method in the standard library that does
+this look-up, pretend it doesn't exist and implement it yourself.
+
+## Notes
+
+Though our exercise adopts some very simple rules, there is more to
+learn!
+
+For a delightful, four minute explanation of the whole leap year
+phenomenon, go watch [this youtube video][video].
+
+[video]: http://www.youtube.com/watch?v=xX96xng7sAE
+## Source
+
+JavaRanch Cattle Drive, exercise 3 [http://www.javaranch.com/leap.jsp](http://www.javaranch.com/leap.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.