trackler 2.2.1.109 → 2.2.1.110

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

@@ -11,8 +11,9 @@ defmodule Hamming do
     distance = pairs(strand1, strand2) |> count_mismatched
     {:ok, distance}
   end
+
   def hamming_distance(_, _), do: {:error, "Lists must be the same length"}
 
-  defp pairs(s1, s2),           do: Enum.zip(s1, s2)
-  defp count_mismatched(pairs), do: Enum.count(pairs, fn({c1, c2}) -> c2 && (c1 != c2) end)
+  defp pairs(s1, s2), do: Enum.zip(s1, s2)
+  defp count_mismatched(pairs), do: Enum.count(pairs, fn {c1, c2} -> c2 && c1 != c2 end)
 end

data/tracks/elixir/exercises/hamming/hamming_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("hamming.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule HammingTest do
   use ExUnit.Case
@@ -34,7 +34,10 @@ defmodule HammingTest do
 
   @tag :pending
   test "hamming distance is undefined for strands of different lengths" do
-    assert {:error, "Lists must be the same length"} = Hamming.hamming_distance('AAAC', 'TAGGGGAGGCTAGCGGTAGGAC')
-    assert {:error, "Lists must be the same length"} = Hamming.hamming_distance('GACTACGGACAGGACACC', 'GACATCGC')
+    assert {:error, "Lists must be the same length"} =
+             Hamming.hamming_distance('AAAC', 'TAGGGGAGGCTAGCGGTAGGAC')
+
+    assert {:error, "Lists must be the same length"} =
+             Hamming.hamming_distance('GACTACGGACAGGACACC', 'GACATCGC')
   end
 end

data/tracks/elixir/exercises/hello-world/example.exs

@@ -6,4 +6,4 @@ defmodule HelloWorld do
   def hello do
     "Hello, World!"
   end
- end
+end

data/tracks/elixir/exercises/hello-world/hello_world.exs

@@ -2,7 +2,7 @@ defmodule HelloWorld do
   @doc """
   Simply returns "Hello, World!"
   """
-  @spec hello :: String.t
+  @spec hello :: String.t()
   def hello do
     "Your implementation goes here"
   end

data/tracks/elixir/exercises/hello-world/hello_world_test.exs

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

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

@@ -1,8 +1,8 @@
 defmodule Hexadecimal do
   @base 16
   @hex_table String.split("0123456789abcdef", "", trim: true)
-               |> Enum.with_index
-               |> Enum.into(%{})
+             |> Enum.with_index()
+             |> Enum.into(%{})
 
   @doc """
     Accept a string representing a hexadecimal value and return the
@@ -26,10 +26,10 @@ defmodule Hexadecimal do
       0
     else
       hex
-        |> String.downcase
-        |> String.reverse
-        |> String.split("", trim: true)
-        |> hex_to_int(0, 0)
+      |> String.downcase()
+      |> String.reverse()
+      |> String.split("", trim: true)
+      |> hex_to_int(0, 0)
     end
   end
 
@@ -38,7 +38,8 @@ defmodule Hexadecimal do
   end
 
   defp hex_to_int([], acc, _), do: round(acc)
-  defp hex_to_int([char|hex], acc, power) do
+
+  defp hex_to_int([char | hex], acc, power) do
     acc = acc + Map.get(@hex_table, char) * :math.pow(@base, power)
     hex_to_int(hex, acc, power + 1)
   end

data/tracks/elixir/exercises/hexadecimal/hexadecimal.exs

@@ -17,6 +17,5 @@ defmodule Hexadecimal do
 
   @spec to_decimal(binary) :: integer
   def to_decimal(hex) do
-
   end
 end

data/tracks/elixir/exercises/hexadecimal/hexadecimal_test.exs

@@ -2,14 +2,14 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("hexadecimal.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule HexadecimalTest do
   use ExUnit.Case
 
   test "returns 1 when hex is 1" do
-    assert Hexadecimal.to_decimal("1") ==  1
+    assert Hexadecimal.to_decimal("1") == 1
   end
 
   @tag :pending

data/tracks/elixir/exercises/isbn-verifier/example.exs

@@ -33,4 +33,4 @@ defmodule ISBNVerifier do
   defp checksum_weighting({digit, weight}) do
     String.to_integer(digit) * weight
   end
-end
+end

data/tracks/elixir/exercises/isbn-verifier/isbn_verifier.exs

@@ -13,6 +13,5 @@ defmodule ISBNVerifier do
   """
   @spec isbn?(String.t()) :: boolean
   def isbn?(isbn) do
-
   end
-end
+end

data/tracks/elixir/exercises/isbn-verifier/isbn_verifier_test.exs

@@ -8,7 +8,7 @@ ExUnit.configure(exclude: :pending, trace: true)
 defmodule ISBNVerifierTest do
   use ExUnit.Case
 
-  #@tag :pending
+  # @tag :pending
   test "valid isbn number" do
     assert ISBNVerifier.isbn?("3-598-21508-8")
   end
@@ -72,4 +72,4 @@ defmodule ISBNVerifierTest do
   test "check digit of X should not be used for 0" do
     refute ISBNVerifier.isbn?("3-598-21515-X")
   end
-end
+end

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

@@ -2,14 +2,14 @@ defmodule Isogram do
   @doc """
   Determines if a word or sentence is an isogram
   """
-  @spec isogram?(String.t) :: boolean
+  @spec isogram?(String.t()) :: boolean
   def isogram?(sentence) do
-    codepoints = sentence
-      |> String.downcase
+    codepoints =
+      sentence
+      |> String.downcase()
       |> String.replace(~r/\s|-/u, "")
-      |> String.codepoints
+      |> String.codepoints()
 
     length(Enum.uniq(codepoints)) == length(codepoints)
   end
-
 end

data/tracks/elixir/exercises/isogram/isogram.exs

@@ -2,9 +2,7 @@ defmodule Isogram do
   @doc """
   Determines if a word or sentence is an isogram
   """
-  @spec isogram?(String.t) :: boolean
+  @spec isogram?(String.t()) :: boolean
   def isogram?(sentence) do
-
   end
-
 end

data/tracks/elixir/exercises/isogram/isogram_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("isogram.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule IsogramTest do
   use ExUnit.Case
@@ -46,5 +46,4 @@ defmodule IsogramTest do
   test "phrase is not isogram" do
     refute Isogram.isogram?("the quick brown fox")
   end
-
 end

data/tracks/elixir/exercises/kindergarten-garden/example.exs

@@ -1,6 +1,18 @@
 defmodule Garden do
-  @default_names [:alice, :bob, :charlie, :david, :eve, :fred, :ginny, :harriet,
-                  :ileana, :joseph, :kincaid, :larry]
+  @default_names [
+    :alice,
+    :bob,
+    :charlie,
+    :david,
+    :eve,
+    :fred,
+    :ginny,
+    :harriet,
+    :ileana,
+    :joseph,
+    :kincaid,
+    :larry
+  ]
   @letter_map %{"V" => :violets, "R" => :radishes, "C" => :clover, "G" => :grass}
 
   @doc """
@@ -46,7 +58,7 @@ defmodule Garden do
 
   defp add_to_map(map, current_name, letters) do
     letters = String.codepoints(letters)
-    translated_list = Enum.map(letters, fn(letter) -> @letter_map[letter] end)
+    translated_list = Enum.map(letters, fn letter -> @letter_map[letter] end)
     tuple = List.to_tuple(translated_list)
     Map.put(map, current_name, tuple)
   end

data/tracks/elixir/exercises/kindergarten-garden/garden_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("garden.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule GardenTest do
   use ExUnit.Case
@@ -57,8 +57,21 @@ defmodule GardenTest do
 
   @tag :pending
   test "gets the garden for all students with custom child names" do
-    names = [:maggie, :nate, :xander, :ophelia, :pete, :reggie, :sylvia,
-             :tanner, :ursula, :victor, :winnie, :ynold]
+    names = [
+      :maggie,
+      :nate,
+      :xander,
+      :ophelia,
+      :pete,
+      :reggie,
+      :sylvia,
+      :tanner,
+      :ursula,
+      :victor,
+      :winnie,
+      :ynold
+    ]
+
     garden_string = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV"
     garden_info = Garden.info(garden_string, names)
     assert garden_info.maggie == {:violets, :radishes, :violets, :radishes}

data/tracks/elixir/exercises/largest-series-product/example.exs

@@ -1,17 +1,16 @@
 defmodule Series do
-
-  @spec digits(String.t) :: [non_neg_integer]
+  @spec digits(String.t()) :: [non_neg_integer]
   defp digits("") do
     []
   end
 
   defp digits(number_string) do
     String.split(number_string, "", trim: true)
-    |> Enum.reduce([], fn(char, acc) -> [String.to_integer(char)|acc] end)
-    |> Enum.reverse
+    |> Enum.reduce([], fn char, acc -> [String.to_integer(char) | acc] end)
+    |> Enum.reverse()
   end
 
-  @spec slices(String.t, non_neg_integer) :: [list(non_neg_integer)]
+  @spec slices(String.t(), non_neg_integer) :: [list(non_neg_integer)]
   defp slices(number_string, size) do
     digits = digits(number_string)
     chunk(digits, size, 1)
@@ -20,7 +19,7 @@ defmodule Series do
   @doc """
   Finds the largest product of a given number of consecutive numbers in a given string of numbers.
   """
-  @spec largest_product(String.t, non_neg_integer) :: non_neg_integer
+  @spec largest_product(String.t(), non_neg_integer) :: non_neg_integer
   def largest_product(_, 0) do
     1
   end
@@ -29,13 +28,15 @@ defmodule Series do
     unless Enum.member?(Range.new(0, String.length(number_string)), size) do
       raise ArgumentError
     end
+
     slices = slices(number_string, size)
-    Enum.map(slices, &Enum.reduce(&1, fn(x, acc) -> x * acc end))
-    |> Enum.max
+
+    Enum.map(slices, &Enum.reduce(&1, fn x, acc -> x * acc end))
+    |> Enum.max()
   end
 
   # Handle Enum.chunks -> Enum.chunk renaming.
-  if not { :chunk, 3 } in Enum.__info__(:functions) do
+  if not ({:chunk, 3} in Enum.__info__(:functions)) do
     defp chunk(coll, n, step), do: Enum.chunks(coll, n, step)
   else
     defp chunk(coll, n, step), do: Enum.chunk(coll, n, step)

data/tracks/elixir/exercises/largest-series-product/largest_series_product.exs

@@ -1,10 +1,8 @@
 defmodule Series do
-
   @doc """
   Finds the largest product of a given number of consecutive numbers in a given string of numbers.
   """
-  @spec largest_product(String.t, non_neg_integer) :: non_neg_integer
+  @spec largest_product(String.t(), non_neg_integer) :: non_neg_integer
   def largest_product(number_string, size) do
-
   end
 end

data/tracks/elixir/exercises/largest-series-product/largest_series_product_test.exs

@@ -2,8 +2,8 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
   Code.load_file("largest_series_product.exs", __DIR__)
 end
 
-ExUnit.start
-ExUnit.configure exclude: :pending, trace: true
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
 
 defmodule LargestSeriesProductTest do
   use ExUnit.Case
@@ -45,12 +45,14 @@ defmodule LargestSeriesProductTest do
 
   @tag :pending
   test "some big number" do
-    assert Series.largest_product("73167176531330624919225119674426574742355349194934", 6) == 23520
+    assert Series.largest_product("73167176531330624919225119674426574742355349194934", 6) ==
+             23520
   end
 
   @tag :pending
   test "some other big number" do
-    assert Series.largest_product("52677741234314237566414902593461595376319419139427", 6) == 28350
+    assert Series.largest_product("52677741234314237566414902593461595376319419139427", 6) ==
+             28350
   end
 
   @tag :pending

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

@@ -1,10 +1,10 @@
 defmodule Year do
   def leap_year?(year) do
-    div4?(year) && (div100?(year) == div400?(year))
+    div4?(year) && div100?(year) == div400?(year)
   end
 
   defp divides?(dividend, divisor), do: rem(dividend, divisor) == 0
-  defp div4?(dividend),   do: divides?(dividend, 4)
+  defp div4?(dividend), do: divides?(dividend, 4)
   defp div100?(dividend), do: divides?(dividend, 100)
   defp div400?(dividend), do: divides?(dividend, 400)
 end

data/tracks/elixir/exercises/leap/leap.exs

@@ -10,6 +10,5 @@ defmodule Year do
   """
   @spec leap_year?(non_neg_integer) :: boolean
   def leap_year?(year) do
-
   end
 end

data/tracks/elixir/exercises/leap/leap_test.exs

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

data/tracks/elixir/exercises/list-ops/example.exs

@@ -10,43 +10,44 @@ defmodule ListOps do
   def count(l), do: do_count(l, 0)
 
   defp do_count([], acc), do: acc
-  defp do_count([_|t], acc), do: do_count(t, acc+1)
+  defp do_count([_ | t], acc), do: do_count(t, acc + 1)
 
   @spec reverse(list) :: list
   def reverse(l), do: do_reverse(l, [])
 
   defp do_reverse([], acc), do: acc
-  defp do_reverse([h|t], acc), do: do_reverse(t, [h|acc])
+  defp do_reverse([h | t], acc), do: do_reverse(t, [h | acc])
 
   @spec map(list, (any -> any)) :: list
   def map(l, f), do: do_map(l, f, []) |> reverse()
 
   defp do_map([], _, acc), do: acc
-  defp do_map([h|t], f, acc), do: do_map(t, f, [f.(h)|acc])
+  defp do_map([h | t], f, acc), do: do_map(t, f, [f.(h) | acc])
 
   @spec filter(list, (any -> as_boolean(term))) :: list
   def filter(l, f), do: do_filter(l, f, []) |> reverse()
 
   defp do_filter([], _, acc), do: acc
-  defp do_filter([h|t], f, acc) do
+
+  defp do_filter([h | t], f, acc) do
     if f.(h) do
-      do_filter(t, f, [h|acc])
+      do_filter(t, f, [h | acc])
     else
       do_filter(t, f, acc)
     end
   end
 
   @type acc :: any
-  @spec reduce(list, acc, ((any, acc) -> acc)) :: acc
+  @spec reduce(list, acc, (any, acc -> acc)) :: acc
   def reduce([], acc, _), do: acc
-  def reduce([h|t], acc, f), do: reduce(t, f.(h, acc), f)
+  def reduce([h | t], acc, f), do: reduce(t, f.(h, acc), f)
 
   @spec append(list, list) :: list
   def append(a, b), do: do_append(reverse(a), b)
 
   defp do_append([], b), do: b
-  defp do_append([h|t], b), do: do_append(t, [h|b])
+  defp do_append([h | t], b), do: do_append(t, [h | b])
 
   @spec concat([[any]]) :: [any]
-  def concat(ll), do: reverse(ll) |> reduce([], &(append(&1, &2)))
+  def concat(ll), do: reverse(ll) |> reduce([], &append(&1, &2))
 end