trackler 2.2.1.47 → 2.2.1.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92efa285942ab95f5a2258104af5760d36739a97
-  data.tar.gz: c64b182d5ac840e3ab7e756817b2270630ca6b4a
+  metadata.gz: ec68899acf97545d543c40f4bef852453e55c1e1
+  data.tar.gz: 829b5be04375b44cb89e7575d0d8116805d70d48
 SHA512:
-  metadata.gz: a61f170722b0b12d153f9264c27801a9f7b54fdba704dd90fa59fe6539f8492caaf32c073617f2d3b4736ca066b53550038da87fdacb1c9d1fa229bc8a001add
-  data.tar.gz: 2228b20ec990d55cb2cdad808b17bb300cd2166fafce70bc394adbecccdf9d0c4315a140f5805f5c8df6aa1219a47456a1a57f9560f45d15896dde1169a0d734
+  metadata.gz: 12372ce3823eb15f1203cebb8164ea17ed425491ce7bcd0958c57769b393ac4b83bb54eb1a732542b3110ba2b9e113c0a9bf3524de352729b4e27b94949359d2
+  data.tar.gz: '09d000ded12e61b97617d0a59fc7d1b8933a4091905e9e9455ddcc60756767f282a1d1ab7c18c0a2e1104dc1aba01ba2be2f7e35e1eea26af73d77ead9f5426f'

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.47"
+  VERSION = "2.2.1.48"
 end

data/problem-specifications/exercises/pangram/canonical-data.json

@@ -3,7 +3,7 @@
   "comments": [
     "A pangram is a sentence using every letter of the alphabet at least once."
   ],
-  "version": "1.2.0",
+  "version": "1.3.0",
   "cases": [
     {
       "description": "Check if the given string is an pangram",
@@ -36,9 +36,9 @@
           "expected": false
         },
         {
-          "description": "another missing character 'x'",
+          "description": "another missing character, e.g. 'h'",
           "property": "isPangram",
-          "input": "the quick brown fish jumps over the lazy dog",
+          "input": "five boxing wizards jump quickly at it",
           "expected": false
         },
         {

data/tracks/common-lisp/.travis.yml

@@ -13,22 +13,15 @@ env:
     - PATH=~/.roswell/bin:$PATH
     - ROSWELL_INSTALL_DIR=$HOME/.roswell
   matrix:
-    - LISP=sbcl
+    - LISP=sbcl-bin
     - LISP=abcl-bin
-    - LISP=allegro
     - LISP=ccl-bin
     - LISP=ecl
-    - LISP=clasp
     - LISP=clisp
-    - LISP=cmu-bin
-    #- LISP=sbcl-bin
 
 matrix:
   fast_finish: true
-  allow_failures:
-    - env: LISP=clasp
-    - env: LISP=clisp
-    - env: LISP=cmu-bin
+
 
 install:
   - curl -L 'https://raw.githubusercontent.com/snmsts/roswell/release/scripts/install-for-ci.sh' | sh

data/tracks/common-lisp/docs/TESTS.md

@@ -9,18 +9,52 @@ with `(lisp-unit:run-tests :all :point-mutations-test)`.
 
 ## Making your first Common Lisp solution
 
-To create lisp code that can be loaded with `(load "dna")`
-for the first exercise, put this code in `dna.lisp`:
+To create lisp code that can be loaded with `(load "hamming")`
+for the first exercise, put this code in `hamming.lisp`:
 
 ```lisp
-(in-package #:cl-user)
-(defpackage #:dna
-  (:use #:common-lisp)
-  (:export #:hamming-distance))
+(defpackage #:hamming
+  (:use #:cl)
+  (:export #:distance))
 
-(in-package #:dna)
+(in-package #:hamming)
 
-(defun hamming-distance (dna1 dna2)
-  "Determine number of mutations between DNA strands by computing the Hamming Distance."
+(defun distance (dna1 dna2)
+  "Number of positional differences in two equal length dna strands."
+  ;;; your solution here
   )
 ```
+
+## How to run the tests
+
+If you have a running Lisp implementation you can load the test file 
+with the command: `(load "hamming-tests")`.
+
+If instead you'd like to do it from the command line the command you
+need to run depends upon the implementation. Please refer to the
+documentation for your implementation. Here we'll give examples of how
+to do it in two common implementations: 
+[Clisp](https://clisp.sourceforge.io) & [SBCL](http://www.sbcl.org).
+
+It is important to make sure that the command you run will load the
+implementation's init file, which is needed to ensure QuickLisp is
+loaded, then loads the test file, then exits back the command line.
+
+### Clisp
+
+Either of the following commands will work:
+
+```
+clisp -i ~/.clisprc.lisp hamming-test.lisp
+```
+
+```
+clisp -i hamming-test.lisp -x '(ext:exit)'
+```
+
+### SBCL
+
+```
+sbcl --load hamming-test.lisp --quit
+```
+

data/tracks/delphi/exercises/nucleotide-count/uNucleotideCountTest.pas

@@ -18,11 +18,11 @@ type
 
     [Test]
     [Ignore]
-    procedure strand_with_repeated_nucleotide;
+    procedure can_count_one_nucleotide_in_single_character_input;
 
     [Test]
     [Ignore]
-    procedure can_count_one_nucleotide_in_single_character_input;
+    procedure strand_with_repeated_nucleotide;
 
     [Test]
     [Ignore]

data/tracks/elixir/.travis.yml

@@ -1,14 +1,11 @@
 language: elixir
 elixir:
-  - 1.3.2
-  - 1.4.0-rc.1
+  - 1.4.5
+  - 1.5.2
 
 otp_release:
-  - 19.0
-
-matrix:
-  allow_failures:
-    - elixir: 1.4.0-rc.1
+  - 19.3
+  - 20.1
 
 script:
 - bin/fetch-configlet

data/tracks/elixir/README.md

@@ -6,7 +6,7 @@ Exercism Exercises in Elixir
 
 ## Setup
 
-The exercises currently target Elixir 1.3.2 and Erlang/OTP 19. Detailed
+The exercises currently target Elixir 1.5.2 and Erlang/OTP 20. Detailed
 installation instructions can be found at
 [http://elixir-lang.org/install.html](http://elixir-lang.org/install.html).
 
@@ -32,7 +32,7 @@ Please keep the following in mind:
   best to discuss these changes before doing the work.
 
 - Follow the coding standards found in
-  [The Elixir Style Guide](https://github.com/niftyn8/elixir_style_guide).
+  [The Elixir Style Guide](https://github.com/lexmag/elixir-style-guide).
 
 - Watch out for trailing spaces, extra blank lines, and spaces in blank lines.
 
@@ -40,10 +40,6 @@ Please keep the following in mind:
   exercise directory. They will not be included when the user fetches the
   exercise.
 
-- Please do not add a README or README.md file to the exercise directory. The
-  READMEs are constructed using shared metadata, which lives in the
-  [exercism/x-common](https://github.com/exercism/x-common) repository.
-
 - Each problem should have a test suite, an example solution, and a template
   file for the real implementation. The example solution should be named
   `example.exs`.

data/tracks/elixir/bin/dialyzer_check.sh

@@ -10,19 +10,8 @@ do
 done
 
 elixirc -o ./tmp/build ./tmp/src/*.exs
-
-if [ $CI ]; then
-    export PLT_FILENAME=elixir-${TRAVIS_ELIXIR_VERSION:=1.3.2}_${TRAVIS_OTP_RELEASE:=19.0}.plt
-    export PLT_LOCATION=./tmp/$PLT_FILENAME
-    wget -O $PLT_LOCATION https://github.com/danielberkompas/travis_elixir_plts/blob/master/elixir-${TRAVIS_ELIXIR_VERSION}_${TRAVIS_OTP_RELEASE}.plt?raw=true
-
-    dialyzer --no_check_plt --plt $PLT_LOCATION --no_native ./tmp/build;
-    RESULT=$?
-else
-    dialyzer ./tmp/build;
-    RESULT=$?
-fi
-
+mix dialyzer
+RESULT=$?
 rm -rf ./tmp
 
 exit $RESULT

data/tracks/elixir/exercises/allergies/example.exs

@@ -14,7 +14,8 @@ defmodule Allergies do
 
   def list(flags) do
     Enum.with_index(@allergens)
-    |> Enum.filter_map(&(flagged? flags, &1), fn({item, _}) -> item end)
+    |> Enum.filter(&flagged?(flags, &1))
+    |> Enum.map(fn {item, _} -> item end)
   end
 
   def allergic_to?(flags, item) do
@@ -22,6 +23,6 @@ defmodule Allergies do
   end
 
   defp flagged?(flags, {_, index}) do
-    (flags &&& (1 <<< index)) > 0
+    (flags &&& 1 <<< index) > 0
   end
 end

data/tracks/elixir/exercises/atbash-cipher/example.exs

@@ -9,12 +9,12 @@ defmodule Atbash do
   iex> Atbash.encode("completely insecure")
   "xlnko vgvob rmhvx fiv"
   """
-  @spec encode(String.t) :: String.t
+  @spec encode(String.t()) :: String.t()
   def encode(plaintext) do
     plaintext |> normalize |> transpose |> chunk |> Enum.join(" ")
   end
 
-  @spec decode(String.t) :: String.t
+  @spec decode(String.t()) :: String.t()
   def decode(cipher) do
     cipher |> normalize |> transpose
   end
@@ -25,9 +25,9 @@ defmodule Atbash do
 
   defp transpose(text) do
     text
-    |> String.to_char_list
+    |> String.to_charlist()
     |> Enum.map(&convert/1)
-    |> List.to_string
+    |> List.to_string()
   end
 
   defp convert(character) do
@@ -35,6 +35,6 @@ defmodule Atbash do
   end
 
   defp chunk(input) do
-    Regex.scan(~r(.{1,5}), input) |> List.flatten
+    Regex.scan(~r(.{1,5}), input) |> List.flatten()
   end
 end

data/tracks/elixir/exercises/bank-account/example.exs

@@ -8,20 +8,20 @@ defmodule BankAccount do
   ## Callbacks
 
   def init(_args) do
-    { :ok, 0 }
+    {:ok, 0}
   end
 
   def handle_call(:balance, _from, balance) do
-    { :reply, balance, balance }
+    {:reply, balance, balance}
   end
 
-  def handle_call({ :update, amount }, _from, balance) do
-    { :reply, :ok, balance + amount }
+  def handle_call({:update, amount}, _from, balance) do
+    {:reply, :ok, balance + amount}
   end
 
   def handle_call(:close, _from, balance) do
     # We stop normally and return :stopped to the caller.
-    { :stop, :normal, :stopped, balance }
+    {:stop, :normal, :stopped, balance}
   end
 
   ## Interface for tests
@@ -36,7 +36,7 @@ defmodule BankAccount do
   """
   @spec open_bank() :: account
   def open_bank() do
-    { :ok, pid } = :gen_server.start_link(BankAccount, [], [])
+    {:ok, pid} = GenServer.start_link(__MODULE__, [], [])
     pid
   end
 
@@ -45,7 +45,7 @@ defmodule BankAccount do
   """
   @spec close_bank(account) :: any
   def close_bank(account) do
-    :gen_server.call(account, :close)
+    GenServer.stop(account)
   end
 
   @doc """
@@ -54,9 +54,9 @@ defmodule BankAccount do
   @spec balance(account) :: integer
   def balance(account) do
     if Process.alive?(account) do
-      :gen_server.call(account, :balance)
+      GenServer.call(account, :balance)
     else
-      { :error, :account_closed }
+      {:error, :account_closed}
     end
   end
 
@@ -65,9 +65,9 @@ defmodule BankAccount do
   """
   def update(account, amount) do
     if Process.alive?(account) do
-      :gen_server.call(account, { :update, amount })
+      GenServer.call(account, {:update, amount})
     else
-      { :error, :account_closed }
+      {:error, :account_closed}
     end
   end
 end

data/tracks/elixir/exercises/bob/example.exs

@@ -19,17 +19,17 @@ defmodule Bob do
 
   def hey(input) do
     cond do
-      silent?(input)   -> "Fine. Be that way!"
+      silent?(input) -> "Fine. Be that way!"
       question?(input) -> "Sure."
       shouting?(input) -> "Whoa, chill out!"
-      true             -> "Whatever."
+      true -> "Whatever."
     end
   end
 
-  defp silent?(input),   do: "" == String.strip(input)
+  defp silent?(input), do: "" == String.trim(input)
   defp shouting?(input), do: input == String.upcase(input) && letters?(input)
   defp question?(input), do: String.ends_with?(input, "?")
-  defp letters?(input),  do: Regex.match?(~r/\p{L}+/, input)
+  defp letters?(input), do: Regex.match?(~r/\p{L}+/, input)
 end
 
 # Another approach which abstracts knowing about string categories

data/tracks/elixir/exercises/forth/example.exs

@@ -1,70 +1,75 @@
 defmodule Forth do
   defmodule State do
+    @type t :: %__MODULE__{}
+
     defstruct stack: [], defs: %{}, input: []
   end
 
-  @opaque evaluator :: State.t
+  @opaque evaluator :: State.t()
 
   defmodule Primitives do
     def defs do
       %{
-         "+" =>    &math_op(&1, :+) ,
-         "-" =>    &math_op(&1, :-) ,
-         "*" =>    &math_op(&1, :*) ,
-         "/" =>    &math_op(&1, :/) ,
-         "DUP" =>  &dup/1 ,
-         "DROP" => &drop/1 ,
-         "SWAP" => &swap/1 ,
-         "OVER" => &over/1
-       }
+        "+" => &math_op(&1, :+),
+        "-" => &math_op(&1, :-),
+        "*" => &math_op(&1, :*),
+        "/" => &math_op(&1, :/),
+        "DUP" => &dup/1,
+        "DROP" => &drop/1,
+        "SWAP" => &swap/1,
+        "OVER" => &over/1
+      }
     end
 
     defp math_op(s, op) do
-      { s, [a, b] } = pop(s, 2)
-      res = case op do
-        :+             -> a + b
-        :-             -> a - b
-        :*             -> a * b
-        :/ when b == 0 -> raise Forth.DivisionByZero
-        :/             -> div(a, b)
-      end
+      {s, [a, b]} = pop(s, 2)
+
+      res =
+        case op do
+          :+ -> a + b
+          :- -> a - b
+          :* -> a * b
+          :/ when b == 0 -> raise Forth.DivisionByZero
+          :/ -> div(a, b)
+        end
+
       push(s, res)
     end
 
     defp dup(s) do
-      { s, [x] } = pop(s, 1)
-      %{s | stack: [x,x|s.stack]}
+      {s, [x]} = pop(s, 1)
+      %{s | stack: [x, x | s.stack]}
     end
 
     defp drop(s) do
-      { s, _ } = pop(s, 1)
+      {s, _} = pop(s, 1)
       s
     end
 
     defp swap(s) do
-      { s, [a, b] } = pop(s, 2)
-      %{s | stack: [a,b|s.stack]}
+      {s, [a, b]} = pop(s, 2)
+      %{s | stack: [a, b | s.stack]}
     end
 
     defp over(s) do
       case s.stack do
         [b, a | t] -> %{s | stack: [a, b, a | t]}
-        _          -> raise Forth.StackUnderflow
+        _ -> raise Forth.StackUnderflow
       end
     end
 
     # Pops and returns in reverse order (so the patterns catching those args can
     # be written in the way you'd think about them in Forth).
     defp pop(s, n) do
-      { stack, acc } = do_pop(s.stack, n, [])
-      { %{s | stack: stack}, acc }
+      {stack, acc} = do_pop(s.stack, n, [])
+      {%{s | stack: stack}, acc}
     end
 
-    defp do_pop(stack, 0, acc), do: { stack, acc }
-    defp do_pop([h|t], n, acc), do: do_pop(t, n-1, [h|acc])
-    defp do_pop([], _, _), do: raise Forth.StackUnderflow
+    defp do_pop(stack, 0, acc), do: {stack, acc}
+    defp do_pop([h | t], n, acc), do: do_pop(t, n - 1, [h | acc])
+    defp do_pop([], _, _), do: raise(Forth.StackUnderflow)
 
-    defp push(s, x), do: %{s | stack: [x|s.stack]}
+    defp push(s, x), do: %{s | stack: [x | s.stack]}
   end
 
   @doc """
@@ -72,29 +77,34 @@ defmodule Forth do
   """
   @spec new() :: evaluator
   def new() do
-    %State{defs: Primitives.defs}
+    %State{defs: Primitives.defs()}
   end
 
   @doc """
   Evaluate an input string, updating the evaluator state.
   """
-  @spec eval(evaluator, String.t) :: evaluator
+  @spec eval(evaluator, String.t()) :: evaluator
   def eval(ev, s) do
     do_eval(%{ev | input: ev.input ++ tokenize(s)})
   end
 
   defp do_eval(s = %State{input: []}), do: s
-  defp do_eval(s = %State{stack: stack, input: [h|t]}) when is_integer(h) do
-    do_eval(%{s | stack: [h|stack], input: t})
+
+  defp do_eval(s = %State{stack: stack, input: [h | t]}) when is_integer(h) do
+    do_eval(%{s | stack: [h | stack], input: t})
   end
-  defp do_eval(s = %State{input: [":",h|t]}) do
+
+  defp do_eval(s = %State{input: [":", h | t]}) do
     if is_binary(h) do
       w = String.upcase(h)
       # Find the ";", otherwise just return the current state and wait for the
       # user to finish the definition.
       case Enum.split_while(t, &(&1 != ";")) do
-        { _, [] }         -> s # ";" not found
-        { ws, [";" | r] } ->
+        # ";" not found
+        {_, []} ->
+          s
+
+        {ws, [";" | r]} ->
           do_eval(%{s | defs: Map.put(s.defs, w, ws), input: r})
       end
     else
@@ -102,14 +112,22 @@ defmodule Forth do
       raise Forth.InvalidWord, word: h
     end
   end
-  defp do_eval(s = %State{defs: defs, input: [h|t]}) when is_binary(h) do
+
+  defp do_eval(s = %State{defs: defs, input: [h | t]}) when is_binary(h) do
     w = String.upcase(h)
+
     case defs[w] do
-      nil                   -> raise Forth.UnknownWord, word: w
-      d when is_function(d) -> do_eval(d.(%{s | input: t}))
+      nil ->
+        raise Forth.UnknownWord, word: w
+
+      d when is_function(d) ->
+        do_eval(d.(%{s | input: t}))
+
       # To evaluate a user defined function we'll just put the function
       # definition in the input list. That should do the trick.
-      d when is_list(d)     -> do_eval(%{s | input: d ++ t})
+      d
+      when is_list(d) ->
+        do_eval(%{s | input: d ++ t})
     end
   end
 
@@ -118,8 +136,8 @@ defmodule Forth do
     |> Stream.map(&hd/1)
     |> Enum.map(fn t ->
          case Integer.parse(t) do
-           { i, "" } -> i
-           _         -> t
+           {i, ""} -> i
+           _ -> t
          end
        end)
   end
@@ -128,7 +146,7 @@ defmodule Forth do
   Return the current stack as a string with the element on top of the stack
   being the rightmost element in the string.
   """
-  @spec format_stack(evaluator) :: String.t
+  @spec format_stack(evaluator) :: String.t()
   def format_stack(%State{stack: stack}) do
     # Enum.join calls to_string on each element, no need to do that ourselves.
     Enum.reverse(stack) |> Enum.join(" ")
@@ -141,13 +159,13 @@ defmodule Forth.StackUnderflow do
 end
 
 defmodule Forth.InvalidWord do
-  defexception [word: nil]
-  def message(e), do: "invalid word: #{inspect e.word}"
+  defexception word: nil
+  def message(e), do: "invalid word: #{inspect(e.word)}"
 end
 
 defmodule Forth.UnknownWord do
-  defexception [word: nil]
-  def message(e), do: "unknown word: #{inspect e.word}"
+  defexception word: nil
+  def message(e), do: "unknown word: #{inspect(e.word)}"
 end
 
 defmodule Forth.DivisionByZero do