trackler 2.2.1.109 → 2.2.1.110

data/tracks/elixir/exercises/matrix/matrix_test.exs

@@ -2,15 +2,15 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("matrix.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure trace: true, exclude: :pending
+ExUnit.start()
+ExUnit.configure(trace: true, exclude: :pending)
 
 defmodule MatrixTest do
   use ExUnit.Case
 
   @input "1 2 3\n4 5 6\n7 8 9"
 
-  #@tag :pending
+  # @tag :pending
   test "reading from and writing to string" do
     matrix = Matrix.from_string(@input)
     assert Matrix.to_string(matrix) == @input
@@ -21,10 +21,10 @@ defmodule MatrixTest do
     matrix = Matrix.from_string(@input)
 
     assert Matrix.rows(matrix) == [
-      [1, 2, 3],
-      [4, 5, 6],
-      [7, 8, 9]
-    ]
+             [1, 2, 3],
+             [4, 5, 6],
+             [7, 8, 9]
+           ]
   end
 
   @tag :pending
@@ -41,10 +41,10 @@ defmodule MatrixTest do
     matrix = Matrix.from_string(@input)
 
     assert Matrix.columns(matrix) == [
-      [1, 4, 7],
-      [2, 5, 8],
-      [3, 6, 9]
-    ]
+             [1, 4, 7],
+             [2, 5, 8],
+             [3, 6, 9]
+           ]
   end
 
   @tag :pending

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

@@ -4,8 +4,13 @@ defmodule Meetup do
   """
 
   @type weekday ::
-      :monday | :tuesday | :wednesday
-    | :thursday | :friday | :saturday | :sunday
+          :monday
+          | :tuesday
+          | :wednesday
+          | :thursday
+          | :friday
+          | :saturday
+          | :sunday
 
   @type schedule :: :first | :second | :third | :fourth | :last | :teenth
 
@@ -15,37 +20,39 @@ defmodule Meetup do
   The schedule is in which week (1..4, last or "teenth") the meetup date should
   fall.
   """
-  @spec meetup(pos_integer, pos_integer, weekday, schedule) :: :calendar.date
+  @spec meetup(pos_integer, pos_integer, weekday, schedule) :: :calendar.date()
   def meetup(year, month, weekday, :last) do
     start_day = :calendar.last_day_of_the_month(year, month) - 6
     meetup_nth(year, month, start_day, weekday)
   end
+
   def meetup(year, month, weekday, schedule) do
     meetup_nth(year, month, schedule_start(schedule), weekday)
   end
 
   defp meetup_nth(year, month, start_day, weekday) do
     w = weekday_num(weekday)
+
     case w - :calendar.day_of_the_week(year, month, start_day) do
-       n when n < 0 -> {year, month, start_day + n + 7}
-       n            -> {year, month, start_day + n}
+      n when n < 0 -> {year, month, start_day + n + 7}
+      n -> {year, month, start_day + n}
     end
   end
 
   # Aliases for the day of week numbers from Erlang.
   #
   # Case matching is used because that's very fast in Elixir/Erlang.
-  defp weekday_num(:monday),    do: 1
-  defp weekday_num(:tuesday),   do: 2
+  defp weekday_num(:monday), do: 1
+  defp weekday_num(:tuesday), do: 2
   defp weekday_num(:wednesday), do: 3
-  defp weekday_num(:thursday),  do: 4
-  defp weekday_num(:friday),    do: 5
-  defp weekday_num(:saturday),  do: 6
-  defp weekday_num(:sunday),    do: 7
+  defp weekday_num(:thursday), do: 4
+  defp weekday_num(:friday), do: 5
+  defp weekday_num(:saturday), do: 6
+  defp weekday_num(:sunday), do: 7
 
-  defp schedule_start(:first),  do: 1
+  defp schedule_start(:first), do: 1
   defp schedule_start(:second), do: 8
-  defp schedule_start(:third),  do: 15
+  defp schedule_start(:third), do: 15
   defp schedule_start(:fourth), do: 22
   defp schedule_start(:teenth), do: 13
 end

data/tracks/elixir/exercises/meetup/meetup.exs

@@ -4,8 +4,13 @@ defmodule Meetup do
   """
 
   @type weekday ::
-      :monday | :tuesday | :wednesday
-    | :thursday | :friday | :saturday | :sunday
+          :monday
+          | :tuesday
+          | :wednesday
+          | :thursday
+          | :friday
+          | :saturday
+          | :sunday
 
   @type schedule :: :first | :second | :third | :fourth | :last | :teenth
 
@@ -15,8 +20,7 @@ defmodule Meetup do
   The schedule is in which week (1..4, last or "teenth") the meetup date should
   fall.
   """
-  @spec meetup(pos_integer, pos_integer, weekday, schedule) :: :calendar.date
+  @spec meetup(pos_integer, pos_integer, weekday, schedule) :: :calendar.date()
   def meetup(year, month, weekday, schedule) do
-
   end
 end

data/tracks/elixir/exercises/meetup/meetup_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("meetup.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule MeetupTest do
   use ExUnit.Case

data/tracks/elixir/exercises/minesweeper/minesweeper.exs

@@ -1,11 +1,9 @@
 defmodule Minesweeper do
-
   @doc """
   Annotate empty spots next to mines with the number of mines next to them.
   """
-  @spec annotate([String.t]) :: [String.t]
+  @spec annotate([String.t()]) :: [String.t()]
 
   def annotate(board) do
-
   end
 end

data/tracks/elixir/exercises/minesweeper/minesweeper_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("minesweeper.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule MinesweeperTest do
   use ExUnit.Case
@@ -18,25 +18,19 @@ defmodule MinesweeperTest do
 
   @tag :pending
   test "empty board" do
-    b = ["   ",
-         "   ",
-         "   "]
+    b = ["   ", "   ", "   "]
     assert Minesweeper.annotate(clean(b)) == b
   end
 
   @tag :pending
   test "board full of mines" do
-    b = ["***",
-         "***",
-         "***"]
+    b = ["***", "***", "***"]
     assert Minesweeper.annotate(clean(b)) == b
   end
 
   @tag :pending
   test "surrounded" do
-    b = ["***",
-         "*8*",
-         "***"]
+    b = ["***", "*8*", "***"]
     assert Minesweeper.annotate(clean(b)) == b
   end
 
@@ -48,21 +42,13 @@ defmodule MinesweeperTest do
 
   @tag :pending
   test "vertical line" do
-    b = ["1",
-         "*",
-         "2",
-         "*",
-         "1"]
+    b = ["1", "*", "2", "*", "1"]
     assert Minesweeper.annotate(clean(b)) == b
   end
 
   @tag :pending
   test "cross" do
-    b = [" 2*2 ",
-         "25*52",
-         "*****",
-         "25*52",
-         " 2*2 "]
+    b = [" 2*2 ", "25*52", "*****", "25*52", " 2*2 "]
     assert Minesweeper.annotate(clean(b)) == b
   end
 end

data/tracks/elixir/exercises/nth-prime/example.exs

@@ -1,16 +1,16 @@
 defmodule Prime do
-
   @doc """
   Generates the nth prime.
   """
   @spec nth(non_neg_integer) :: non_neg_integer
   def nth(count) do
-    if count < 1, do: raise ArgumentError
+    if count < 1, do: raise(ArgumentError)
     nth(count, 1000)
   end
 
   defp nth(count, max) do
     primes = primes_to(max)
+
     cond do
       Enum.count(primes) < count -> nth(count, max * 4)
       true -> Enum.at(primes, count - 1)
@@ -18,13 +18,13 @@ defmodule Prime do
   end
 
   defp primes_to(limit) do
-    Enum.reduce(2..limit, [], fn(number, primes) ->
-      if is_prime?(number, primes), do: [number|primes], else: primes end)
-      |> Enum.reverse
+    Enum.reduce(2..limit, [], fn number, primes ->
+      if is_prime?(number, primes), do: [number | primes], else: primes
+    end)
+    |> Enum.reverse()
   end
 
   defp is_prime?(number, primes) do
     Enum.all?(primes, &(rem(number, &1) != 0))
   end
-
-end
+end

data/tracks/elixir/exercises/nth-prime/nth_prime.exs

@@ -1,5 +1,4 @@
 defmodule Prime do
-
   @doc """
   Generates the nth prime.
   """

data/tracks/elixir/exercises/nth-prime/nth_prime_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("nth_prime.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule NthPrimeTest do
   use ExUnit.Case
@@ -30,6 +30,6 @@ defmodule NthPrimeTest do
 
   @tag :pending
   test "weird case" do
-    catch_error Prime.nth(0)
+    catch_error(Prime.nth(0))
   end
 end

data/tracks/elixir/exercises/nucleotide-count/example.exs

@@ -13,10 +13,11 @@ defmodule NucleotideCount do
   1
   """
 
-  def count(strand, nucleotide) when nucleotide in(@nucleotides) do
-    Enum.count strand, &(&1 == nucleotide)
+  def count(strand, nucleotide) when nucleotide in @nucleotides do
+    Enum.count(strand, &(&1 == nucleotide))
   end
-  def count(_strand, _nucleotide), do: raise ArgumentError
+
+  def count(_strand, _nucleotide), do: raise(ArgumentError)
 
   @doc """
   Returns a summary of counts by nucleotide.

data/tracks/elixir/exercises/nucleotide-count/nucleotide_count.exs

@@ -14,10 +14,8 @@ defmodule NucleotideCount do
   """
   @spec count([char], char) :: non_neg_integer
   def count(strand, nucleotide) do
-
   end
 
-
   @doc """
   Returns a summary of counts by nucleotide.
 
@@ -28,6 +26,5 @@ defmodule NucleotideCount do
   """
   @spec histogram([char]) :: map
   def histogram(strand) do
-
   end
 end

data/tracks/elixir/exercises/nucleotide-count/nucleotide_count_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("nucleotide_count.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule NucleotideCountTest do
   use ExUnit.Case

data/tracks/elixir/exercises/ocr-numbers/example.exs

@@ -1,10 +1,9 @@
 defmodule OCRNumbers do
-
   @doc """
   Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is represented, or
   whether it is garbled.
   """
-  @spec convert([String.t]) :: String.t
+  @spec convert([String.t()]) :: String.t()
   def convert(input) do
     Enum.chunk(input, 4)
     |> Enum.map(fn row_set -> _convert(row_set, "") end)
@@ -21,9 +20,10 @@ defmodule OCRNumbers do
   def _convert(_, {:error, _} = error), do: error
   def _convert(input, _) when length(input) != 4, do: {:error, 'invalid line count'}
   def _convert(["", "", "", ""], output), do: output
+
   def _convert(input, output) do
     split_strings = Enum.map(input, fn a -> String.split_at(a, 3) end)
-    this_character = Enum.map(split_strings, fn ({a, _}) -> a end)
+    this_character = Enum.map(split_strings, fn {a, _} -> a end)
     other_characters = Enum.map(split_strings, fn {_, a} -> a end)
     lengths = Enum.map(this_character, fn a -> String.length(a) end)
 

data/tracks/elixir/exercises/ocr-numbers/ocr_numbers.exs

@@ -1,10 +1,9 @@
 defmodule OCRNumbers do
-
   @doc """
   Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is represented, or
   whether it is garbled.
   """
-  @spec convert([String.t]) :: String.t
+  @spec convert([String.t()]) :: String.t()
   def convert(input) do
   end
 end

data/tracks/elixir/exercises/ocr-numbers/ocr_numbers_test.exs

@@ -2,238 +2,223 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("ocr_numbers.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule OCRNumbersTest do
   use ExUnit.Case
 
   # @tag :pending
   test "Recognizes 0" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "| |",
         "|_|",
         "   "
-      ]
-    )
+      ])
+
     assert number == {:ok, "0"}
   end
 
   @tag :pending
   test "Recognizes 1" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "   ",
         "  |",
         "  |",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "1"}
   end
 
   @tag :pending
   test "Unreadable but correctly sized inputs return ?" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "   ",
         "  _",
         "  |",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "?"}
   end
 
   @tag :pending
   test "Input with a number of lines that is not a multiple of four raises an error" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "| |",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:error, 'invalid line count'}
   end
 
   @tag :pending
   test "Input with a number of columns that is not a multiple of three raises an error" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "    ",
         "   |",
         "   |",
         "    "
-      ]
-    )
+      ])
 
     assert number == {:error, 'invalid column count'}
   end
 
   @tag :pending
   test "Recognizes 110101100" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "       _     _        _  _ ",
         "  |  || |  || |  |  || || |",
         "  |  ||_|  ||_|  |  ||_||_|",
         "                           "
-      ]
-    )
+      ])
 
     assert number == {:ok, "110101100"}
   end
 
   @tag :pending
   test "Garbled numbers in a string are replaced with ?" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "       _     _           _ ",
         "  |  || |  || |     || || |",
         "  |  | _|  ||_|  |  ||_||_|",
         "                           "
-      ]
-    )
+      ])
 
     assert number == {:ok, "11?10?1?0"}
   end
 
   @tag :pending
   test "Recognizes 2" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         " _|",
         "|_ ",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "2"}
   end
 
   @tag :pending
   test "Recognizes 3" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         " _|",
         " _|",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "3"}
   end
 
   @tag :pending
   test "Recognizes 4" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "   ",
         "|_|",
         "  |",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "4"}
   end
 
   @tag :pending
   test "Recognizes 5" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "|_ ",
         " _|",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "5"}
   end
 
   @tag :pending
   test "Recognizes 6" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "|_ ",
         "|_|",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "6"}
   end
 
   @tag :pending
   test "Regonizes 7" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "  |",
         "  |",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "7"}
   end
 
   @tag :pending
   test "Recognizes 8" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "|_|",
         "|_|",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "8"}
   end
 
   @tag :pending
   test "Recognizes 9" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         " _ ",
         "|_|",
         " _|",
         "   "
-      ]
-    )
+      ])
 
     assert number == {:ok, "9"}
   end
 
   @tag :pending
   test "Recognizes string of decimal numbers" do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "    _  _     _  _  _  _  _  _ ",
         "  | _| _||_||_ |_   ||_||_|| |",
         "  ||_  _|  | _||_|  ||_| _||_|",
         "                              "
-      ]
-    )
+      ])
 
     assert number == {:ok, "1234567890"}
   end
 
   @tag :pending
   test "Numbers separated by empty lines are recognized. Lines are joined by commas." do
-    number = OCRNumbers.convert(
-      [
+    number =
+      OCRNumbers.convert([
         "    _  _ ",
         "  | _| _|",
         "  ||_  _|",
@@ -246,8 +231,7 @@ defmodule OCRNumbersTest do
         "  ||_||_|",
         "  ||_| _|",
         "         "
-      ]
-    )
+      ])
 
     assert number == {:ok, "123,456,789"}
   end