trackler 2.2.1.46 → 2.2.1.47

data/tracks/ecmascript/exercises/wordy/package.json

@@ -39,7 +39,7 @@
       ],
       ["transform-regenerator"]
     ]
-},
+  },
   "scripts": {
     "test": "jest --no-cache ./*",
     "watch": "jest --no-cache --watch ./*",

data/tracks/ecmascript/package.json

@@ -39,7 +39,7 @@
       ],
       ["transform-regenerator"]
     ]
-},
+  },
   "scripts": {
     "test": "jest --no-cache ./*",
     "watch": "jest --no-cache --watch ./*",

data/tracks/elixir/config.json

@@ -889,6 +889,17 @@
         "Algorithms",
         "Sorting"
       ]
+    },
+    {
+      "uuid": "ce270a34-add1-422c-bb86-53b310f05e27",
+      "slug": "transpose",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 5,
+      "topics": [
+        "Strings",
+        "Transforming"
+      ]
     }
   ],
   "foregone": [

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

@@ -1,59 +1,39 @@
 defmodule Luhn do
-  @doc """
-  Calculates the total checksum of a number
-  """
-  @spec checksum(String.t()) :: integer
-  def checksum(number) do
-    number
-    |> String.reverse
-    |> String.graphemes
-    |> Enum.with_index
-    |> Enum.map(&do_checksum/1)
-    |> Enum.sum
-  end
-
-  defp do_checksum({digit, index}) do
-    digit
-    |> String.to_integer
-    |> double_if_even_index(index)
-    |> compact
-  end
-
-  defp compact(num) when num < 10, do: num
-  defp compact(num) do
-    num
-    |> Integer.digits
-    |> Enum.sum
-    |> compact
-  end
 
   @doc """
   Checks if the given number is valid via the luhn formula
   """
   @spec valid?(String.t()) :: boolean
   def valid?(number) do
-    number |> checksum |> rem(10) == 0
+    number_without_spaces = String.replace(number, " ", "")
+    case Integer.parse(number_without_spaces) do
+      {_, ""} ->
+        String.length(number_without_spaces) > 1 && checksum(number_without_spaces)
+      _ ->
+        false
+    end
   end
 
-  @doc """
-  Creates a valid number by adding the correct
-  checksum digit to the end of the number
-  """
-  @spec create(String.t()) :: String.t()
-  def create(number) do
-    number <> do_create(number)
-  end
-
-  defp do_create(number) do
-    number <> "0"
-    |> checksum
+  defp checksum(number) do
+    0 == number
+    |> String.graphemes()
+    |> Enum.map(&String.to_integer/1)
+    |> double_even()
+    |> Enum.sum()
     |> rem(10)
-    |> (&(10 - &1)).()
-    |> to_string
-    |> String.last
   end
 
-  defp double_if_even_index(n, index) do
-    if rem(index, 2) == 0, do: n, else: n * 2
+  defp double_even(numlist) do
+    numlist
+    |> Enum.reverse()
+    |> Enum.zip(Stream.cycle([1,2]))
+    |> Enum.map(fn {n,m} -> n * m  end)
+    |> Enum.map(
+      fn
+        n when n > 9 -> n-9
+        n -> n
+      end)
+
   end
-end
+
+end

data/tracks/elixir/exercises/luhn/luhn.exs

@@ -1,10 +1,4 @@
 defmodule Luhn do
-  @doc """
-  Calculates the total checksum of a number
-  """
-  @spec checksum(String.t()) :: integer
-  def checksum(number) do
-  end
 
   @doc """
   Checks if the given number is valid via the luhn formula
@@ -13,11 +7,4 @@ defmodule Luhn do
   def valid?(number) do
   end
 
-  @doc """
-  Creates a valid number by adding the correct
-  checksum digit to the end of the number
-  """
-  @spec create(String.t()) :: String.t()
-  def create(number) do
-  end
 end

data/tracks/elixir/exercises/luhn/luhn_test.exs

@@ -8,37 +8,67 @@ ExUnit.configure exclude: :pending, trace: true
 defmodule LuhnTest do
   use ExUnit.Case
 
-  test "checksum" do
-    assert Luhn.checksum("4913") == 22
+  test "single digit strings can not be valid" do
+    refute Luhn.valid?("1")
   end
 
   @tag :pending
-  test "checksum again" do
-    assert Luhn.checksum("201773") == 21
+  test "A single zero is invalid" do
+    refute Luhn.valid?("0")
   end
 
   @tag :pending
-  test "invalid number" do
-    assert Luhn.valid?("738") == false
+  test "a simple valid SIN that remains valid if reversed" do
+    assert Luhn.valid?("059")
   end
 
   @tag :pending
-  test "valid number" do
-    assert Luhn.valid?("8739567") == true
+  test "a simple valid SIN that becomes invalid if reversed" do
+    assert Luhn.valid?("59")
   end
 
   @tag :pending
-  test "create valid number" do
-    assert Luhn.create("123") == "1230"
+  test "a valid Canadian SIN" do
+    assert Luhn.valid?("055 444 285")
   end
 
   @tag :pending
-  test "create other valid number" do
-    assert Luhn.create("873956") == "8739567"
+  test "invalid Canadian SIN" do
+    refute Luhn.valid?("055 444 286")
   end
 
   @tag :pending
-  test "create yet another valid number" do
-    assert Luhn.create("837263756") == "8372637564"
+  test "invalid credit card" do
+    refute Luhn.valid?("8273 1232 7352 0569")
+  end
+
+  @tag :pending
+  test "valid strings with a non-digit included become invalid" do
+    refute Luhn.valid?("055a 444 285")
+  end
+
+  @tag :pending
+  test "valid strings with punctuation included become invalid" do
+    refute Luhn.valid?("055-444-285")
+  end
+
+  @tag :pending
+  test "valid strings with symbols included become invalid" do
+    refute Luhn.valid?("055£ 444$ 285")
+  end
+
+  @tag :pending
+  test "single zero with space is invalid" do
+    refute Luhn.valid?(" 0")
+  end
+
+  @tag :pending
+  test "more than a single zero is valid" do
+    assert Luhn.valid?("0000 0")
+  end
+
+  @tag :pending
+  test "input digit 9 is correctly converted to output digit 9" do
+    assert Luhn.valid?("091")
   end
 end

data/tracks/elixir/exercises/transpose/README.md

@@ -0,0 +1,101 @@
+# Transpose
+
+Given an input text output it transposed.
+
+Roughly explained, the transpose of a matrix:
+
+```text
+ABC
+DEF
+```
+
+is given by:
+
+```text
+AD
+BE
+CF
+```
+
+Rows become columns and columns become rows. See <https://en.wikipedia.org/wiki/Transpose>.
+
+If the input has rows of different lengths, this is to be solved as follows:
+
+- Pad to the left with spaces.
+- Don't pad to the right.
+
+Therefore, transposing this matrix:
+
+```text
+ABC
+DE
+```
+
+results in:
+
+```text
+AD
+BE
+C
+```
+
+And transposing:
+
+```text
+AB
+DEF
+```
+
+results in:
+
+```text
+AD
+BE
+ F
+```
+
+In general, all characters from the input should also be present in the transposed output.
+That means that if a column in the input text contains only spaces on its bottom-most row(s),
+the corresponding output row should contain the spaces in its right-most column(s).
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir transpose_test.exs
+```
+
+### Pending tests
+
+In the test suites, all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+commenting out the relevant `@tag :pending` with a `#` symbol.
+
+For example:
+
+```elixir
+# @tag :pending
+test "two characters in a row" do
+  input= "AB"
+  expected =
+    "A\n" <>
+    "B"
+
+  assert Transpose.transpose(input) == expected
+end
+```
+
+Or, you can enable all the tests by commenting out the
+`ExUnit.configure` line in the test suite.
+
+```elixir
+# ExUnit.configure exclude: :pending, trace: true
+```
+
+For more detailed information about the Elixir track, please
+see the [help page](http://exercism.io/languages/elixir).
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,46 @@
+defmodule Transpose do
+  @doc """
+  Given an input text, output it transposed.
+
+  Rows become columns and columns become rows. See https://en.wikipedia.org/wiki/Transpose.
+
+  If the input has rows of different lengths, this is to be solved as follows:
+    * Pad to the left with spaces.
+    * Don't pad to the right.
+
+  ## Examples
+  iex> Transpose.transpose("ABC\nDE")
+  "AD\nBE\nC"
+
+  iex> Transpose.transpose("AB\nDEF")
+  "AD\nBE\n F"
+  """
+
+  @spec transpose(String.t) :: String.t
+  def transpose(matrix) do
+    rows = String.split(matrix, "\n")
+
+    max_length = get_longest_row_length(rows)
+
+    rows
+    |> Enum.map(fn x -> get_padded_row(x, max_length) end)
+    |> Enum.map(fn x -> String.to_charlist(x) end)
+    |> List.zip
+    |> Enum.map(fn x -> Tuple.to_list(x) end)
+    |> Enum.map(fn x -> List.to_string(x) end)
+    |> Enum.map(fn x -> String.replace(x, "*", " ") end)
+    |> Enum.join("\n")
+    |> String.trim_trailing
+  end
+
+  defp get_longest_row_length(rows) do
+    rows
+    |> Enum.map(fn row -> String.length(row) end)
+    |> Enum.max
+  end
+
+  defp get_padded_row(row, max_length) do
+    padding = String.duplicate("*", max_length - String.length(row))
+    row <> padding
+  end
+end

data/tracks/elixir/exercises/transpose/transpose.exs

@@ -0,0 +1,22 @@
+defmodule Transpose do
+  @doc """
+  Given an input text, output it transposed.
+
+  Rows become columns and columns become rows. See https://en.wikipedia.org/wiki/Transpose.
+
+  If the input has rows of different lengths, this is to be solved as follows:
+    * Pad to the left with spaces.
+    * Don't pad to the right.
+
+  ## Examples
+  iex> Transpose.transpose("ABC\nDE")
+  "AD\nBE\nC"
+
+  iex> Transpose.transpose("AB\nDEF")
+  "AD\nBE\n F"
+  """
+
+  @spec transpose(String.t) :: String.t
+  def transpose(input) do
+  end
+end

data/tracks/elixir/exercises/transpose/transpose_test.exs

@@ -0,0 +1,248 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("transpose.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule TransposeTest do
+  use ExUnit.Case
+
+  test "empty string" do
+    input = ""
+    expected = ""
+
+    assert Transpose.transpose(input) == expected
+  end
+
+  @tag :pending
+  test "two characters in a row" do
+    input= "AB"
+    expected =
+      "A\n" <>
+      "B"
+
+    assert Transpose.transpose(input) == expected
+  end
+
+  @tag :pending
+  test "two characters in one column" do
+    input=
+      "A\n" <>
+      "B"
+
+    expected = "AB"
+
+    assert Transpose.transpose(input) == expected
+  end
+
+  @tag :pending
+  test "single line" do
+    input = "Single line."
+
+    expected =
+      "S\n" <>
+      "i\n" <>
+      "n\n" <>
+      "g\n" <>
+      "l\n" <>
+      "e\n" <>
+      " \n" <>
+      "l\n" <>
+      "i\n" <>
+      "n\n" <>
+      "e\n" <>
+      "."
+
+      assert Transpose.transpose(input) == expected
+  end
+
+  @tag :pending
+  test "first line longer than second line" do
+    input = "The fourth line.\n" <>
+            "The fifth line."
+
+      expected =
+        "TT\n" <>
+        "hh\n" <>
+        "ee\n" <>
+        "  \n" <>
+        "ff\n" <>
+        "oi\n" <>
+        "uf\n" <>
+        "rt\n" <>
+        "th\n" <>
+        "h \n" <>
+        " l\n" <>
+        "li\n" <>
+        "in\n" <>
+        "ne\n" <>
+        "e.\n" <>
+        "."
+
+      assert Transpose.transpose(input) == expected
+  end
+
+  @tag :pending
+  test "second line longer than first line" do
+    input = "The first line.\n" <>
+            "The second line."
+
+      expected =
+        "TT\n" <>
+        "hh\n" <>
+        "ee\n" <>
+        "  \n" <>
+        "fs\n" <>
+        "ie\n" <>
+        "rc\n" <>
+        "so\n" <>
+        "tn\n" <>
+        " d\n" <>
+        "l \n" <>
+        "il\n" <>
+        "ni\n" <>
+        "en\n" <>
+        ".e\n" <>
+        " ."
+
+      assert Transpose.transpose(input) == expected
+  end
+
+  @tag :pending
+  test "square" do
+    matrix =
+      "HEART\n" <>
+      "EMBER\n" <>
+      "ABUSE\n" <>
+      "RESIN\n" <>
+      "TREND"
+
+    expected =
+      "HEART\n" <>
+      "EMBER\n" <>
+      "ABUSE\n" <>
+      "RESIN\n" <>
+      "TREND"
+
+    assert Transpose.transpose(matrix) == expected
+  end
+
+  @tag :pending
+  test "rectangle" do
+    matrix =
+      "FRACTURE\n" <>
+      "OUTLINED\n" <>
+      "BLOOMING\n" <>
+      "SEPTETTE"
+
+    expected =
+      "FOBS\n" <>
+      "RULE\n" <>
+      "ATOP\n" <>
+      "CLOT\n" <>
+      "TIME\n" <>
+      "UNIT\n" <>
+      "RENT\n" <>
+      "EDGE"
+
+    assert Transpose.transpose(matrix) == expected
+  end
+
+  @tag :pending
+  test "triangle" do
+    matrix =
+      "T\n" <>
+      "EE\n" <>
+      "AAA\n" <>
+      "SSSS\n" <>
+      "EEEEE\n" <>
+      "RRRRRR"
+
+    expected =
+      "TEASER\n" <>
+      " EASER\n" <>
+      "  ASER\n" <>
+      "   SER\n" <>
+      "    ER\n" <>
+      "     R"
+
+    assert Transpose.transpose(matrix) == expected
+  end
+
+  @tag :pending
+  test "many lines" do
+    matrix =
+      "Chor. Two households, both alike in dignity,\n" <>
+      "In fair Verona, where we lay our scene,\n" <>
+      "From ancient grudge break to new mutiny,\n" <>
+      "Where civil blood makes civil hands unclean.\n" <>
+      "From forth the fatal loins of these two foes\n" <>
+      "A pair of star-cross'd lovers take their life;\n" <>
+      "Whose misadventur'd piteous overthrows\n" <>
+      "Doth with their death bury their parents' strife.\n" <>
+      "The fearful passage of their death-mark'd love,\n" <>
+      "And the continuance of their parents' rage,\n" <>
+      "Which, but their children's end, naught could remove,\n" <>
+      "Is now the two hours' traffic of our stage;\n" <>
+      "The which if you with patient ears attend,\n" <>
+      "What here shall miss, our toil shall strive to mend."
+
+    expected =
+      "CIFWFAWDTAWITW\n" <>
+      "hnrhr hohnhshh\n" <>
+      "o oeopotedi ea\n" <>
+      "rfmrmash  cn t\n" <>
+      ".a e ie fthow \n" <>
+      " ia fr weh,whh\n" <>
+      "Trnco miae  ie\n" <>
+      "w ciroitr btcr\n" <>
+      "oVivtfshfcuhhe\n" <>
+      " eeih a uote  \n" <>
+      "hrnl sdtln  is\n" <>
+      "oot ttvh tttfh\n" <>
+      "un bhaeepihw a\n" <>
+      "saglernianeoyl\n" <>
+      "e,ro -trsui ol\n" <>
+      "h uofcu sarhu \n" <>
+      "owddarrdan o m\n" <>
+      "lhg to'egccuwi\n" <>
+      "deemasdaeehris\n" <>
+      "sr als t  ists\n" <>
+      ",ebk 'phool'h,\n" <>
+      "  reldi ffd   \n" <>
+      "bweso tb  rtpo\n" <>
+      "oea ileutterau\n" <>
+      "t kcnoorhhnatr\n" <>
+      "hl isvuyee'fi \n" <>
+      " atv es iisfet\n" <>
+      "ayoior trr ino\n" <>
+      "l  lfsoh  ecti\n" <>
+      "ion   vedpn  l\n" <>
+      "kuehtteieadoe \n" <>
+      "erwaharrar,fas\n" <>
+      "   nekt te  rh\n" <>
+      "ismdsehphnnosa\n" <>
+      "ncuse ra-tau l\n" <>
+      " et  tormsural\n" <>
+      "dniuthwea'g t \n" <>
+      "iennwesnr hsts\n" <>
+      "g,ycoi tkrttet\n" <>
+      "n ,l r s'a anr\n" <>
+      "i  ef  'dgcgdi\n" <>
+      "t  aol   eoe,v\n" <>
+      "y  nei sl,u; e\n" <>
+      ",  .sf to l   \n" <>
+      "     e rv d  t\n" <>
+      "     ; ie    o\n" <>
+      "       f, r   \n" <>
+      "       e  e  m\n" <>
+      "       .  m  e\n" <>
+      "          o  n\n" <>
+      "          v  d\n" <>
+      "          e  .\n" <>
+      "          ,"
+
+    assert Transpose.transpose(matrix) == expected
+  end
+end