trackler 2.2.1.57 → 2.2.1.58

data/tracks/ecmascript/exercises/complex-numbers/complex-numbers.spec.js

@@ -0,0 +1,216 @@
+import ComplexNumber from './complex-numbers.js';
+
+describe('Complex numbers', () => {
+  test('Real part of a purely real number', () => {
+    const expected = 1;
+    const actual = new ComplexNumber(1, 0).real;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Real part of a purely imaginary number', () => {
+    const expected = 0;
+    const actual = new ComplexNumber(0, 1).real;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Real part of a number with real and imaginary part', () => {
+    const expected = 1;
+    const actual = new ComplexNumber(1, 2).real;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Imaginary part of a purely real number', () => {
+    const expected = 0;
+    const actual = new ComplexNumber(1, 0).imag;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Imaginary part of a purely imaginary number', () => {
+    const expected = 1;
+    const actual = new ComplexNumber(0, 1).imag;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Imaginary part of a number with real and imaginary part', () => {
+    const expected = 2;
+    const actual = new ComplexNumber(1, 2).imag;
+
+    expect(actual).toEqual(expected);
+  });
+  
+  xtest('Add purely real numbers', () => {
+    const expected = new ComplexNumber(3, 0);
+    const actual = new ComplexNumber(1, 0).add(new ComplexNumber(2, 0));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Add purely imaginary numbers', () => {
+    const expected = new ComplexNumber(0, 3);
+    const actual = new ComplexNumber(0, 1).add(new ComplexNumber(0, 2));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Add numbers with real and imaginary part', () => {
+    const expected = new ComplexNumber(4, 6);
+    const actual = new ComplexNumber(1, 2).add(new ComplexNumber(3, 4));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Subtract purely real numbers', () => {
+    const expected = new ComplexNumber(-1, 0);
+    const actual = new ComplexNumber(1, 0).sub(new ComplexNumber(2, 0));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Subtract purely imaginary numbers', () => {
+    const expected = new ComplexNumber(0, -1);
+    const actual = new ComplexNumber(0, 1).sub(new ComplexNumber(0, 2));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Subtract numbers with real and imaginary part', () => {
+    const expected = new ComplexNumber(-2, -2);
+    const actual = new ComplexNumber(1, 2).sub(new ComplexNumber(3, 4));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Multiply purely real numbers', () => {
+    const expected = new ComplexNumber(2, 0);
+    const actual = new ComplexNumber(1, 0).mul(new ComplexNumber(2, 0));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Multiply imaginary unit', () => {
+    const expected = new ComplexNumber(-1, 0);
+    const actual = new ComplexNumber(0, 1).mul(new ComplexNumber(0, 1));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Multiply purely imaginary numbers', () => {
+    const expected = new ComplexNumber(-2, 0);
+    const actual = new ComplexNumber(0, 1).mul(new ComplexNumber(0, 2));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Multiply numbers with real and imaginary part', () => {
+    const expected = new ComplexNumber(-5, 10);
+    const actual = new ComplexNumber(1, 2).mul(new ComplexNumber(3, 4));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Divide purely real numbers', () => {
+    const expected = new ComplexNumber(0.5, 0);
+    const actual = new ComplexNumber(1, 0).div(new ComplexNumber(2, 0));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Divide purely imaginary numbers', () => {
+    const expected = new ComplexNumber(0.5, 0);
+    const actual = new ComplexNumber(0, 1).div(new ComplexNumber(0, 2));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Divide numbers with real and imaginary part', () => {
+    const expected = new ComplexNumber(0.44, 0.08);
+    const actual = new ComplexNumber(1, 2).div(new ComplexNumber(3, 4));
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Absolute value of a positive purely real number', () => {
+    const expected = 5;
+    const actual = new ComplexNumber(5, 0).abs;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Absolute value of a negative purely real number', () => {
+    const expected = 5;
+    const actual = new ComplexNumber(-5, 0).abs;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Absolute value of a purely imaginary number with positive imaginary part', () => {
+    const expected = 5;
+    const actual = new ComplexNumber(0, 5).abs;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Absolute value of a purely imaginary number with negative imaginary part', () => {
+    const expected = 5;
+    const actual = new ComplexNumber(0, -5).abs;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Absolute value of a number with real and imaginary part', () => {
+    const expected = 5;
+    const actual = new ComplexNumber(3, 4).abs;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Conjugate a purely real number', () => {
+    const expected = new ComplexNumber(5, 0);
+    const actual = new ComplexNumber(5, 0).conj;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Conjugate a purely imaginary number', () => {
+    const expected = new ComplexNumber(0, -5);
+    const actual = new ComplexNumber(0, 5).conj;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Conjugate a number with real and imaginary part', () => {
+    const expected = new ComplexNumber(1, -1);
+    const actual = new ComplexNumber(1, 1).conj;
+
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('Euler\'s identity/formula', () => {
+    const expected = new ComplexNumber(-1, 0);
+    const actual = new ComplexNumber(0, Math.PI).exp;
+
+    expect(actual.real).toBeCloseTo(expected.real);
+    expect(actual.imag).toBeCloseTo(expected.imag);
+  });
+
+  xtest('Exponential of 0', () => {
+    const expected = new ComplexNumber(1, 0);
+    const actual = new ComplexNumber(0, 0).exp;
+
+    expect(actual.real).toBeCloseTo(expected.real);
+    expect(actual.imag).toBeCloseTo(expected.imag);
+  });
+
+  xtest('Exponential of a purely real number', () => {
+    const expected = new ComplexNumber(Math.E, 0);
+    const actual = new ComplexNumber(1, 0).exp;
+
+    expect(actual.real).toBeCloseTo(expected.real);
+    expect(actual.imag).toBeCloseTo(expected.imag);
+  });
+});

data/tracks/ecmascript/exercises/complex-numbers/example.js

@@ -0,0 +1,43 @@
+export default class ComplexNumber {
+
+  constructor(real, imag) {
+    this.real = real;
+    this.imag = imag;
+  }
+
+  add(other) {
+    return new ComplexNumber(this.real + other.real, this.imag + other.imag);
+  }
+
+  sub(other) {
+    return new ComplexNumber(this.real - other.real, this.imag - other.imag);
+  }
+
+  mul(other) {
+    return new ComplexNumber(
+      (this.real * other.real) - (this.imag * other.imag),
+      (this.imag * other.real) + (this.real * other.imag));
+  }
+
+  div(other) {
+    return new ComplexNumber(
+      ((this.real * other.real) + (this.imag * other.imag))
+      / ((other.real * other.real) + (other.imag * other.imag)),
+      ((this.imag * other.real) - (this.real * other.imag))
+      / ((other.real * other.real) + (other.imag * other.imag)));
+  }
+
+  get abs() {
+    return Math.sqrt((this.real * this.real) + (this.imag * this.imag));
+  }
+
+  get conj() {
+    return new ComplexNumber(this.real, this.imag !== 0 ? -this.imag : 0);
+  }
+
+  get exp() {
+    return new ComplexNumber(
+      Math.exp(this.real) * Math.cos(this.imag),
+      Math.exp(this.real) * Math.sin(this.imag));
+  }
+}

data/tracks/ecmascript/exercises/{transpose → complex-numbers}/package.json

@@ -9,7 +9,7 @@
     "url": "https://github.com/exercism/xecmascript"
   },
   "devDependencies": {
-    "babel-jest": "^20.0.3",
+    "babel-jest": "^21.2.0",
     "babel-plugin-transform-builtin-extend": "^1.1.2",
     "babel-preset-env": "^1.4.0",
     "eslint": "^3.19.0",
@@ -17,7 +17,7 @@
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-jsx-a11y": "^5.0.1",
     "eslint-plugin-react": "^7.0.1",
-    "jest": "^20.0.4"
+    "jest": "^21.2.1"
   },
   "jest": {
     "modulePathIgnorePatterns": [

data/tracks/elixir/config.json

@@ -783,10 +783,31 @@
       ],
       "unlocked_by": null,
       "uuid": "ce270a34-add1-422c-bb86-53b310f05e27"
+    },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "isbn-verifier",
+      "topics": [
+        "string_processing"
+      ],
+      "unlocked_by": null,
+      "uuid": "0fb09d01-1f8b-4654-9004-52baa057412e"
+    },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "spiral-matrix",
+      "topics": [
+        "lists",
+        "transforming"
+      ],
+      "unlocked_by": null,
+      "uuid": "b0216103-000b-8480-556d-816ddca02c40810d1e9"
     }
   ],
   "foregone": [
     "robot-name"
   ],
   "language": "Elixir"
-}
+}

data/tracks/elixir/exercises/isbn-verifier/README.md

@@ -0,0 +1,80 @@
+# ISBN-Verifier
+
+Check if a given ISBN-10 is valid.
+
+## Functionality
+
+Given an unknown string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should allow for ISBN-10 without the separating dashes to be verified as well.
+
+## ISBN
+
+Let's take a random ISBN-10 number, say `3-598-21508-8` for this.
+The first digit block indicates the group where the ISBN belongs. Groups can consist of shared languages, geographic regions or countries. The leading '3' signals this ISBN is from a german speaking country.
+The following number block is to identify the publisher. Since this is a three digit publisher number there is a 5 digit title number for this book.
+The last digit in the ISBN is the check digit which is used to detect read errors.
+
+The first 9 digits in the ISBN have to be between 0 and 9.
+The check digit can additionally be an 'X' to allow 10 to be a valid check digit as well.
+
+A valid ISBN-10 is calculated with this formula `(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0`
+So for our example ISBN this means:
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 = 0
+
+Which proves that the ISBN is valid.
+
+## Caveats
+
+Converting from string to number can be tricky in certain languages.
+It's getting even trickier since the check-digit of an ISBN-10 can be 'X'.
+
+## Bonus tasks
+
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier)
+
+* Generate valid ISBN, maybe even from a given starting ISBN
+
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir isbn_verifier_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 "shouting" do
+  assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
+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).
+
+## Source
+
+Converting a string into a number and some basic processing utilizing a relatable real world example. [https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation](https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation)
+
+## 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/isbn-verifier/example.exs

@@ -0,0 +1,36 @@
+defmodule ISBNVerifier do
+  @doc """
+    Checks if a string is a valid ISBN-10 identifier
+
+    ## Examples
+
+      iex> ISBNVerifier.isbn?("3-598-21507-X")
+      true
+
+      iex> ISBNVerifier.isbn?("3-598-2K507-0")
+      false
+
+  """
+  @spec isbn?(String.t()) :: boolean
+  def isbn?(isbn) do
+    if Regex.match?(~r/^(\d-?){9}(\d|X)$/, isbn) do
+      checksum =
+        isbn
+        |> String.replace("-", "")
+        |> String.graphemes()
+        |> Enum.zip(10..1)
+        |> Enum.map(&checksum_weighting/1)
+        |> Enum.sum()
+
+      rem(checksum, 11) == 0
+    else
+      false
+    end
+  end
+
+  defp checksum_weighting({"X", 1}), do: 10
+
+  defp checksum_weighting({digit, weight}) do
+    String.to_integer(digit) * weight
+  end
+end

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

@@ -0,0 +1,18 @@
+defmodule ISBNVerifier do
+  @doc """
+    Checks if a string is a valid ISBN-10 identifier
+
+    ## Examples
+
+      iex> ISBNVerifier.isbn?("3-598-21507-X")
+      true
+
+      iex> ISBNVerifier.isbn?("3-598-2K507-0")
+      false
+
+  """
+  @spec isbn?(String.t()) :: boolean
+  def isbn?(isbn) do
+
+  end
+end

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

@@ -0,0 +1,75 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("isbn_verifier.exs", __DIR__)
+end
+
+ExUnit.start()
+ExUnit.configure(exclude: :pending, trace: true)
+
+defmodule ISBNVerifierTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "valid isbn number" do
+    assert ISBNVerifier.isbn?("3-598-21508-8")
+  end
+
+  @tag :pending
+  test "invalid isbn check digit" do
+    refute ISBNVerifier.isbn?("3-598-21508-9")
+  end
+
+  @tag :pending
+  test "valid isbn number with a check digit of 10" do
+    assert ISBNVerifier.isbn?("3-598-21507-X")
+  end
+
+  @tag :pending
+  test "check digit is a character other than X" do
+    refute ISBNVerifier.isbn?("3-598-21507-A")
+  end
+
+  @tag :pending
+  test "invalid character in isbn" do
+    refute ISBNVerifier.isbn?("3-598-2K507-0")
+  end
+
+  @tag :pending
+  test "X is only valid as a check digit" do
+    refute ISBNVerifier.isbn?("3-598-2X507-0")
+  end
+
+  @tag :pending
+  test "valid isbn without separating dashes" do
+    assert ISBNVerifier.isbn?("3598215088")
+  end
+
+  @tag :pending
+  test "isbn without separating dashes and X as check digit" do
+    assert ISBNVerifier.isbn?("359821507X")
+  end
+
+  @tag :pending
+  test "isbn without check digit and dashes" do
+    refute ISBNVerifier.isbn?("359821507")
+  end
+
+  @tag :pending
+  test "too long isbn and no dashes" do
+    refute ISBNVerifier.isbn?("3598215078X")
+  end
+
+  @tag :pending
+  test "isbn without check digit" do
+    refute ISBNVerifier.isbn?("3-598-21507")
+  end
+
+  @tag :pending
+  test "too long isbn" do
+    refute ISBNVerifier.isbn?("3-598-21507-XA")
+  end
+
+  @tag :pending
+  test "check digit of X should not be used for 0" do
+    refute ISBNVerifier.isbn?("3-598-21515-X")
+  end
+end

data/tracks/elixir/exercises/spiral-matrix/README.md

@@ -0,0 +1,65 @@
+# Spiral Matrix
+
+Given the size, return a square matrix of numbers in spiral order.
+
+The matrix should be filled with natural numbers, starting from 1
+in the top-left corner, increasing in an inward, clockwise spiral order,
+like these examples:
+
+###### Spiral matrix of size 3
+
+```text
+1 2 3
+8 9 4
+7 6 5
+```
+
+###### Spiral matrix of size 4
+
+```text
+ 1  2  3 4
+ 12 13 14 5
+ 11 16 15 6
+ 10  9  8 7
+ ```
+
+## Running tests
+
+Execute the tests with:
+
+```bash
+$ elixir spiral_matrix_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 "shouting" do
+  assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
+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).
+
+## Source
+
+Reddit r/dailyprogrammer challenge #320 [Easy] Spiral Ascension. [spiral ascension](https://www.reddit.com/r/dailyprogrammer/comments/6i60lr/20170619_challenge_320_easy_spiral_ascension/)
+
+## 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/spiral-matrix/example.exs

@@ -0,0 +1,27 @@
+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]
+    end
+  end
+
+  defp rotate_right(matrix) do
+    matrix |> transpose |> Enum.map(&Enum.reverse/1)
+  end
+
+  defp transpose(matrix) do
+    matrix |> List.zip |> Enum.map(&Tuple.to_list/1)
+  end
+end

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

@@ -0,0 +1,9 @@
+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(dimension) do
+  end
+end

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

@@ -0,0 +1,58 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("spiral.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure trace: true, exclude: :pending
+
+defmodule SpiralTest do
+  use ExUnit.Case
+
+  # @tag :pending
+  test "empty spiral" do
+    assert Spiral.matrix(0) == []
+  end
+
+  @tag :pending
+  test "trivial spiral" do
+    assert Spiral.matrix(1) == [ [1] ]
+  end
+
+  @tag :pending
+  test "spiral of side length 2" do
+    assert Spiral.matrix(2) == [
+      [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]
+    ]
+  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]
+    ]
+  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]
+    ]
+  end
+end

data/tracks/erlang/config.json

@@ -322,6 +322,16 @@
 
       ]
     },
+    {
+      "uuid": "5fc48c1b-0e1b-47b3-b30a-5281ec364aad",
+      "slug": "complex-numbers",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 5,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "8ad0c97b-189d-46ac-bb72-2c72f1fe4728",
       "slug": "rotational-cipher",