trackler 2.2.1.109 → 2.2.1.110

data/tracks/elixir/exercises/space-age/example.exs

@@ -1,13 +1,12 @@
 defmodule SpaceAge do
-
-  def age_on(:earth, seconds), do: seconds / 31557600.0
+  def age_on(:earth, seconds), do: seconds / 31_557_600.0
   def age_on(planet, seconds), do: age_on(:earth, seconds) / planet_rel_years(planet)
 
   defp planet_rel_years(:mercury), do: 0.2408467
-  defp planet_rel_years(:venus),   do: 0.61519726
-  defp planet_rel_years(:mars),    do: 1.8808158
+  defp planet_rel_years(:venus), do: 0.61519726
+  defp planet_rel_years(:mars), do: 1.8808158
   defp planet_rel_years(:jupiter), do: 11.862615
-  defp planet_rel_years(:saturn),  do: 29.447498
-  defp planet_rel_years(:uranus),  do: 84.016846
+  defp planet_rel_years(:saturn), do: 29.447498
+  defp planet_rel_years(:uranus), do: 84.016846
   defp planet_rel_years(:neptune), do: 164.79132
 end

data/tracks/elixir/exercises/space-age/space_age.exs

@@ -1,6 +1,13 @@
 defmodule SpaceAge do
-  @type planet :: :mercury | :venus | :earth | :mars | :jupiter
-                | :saturn | :uranus | :neptune
+  @type planet ::
+          :mercury
+          | :venus
+          | :earth
+          | :mars
+          | :jupiter
+          | :saturn
+          | :uranus
+          | :neptune
 
   @doc """
   Return the number of years a person that has lived for 'seconds' seconds is
@@ -8,6 +15,5 @@ defmodule SpaceAge do
   """
   @spec age_on(planet, pos_integer) :: float
   def age_on(planet, seconds) do
-
   end
 end

data/tracks/elixir/exercises/space-age/space_age_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("space_age.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 # You need to define a SpaceAge module containing a function age_on that given a
 # planet (:earth, :saturn, etc) and a number of seconds returns the age in years

data/tracks/elixir/exercises/spiral-matrix/example.exs

@@ -1,19 +1,24 @@
 defmodule Spiral do
-
   @doc """
   Given the dimension, return a square matrix of numbers in clockwise spiral order.
   """
   @spec matrix(dimension :: integer) :: list(list(integer))
   def matrix(0), do: []
+
   def matrix(dimension) do
     unwind(dimension, dimension, 1)
   end
 
   defp unwind(row, col, start) do
     case col do
-      0 -> [[]]
-      _ -> [Enum.to_list(start..start + col - 1) |
-            unwind(col, row - 1, start + col) |> rotate_right]
+      0 ->
+        [[]]
+
+      _ ->
+        [
+          Enum.to_list(start..(start + col - 1))
+          | unwind(col, row - 1, start + col) |> rotate_right
+        ]
     end
   end
 
@@ -22,6 +27,6 @@ defmodule Spiral do
   end
 
   defp transpose(matrix) do
-    matrix |> List.zip |> Enum.map(&Tuple.to_list/1)
+    matrix |> List.zip() |> Enum.map(&Tuple.to_list/1)
   end
 end

data/tracks/elixir/exercises/spiral-matrix/spiral.exs

@@ -1,5 +1,4 @@
 defmodule Spiral do
-
   @doc """
   Given the dimension, return a square matrix of numbers in clockwise spiral order.
   """

data/tracks/elixir/exercises/spiral-matrix/spiral_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("spiral.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure trace: true, exclude: :pending
+ExUnit.start()
+ExUnit.configure(trace: true, exclude: :pending)
 
 defmodule SpiralTest do
   use ExUnit.Case
@@ -15,44 +15,44 @@ defmodule SpiralTest do
 
   @tag :pending
   test "trivial spiral" do
-    assert Spiral.matrix(1) == [ [1] ]
+    assert Spiral.matrix(1) == [[1]]
   end
 
   @tag :pending
   test "spiral of side length 2" do
     assert Spiral.matrix(2) == [
-      [1, 2],
-      [4, 3]
-    ]
+             [1, 2],
+             [4, 3]
+           ]
   end
 
   @tag :pending
   test "spiral of side length 3" do
     assert Spiral.matrix(3) == [
-      [1, 2, 3],
-      [8, 9, 4],
-      [7, 6, 5]
-    ]
+             [1, 2, 3],
+             [8, 9, 4],
+             [7, 6, 5]
+           ]
   end
 
   @tag :pending
   test "spiral of side length 4" do
     assert Spiral.matrix(4) == [
-      [ 1,  2,  3, 4],
-      [12, 13, 14, 5],
-      [11, 16, 15, 6],
-      [10,  9,  8, 7]
-    ]
+             [1, 2, 3, 4],
+             [12, 13, 14, 5],
+             [11, 16, 15, 6],
+             [10, 9, 8, 7]
+           ]
   end
 
   @tag :pending
   test "spiral of size 5" do
     assert Spiral.matrix(5) == [
-      [ 1,  2,  3,  4, 5],
-      [16, 17, 18, 19, 6],
-      [15, 24, 25, 20, 7],
-      [14, 23, 22, 21, 8],
-      [13, 12, 11, 10, 9]
-    ]
+             [1, 2, 3, 4, 5],
+             [16, 17, 18, 19, 6],
+             [15, 24, 25, 20, 7],
+             [14, 23, 22, 21, 8],
+             [13, 12, 11, 10, 9]
+           ]
   end
 end

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

@@ -5,12 +5,13 @@ defmodule Strain do
 
   Do not use `Enum.filter`.
   """
-  @spec keep(list :: list(any), fun :: ((any) -> boolean)) :: list(any)
+  @spec keep(list :: list(any), fun :: (any -> boolean)) :: list(any)
   def keep(list, fun) do
     do_keep(list, fun, [])
   end
 
   defp do_keep([], _, results), do: Enum.reverse(results)
+
   defp do_keep([head | tail], fun, results) do
     case apply(fun, [head]) do
       true -> do_keep(tail, fun, [head | results])
@@ -24,17 +25,17 @@ defmodule Strain do
 
   Do not use `Enum.reject`.
   """
-  @spec discard(list :: list(any), fun :: ((any) -> boolean)) :: list(any)
+  @spec discard(list :: list(any), fun :: (any -> boolean)) :: list(any)
   def discard(list, fun) do
     do_discard(list, fun, [])
   end
 
   defp do_discard([], _, results), do: Enum.reverse(results)
+
   defp do_discard([head | tail], fun, results) do
     case apply(fun, [head]) do
       true -> do_discard(tail, fun, results)
-      _ -> do_discard(tail, fun, [ head | results ])
+      _ -> do_discard(tail, fun, [head | results])
     end
   end
 end
-

data/tracks/elixir/exercises/strain/strain.exs

@@ -5,7 +5,7 @@ defmodule Strain do
 
   Do not use `Enum.filter`.
   """
-  @spec keep(list :: list(any), fun :: ((any) -> boolean)) :: list(any)
+  @spec keep(list :: list(any), fun :: (any -> boolean)) :: list(any)
   def keep(list, fun) do
   end
 
@@ -15,7 +15,7 @@ defmodule Strain do
 
   Do not use `Enum.reject`.
   """
-  @spec discard(list :: list(any), fun :: ((any) -> boolean)) :: list(any)
+  @spec discard(list :: list(any), fun :: (any -> boolean)) :: list(any)
   def discard(list, fun) do
   end
 end

data/tracks/elixir/exercises/strain/strain_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("strain.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure trace: true, exclude: :pending
+ExUnit.start()
+ExUnit.configure(trace: true, exclude: :pending)
 
 defmodule StrainTest do
   use ExUnit.Case
@@ -12,7 +12,7 @@ defmodule StrainTest do
   defp is_even?(n), do: rem(n, 2) == 0
   defp noop(_), do: true
 
-  #@tag :pending
+  # @tag :pending
   test "empty keep" do
     assert Strain.keep([], &noop/1) == []
   end
@@ -35,7 +35,7 @@ defmodule StrainTest do
   @tag :pending
   test "keep strings" do
     words = ~w(apple zebra banana zombies cherimoya zelot)
-    assert Strain.keep(words, &(String.starts_with?(&1, "z"))) == ~w(zebra zombies zelot)
+    assert Strain.keep(words, &String.starts_with?(&1, "z")) == ~w(zebra zombies zelot)
   end
 
   @tag :pending
@@ -50,7 +50,12 @@ defmodule StrainTest do
       [1, 2, 5]
     ]
 
-    assert Strain.keep(rows, fn row -> 5 in row end) == [[5, 5, 5], [5, 1, 2], [1, 5, 2], [1, 2, 5]]
+    assert Strain.keep(rows, fn row -> 5 in row end) == [
+             [5, 5, 5],
+             [5, 1, 2],
+             [1, 5, 2],
+             [1, 2, 5]
+           ]
   end
 
   @tag :pending
@@ -76,7 +81,7 @@ defmodule StrainTest do
   @tag :pending
   test "discard strings" do
     words = ~w(apple zebra banana zombies cherimoya zelot)
-    assert Strain.discard(words, &(String.starts_with?(&1, "z"))) == ~w(apple banana cherimoya)
+    assert Strain.discard(words, &String.starts_with?(&1, "z")) == ~w(apple banana cherimoya)
   end
 
   @tag :pending
@@ -90,7 +95,7 @@ defmodule StrainTest do
       [2, 2, 1],
       [1, 2, 5]
     ]
+
     assert Strain.discard(rows, fn row -> 5 in row end) == [[1, 2, 3], [2, 1, 2], [2, 2, 1]]
   end
 end
-

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

@@ -4,27 +4,31 @@ defmodule Sublist do
   and if not whether it is equal or unequal to the second list.
   """
   def compare(a, b) do
-    case { length(a), length(b) } do
-      { la, lb } when la < lb ->
+    case {length(a), length(b)} do
+      {la, lb} when la < lb ->
         if is_sublist(a, b, la, lb), do: :sublist, else: :unequal
-      { la, lb } when la > lb ->
+
+      {la, lb} when la > lb ->
         if is_sublist(b, a, lb, la), do: :superlist, else: :unequal
+
       _ ->
         if a == b, do: :equal, else: :unequal
     end
   end
 
   defp is_sublist(_, _, len_a, len_b) when len_a > len_b, do: false
-  defp is_sublist([], _, _, _), do: true  # empty is sublist of all non-empty
-  defp is_sublist(a, b=[_|t], len_a, len_b) do
+  # empty is sublist of all non-empty
+  defp is_sublist([], _, _, _), do: true
+
+  defp is_sublist(a, b = [_ | t], len_a, len_b) do
     if try_is_sublist(a, b) do
       true
     else
-      is_sublist(a, t, len_a, len_b-1)
+      is_sublist(a, t, len_a, len_b - 1)
     end
   end
 
   defp try_is_sublist([], _), do: true
-  defp try_is_sublist([x|at], [x|bt]), do: try_is_sublist(at, bt)
+  defp try_is_sublist([x | at], [x | bt]), do: try_is_sublist(at, bt)
   defp try_is_sublist(_, _), do: false
 end

data/tracks/elixir/exercises/sublist/sublist.exs

@@ -4,6 +4,5 @@ defmodule Sublist do
   and if not whether it is equal or unequal to the second list.
   """
   def compare(a, b) do
-
   end
 end

data/tracks/elixir/exercises/sublist/sublist_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("sublist.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule SublistTest do
   use ExUnit.Case
@@ -35,64 +35,62 @@ defmodule SublistTest do
 
   @tag :pending
   test "sublist at start" do
-    assert Sublist.compare([1,2,3],[1,2,3,4,5]) == :sublist
+    assert Sublist.compare([1, 2, 3], [1, 2, 3, 4, 5]) == :sublist
   end
 
   @tag :pending
   test "sublist in middle" do
-    assert Sublist.compare([4,3,2],[5,4,3,2,1]) == :sublist
+    assert Sublist.compare([4, 3, 2], [5, 4, 3, 2, 1]) == :sublist
   end
 
   @tag :pending
   test "sublist at end" do
-    assert Sublist.compare([3,4,5],[1,2,3,4,5]) == :sublist
+    assert Sublist.compare([3, 4, 5], [1, 2, 3, 4, 5]) == :sublist
   end
 
   @tag :pending
   test "partially matching sublist at start" do
-    assert Sublist.compare([1,1,2], [1,1,1,2]) == :sublist
+    assert Sublist.compare([1, 1, 2], [1, 1, 1, 2]) == :sublist
   end
 
   @tag :pending
   test "sublist early in huge list" do
-    assert Sublist.compare([3,4,5], Enum.to_list(1..1_000_000)) == :sublist
+    assert Sublist.compare([3, 4, 5], Enum.to_list(1..1_000_000)) == :sublist
   end
 
   @tag :pending
   test "huge sublist not in huge list" do
-    assert Sublist.compare(Enum.to_list(10..1_000_001),
-                           Enum.to_list(1..1_000_000))
-           == :unequal
+    assert Sublist.compare(Enum.to_list(10..1_000_001), Enum.to_list(1..1_000_000)) == :unequal
   end
 
   @tag :pending
   test "superlist at start" do
-    assert Sublist.compare([1,2,3,4,5],[1,2,3]) == :superlist
+    assert Sublist.compare([1, 2, 3, 4, 5], [1, 2, 3]) == :superlist
   end
 
   @tag :pending
   test "superlist in middle" do
-    assert Sublist.compare([5,4,3,2,1],[4,3,2]) == :superlist
+    assert Sublist.compare([5, 4, 3, 2, 1], [4, 3, 2]) == :superlist
   end
 
   @tag :pending
   test "superlist at end" do
-    assert Sublist.compare([1,2,3,4,5],[3,4,5]) == :superlist
+    assert Sublist.compare([1, 2, 3, 4, 5], [3, 4, 5]) == :superlist
   end
 
   @tag :pending
   test "1 and 2 does not contain 3" do
-    assert Sublist.compare([1,2], [3]) == :unequal
+    assert Sublist.compare([1, 2], [3]) == :unequal
   end
 
   @tag :pending
   test "partially matching superlist at start" do
-    assert Sublist.compare([1,1,1,2], [1,1,2]) == :superlist
+    assert Sublist.compare([1, 1, 1, 2], [1, 1, 2]) == :superlist
   end
 
   @tag :pending
   test "superlist early in huge list" do
-    assert Sublist.compare(Enum.to_list(1..1_000_000), [3,4,5]) == :superlist
+    assert Sublist.compare(Enum.to_list(1..1_000_000), [3, 4, 5]) == :superlist
   end
 
   @tag :pending
@@ -102,11 +100,11 @@ defmodule SublistTest do
 
   @tag :pending
   test "recurring values sublist" do
-    assert Sublist.compare([1,2,1,2,3], [1,2,3,1,2,1,2,3,2,1]) == :sublist
+    assert Sublist.compare([1, 2, 1, 2, 3], [1, 2, 3, 1, 2, 1, 2, 3, 2, 1]) == :sublist
   end
 
   @tag :pending
   test "recurring values unequal" do
-    assert Sublist.compare([1,2,1,2,3], [1,2,3,1,2,3,2,3,2,1]) == :unequal
+    assert Sublist.compare([1, 2, 1, 2, 3], [1, 2, 3, 1, 2, 3, 2, 3, 2, 1]) == :unequal
   end
 end

data/tracks/elixir/exercises/sum-of-multiples/example.exs

@@ -1,12 +1,11 @@
 defmodule SumOfMultiples do
-
   @doc """
   Adds up all numbers from 1 to a given end number that are multiples of the factors provided.
   """
   @spec to(non_neg_integer, [non_neg_integer]) :: non_neg_integer
   def to(limit, factors) do
-    Enum.reduce(1..limit-1, 0, fn(n, acc) ->
-      if Enum.any?(factors, &(rem(n, &1) == 0)), do: acc + n, else: acc end)
+    Enum.reduce(1..(limit - 1), 0, fn n, acc ->
+      if Enum.any?(factors, &(rem(n, &1) == 0)), do: acc + n, else: acc
+    end)
   end
-
 end