trackler 2.2.1.57 → 2.2.1.58

data/tracks/erlang/exercises/complex-numbers/HINTS.md

@@ -0,0 +1,2 @@
+You also need to implement a `equal/2` function. For this you can consider
+two numbers as equal, when the difference of each component is less than 0.005.

data/tracks/erlang/exercises/complex-numbers/README.md

@@ -0,0 +1,85 @@
+# Complex Numbers
+
+A complex number is a number in the form `a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
+
+`a` is called the real part and `b` is called the imaginary part of `z`.
+The conjugate of the number `a + b * i` is the number `a - b * i`.
+The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+
+The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately:
+`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
+`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+
+Multiplication result is by definition
+`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+
+The reciprocal of a non-zero complex number is
+`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+
+Dividing a complex number `a + i * b` by another `c + i * d` gives:
+`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+
+Exponent of a complex number can be expressed as
+`exp(a + i * b) = exp(a) * exp(i * b)`,
+and the last term is given by Euler's formula `exp(i * b) = cos(b) + i * sin(b)`.
+
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two complex numbers,
+ - conjugate, absolute value, exponent of a given complex number.
+
+
+Assume the programming language you are using does not have an implementation of complex numbers.
+
+You also need to implement a `equal/2` function. For this you can consider
+two numbers as equal, when the difference of each component is less than 0.005.
+
+
+## Running tests
+
+In order to run the tests, issue the following command from the exercise
+directory:
+
+For running the tests provided, `rebar3` is used as it is the official build and
+dependency management tool for erlang now. Please refer to [the tracks installation
+instructions](http://exercism.io/languages/erlang/installation) on how to do that.
+
+In order to run the tests, you can issue the following command from the exercise
+directory.
+
+```bash
+$ rebar3 eunit
+```
+
+### Test versioning
+
+Each problem defines a macro `TEST_VERSION` in the test file and
+verifies that the solution defines and exports a function `test_version`
+returning that same value.
+
+To make tests pass, add the following to your solution:
+
+```erlang
+-export([test_version/0]).
+
+test_version() ->
+  1.
+```
+
+The benefit of this is that reviewers can see against which test version
+an iteration was written if, for example, a previously posted solution
+does not solve the current problem or passes current tests.
+
+## Questions?
+
+For detailed information about the Erlang track, please refer to the
+[help page](http://exercism.io/languages/erlang) on the Exercism site.
+This covers the basic information on setting up the development
+environment expected by the exercises.
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Complex_number](https://en.wikipedia.org/wiki/Complex_number)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/erlang/exercises/complex-numbers/include/exercism.hrl

@@ -0,0 +1,11 @@
+-include_lib("eunit/include/eunit.hrl").
+
+sut(Module) ->
+  {ok, Files} = file:list_dir("./src"),
+  case lists:member("example.erl", Files) of
+    true  -> example;
+    false -> Module
+  end.
+
+version_test() ->
+  ?assertMatch(?TEST_VERSION, ?TESTED_MODULE:test_version()).

data/tracks/erlang/exercises/complex-numbers/rebar.config

@@ -0,0 +1,30 @@
+%% Erlang compiler options
+{erl_opts, [debug_info]}.
+
+{deps, []}.
+
+{dialyzer, [
+  {warnings, [underspecs, no_return]},
+  {get_warnings, true},
+  {plt_apps, top_level_deps}, % top_level_deps | all_deps
+  {plt_extra_apps, []},
+  {plt_location, local}, % local | "/my/file/name"
+  {plt_prefix, "rebar3"},
+  {base_plt_apps, [stdlib, kernel, crypto]},
+  {base_plt_location, global}, % global | "/my/file/name"
+  {base_plt_prefix, "rebar3"}
+]}.
+
+%% eunit:test(Tests)
+{eunit_tests, []}.
+%% Options for eunit:test(Tests, Opts)
+{eunit_opts, [verbose]}.
+
+%% == xref ==
+
+{xref_warnings, true}.
+
+%% xref checks to run
+{xref_checks, [undefined_function_calls, undefined_functions,
+  locals_not_used, exports_not_used,
+  deprecated_function_calls, deprecated_functions]}.

data/tracks/erlang/exercises/complex-numbers/src/complex_numbers.app.src

@@ -0,0 +1,9 @@
+{application, complex_numbers,
+  [{description, "exercism.io - complex-numbers"},
+    {vsn, "0.0.1"},
+    {modules, []},
+    {registered, []},
+    {applications, [kernel,
+      stdlib]},
+    {env, []}
+  ]}.

data/tracks/erlang/exercises/complex-numbers/src/complex_numbers.erl

@@ -0,0 +1,29 @@
+-module(complex_numbers).
+
+-export([abs/1, add/2, conjugate/1, divide/2, equal/2, exp/1, imaginary/1, mul/2, new/2,
+	 real/1, sub/2, test_version/0]).
+
+
+abs(Z) -> undefined.
+
+add(Z1, Z2) -> undefined.
+
+conjugate(Z) -> undefined.
+
+divide(Z1, Z2) -> undefined.
+
+equal(Z1, Z2) -> undefined.
+
+exp(Z) -> undefined.
+
+imaginary(Z) -> undefined.
+
+mul(Z1, Z2) -> undefined.
+
+new(R, I) -> undefined.
+
+real(Z) -> undefined.
+
+sub(Z1, Z2) -> undefined.
+
+test_version() -> 1.

data/tracks/erlang/exercises/complex-numbers/src/example.erl

@@ -0,0 +1,44 @@
+-module(example).
+
+-export([abs/1, add/2, conjugate/1, divide/2, equal/2, exp/1, imaginary/1, mul/2, new/2,
+    real/1, sub/2, test_version/0]).
+
+-record(complex, {r = 0, i = 0}).
+
+new(R, I) -> #complex{r = R, i = I}.
+
+abs(#complex{r = A, i = B}) ->
+    erlang:abs(math:sqrt(A * A + B * B)).
+
+add(#complex{r = A, i = B}, #complex{r = C, i = D}) ->
+    #complex{r = A + C, i = B + D}.
+
+conjugate(#complex{r = A, i = B}) ->
+    #complex{r = A, i = -B}.
+
+divide(#complex{r = A, i = B}, #complex{r = C, i = D}) ->
+    #complex{
+        r = (A * C + B * D) / (C * C + D * D),
+        i = (B * C - A * D) / (C * C + D * D)}.
+
+equal(#complex{r = A, i = B}, #complex{r = C, i = D}) when erlang:abs(A - C) < 0.005, erlang:abs(B - D) < 0.005 -> true;
+equal(X, Y) -> false.
+
+exp(#complex{r = A, i = B}) ->
+    mul(
+        new(math:exp(A), 0),
+        new(math:cos(B), math:sin(B))).
+
+imaginary(#complex{i = B}) ->
+    B.
+
+mul(#complex{r = A, i = B}, #complex{r = C, i = D}) ->
+    #complex{r = A * C - B * D, i = B * C + A * D}.
+
+real(#complex{r = A}) ->
+    A.
+
+sub(#complex{r = A, i = B}, #complex{r = C, i = D}) ->
+    #complex{r = A - C, i = B - D}.
+
+test_version() -> 1.

data/tracks/erlang/exercises/complex-numbers/test/complex_numbers_tests.erl

@@ -0,0 +1,152 @@
+-module(complex_numbers_tests).
+
+% This file is automatically generated from the exercises canonical data.
+
+-define(TESTED_MODULE, (sut(complex_numbers))).
+-define(TEST_VERSION, 1).
+-include("exercism.hrl").
+
+
+imaginary_unit_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(-1, 0),
+				 ?TESTED_MODULE:mul(?TESTED_MODULE:new(0, 1),
+						    ?TESTED_MODULE:new(0, 1)))).
+
+add_purely_real_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(3, 0),
+				 ?TESTED_MODULE:add(?TESTED_MODULE:new(1, 0),
+						    ?TESTED_MODULE:new(2, 0)))).
+
+add_purely_imaginary_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(0, 3),
+				 ?TESTED_MODULE:add(?TESTED_MODULE:new(0, 1),
+						    ?TESTED_MODULE:new(0, 2)))).
+
+add_numbers_with_real_and_imaginary_part_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(4, 6),
+				 ?TESTED_MODULE:add(?TESTED_MODULE:new(1, 2),
+						    ?TESTED_MODULE:new(3, 4)))).
+
+subtract_purely_real_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(-1, 0),
+				 ?TESTED_MODULE:sub(?TESTED_MODULE:new(1, 0),
+						    ?TESTED_MODULE:new(2, 0)))).
+
+subtract_purely_imaginary_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(0, -1),
+				 ?TESTED_MODULE:sub(?TESTED_MODULE:new(0, 1),
+						    ?TESTED_MODULE:new(0, 2)))).
+
+subtract_numbers_with_real_and_imaginary_part_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(-2, -2),
+				 ?TESTED_MODULE:sub(?TESTED_MODULE:new(1, 2),
+						    ?TESTED_MODULE:new(3, 4)))).
+
+multiply_purely_real_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(2, 0),
+				 ?TESTED_MODULE:mul(?TESTED_MODULE:new(1, 0),
+						    ?TESTED_MODULE:new(2, 0)))).
+
+multiply_purely_imaginary_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(-2, 0),
+				 ?TESTED_MODULE:mul(?TESTED_MODULE:new(0, 1),
+						    ?TESTED_MODULE:new(0, 2)))).
+
+multiply_numbers_with_real_and_imaginary_part_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(-5, 10),
+				 ?TESTED_MODULE:mul(?TESTED_MODULE:new(1, 2),
+						    ?TESTED_MODULE:new(3, 4)))).
+
+divide_purely_real_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(5.0e-1,
+						    0),
+				 ?TESTED_MODULE:divide(?TESTED_MODULE:new(1, 0),
+						       ?TESTED_MODULE:new(2,
+									  0)))).
+
+divide_purely_imaginary_numbers_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(5.0e-1,
+						    0),
+				 ?TESTED_MODULE:divide(?TESTED_MODULE:new(0, 1),
+						       ?TESTED_MODULE:new(0,
+									  2)))).
+
+divide_numbers_with_real_and_imaginary_part_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(4.4e-1,
+						    8.0e-2),
+				 ?TESTED_MODULE:divide(?TESTED_MODULE:new(1, 2),
+						       ?TESTED_MODULE:new(3,
+									  4)))).
+
+absolute_value_of_a_positive_purely_real_number_test() ->
+    ?assert(5 ==
+	      ?TESTED_MODULE:abs(?TESTED_MODULE:new(5, 0))).
+
+absolute_value_of_a_negative_purely_real_number_test() ->
+    ?assert(5 ==
+	      ?TESTED_MODULE:abs(?TESTED_MODULE:new(-5, 0))).
+
+absolute_value_of_a_purely_imaginary_number_with_positive_imaginary_part_test() ->
+    ?assert(5 ==
+	      ?TESTED_MODULE:abs(?TESTED_MODULE:new(0, 5))).
+
+absolute_value_of_a_purely_imaginary_number_with_negative_imaginary_part_test() ->
+    ?assert(5 ==
+	      ?TESTED_MODULE:abs(?TESTED_MODULE:new(0, -5))).
+
+absolute_value_of_a_number_with_real_and_imaginary_part_test() ->
+    ?assert(5 ==
+	      ?TESTED_MODULE:abs(?TESTED_MODULE:new(3, 4))).
+
+conjugate_a_purely_real_number_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(5, 0),
+				 ?TESTED_MODULE:conjugate(?TESTED_MODULE:new(5,
+									     0)))).
+
+conjugate_a_purely_imaginary_number_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(0, -5),
+				 ?TESTED_MODULE:conjugate(?TESTED_MODULE:new(0,
+									     5)))).
+
+conjugate_a_number_with_real_and_imaginary_part_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(1, -1),
+				 ?TESTED_MODULE:conjugate(?TESTED_MODULE:new(1,
+									     1)))).
+
+real_part_of_a_purely_real_number_test() ->
+    ?assert(1 ==
+	      ?TESTED_MODULE:real(?TESTED_MODULE:new(1, 0))).
+
+real_part_of_a_purely_imaginary_number_test() ->
+    ?assert(0 ==
+	      ?TESTED_MODULE:real(?TESTED_MODULE:new(0, 1))).
+
+real_part_of_a_number_with_real_and_imaginary_part_test() ->
+    ?assert(1 ==
+	      ?TESTED_MODULE:real(?TESTED_MODULE:new(1, 2))).
+
+imaginary_part_of_a_purely_real_number_test() ->
+    ?assert(0 ==
+	      ?TESTED_MODULE:imaginary(?TESTED_MODULE:new(1, 0))).
+
+imaginary_part_of_a_purely_imaginary_number_test() ->
+    ?assert(1 ==
+	      ?TESTED_MODULE:imaginary(?TESTED_MODULE:new(0, 1))).
+
+imaginary_part_of_a_number_with_real_and_imaginary_part_test() ->
+    ?assert(2 ==
+	      ?TESTED_MODULE:imaginary(?TESTED_MODULE:new(1, 2))).
+
+eulers_identityformula_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(-1, 0),
+				 ?TESTED_MODULE:exp(?TESTED_MODULE:new(0,
+								       3.14159265358979311600)))).
+
+exponential_of_0_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(1, 0),
+				 ?TESTED_MODULE:exp(?TESTED_MODULE:new(0, 0)))).
+
+exponential_of_a_purely_real_number_test() ->
+    ?assert(?TESTED_MODULE:equal(?TESTED_MODULE:new(2.71828182845904509080,
+						    0),
+				 ?TESTED_MODULE:exp(?TESTED_MODULE:new(1, 0)))).

data/tracks/erlang/testgen/src/tgen.erl

@@ -137,7 +137,7 @@ generate_test_module(ModuleName, Tests, Version) ->
         tgs:define("TEST_VERSION", tgs:value(Version)),
         tgs:include("exercism.hrl"),
         nl,
-        nl] ++ inter(nl, Tests),
+        nl] ++ inter(nl, lists:flatten(Tests)),
 
     {SluggedModName ++ "_tests", lists:flatten(
         lists:map(

data/tracks/erlang/testgen/src/tgen_complex-numbers.erl

@@ -0,0 +1,75 @@
+-module('tgen_complex-numbers').
+
+-behaviour(tgen).
+
+-export([
+    available/0,
+    version/0,
+    generate_test/1
+]).
+
+-spec available() -> true.
+available() ->
+    true.
+
+version() -> 1.
+
+generate_test(F = #{description := Desc, cases := Cases}) ->
+    rewrap(lists:flatten(lists:map(fun generate_test/1, Cases)), {[], []});
+generate_test(#{description := Desc, expected := Exp, property := Prop, input := Z}) when is_number(Exp) ->
+    TestName = tgen:to_test_name(Desc),
+    Property = binary_to_list(Prop),
+
+    Cplx = lists:map(fun to_num/1, Z),
+
+    Fn = tgs:simple_fun(TestName, [
+        tgs:call_macro("assert", [
+            erl_syntax:infix_expr(
+                tgs:value(Exp),
+                erl_syntax:operator("=="),
+                tgs:call_macro("TESTED_MODULE:" ++ Property, [
+                    tgs:call_macro("TESTED_MODULE:new", lists:map(fun tgs:value/1, Cplx))]))])]),
+
+    {ok, Fn, [{Property, ["Z"]}]};
+generate_test(#{description := Desc, expected := Exp, property := Prop, input := Z}) ->
+    TestName = tgen:to_test_name(Desc),
+    Property = binary_to_list(Prop),
+
+    Cplx = lists:map(fun to_num/1, Z),
+    Expected = lists:map(fun to_num/1, Exp),
+
+    Fn = tgs:simple_fun(TestName, [
+        tgs:call_macro("assert", [
+            tgs:call_macro("TESTED_MODULE:equal", [
+                tgs:call_macro("TESTED_MODULE:new", lists:map(fun tgs:value/1, Expected)),
+                tgs:call_macro("TESTED_MODULE:" ++ Property, [
+                    tgs:call_macro("TESTED_MODULE:new", lists:map(fun tgs:value/1, Cplx))])])])]),
+
+    {ok, Fn, [{Property, ["Z"]}]};
+generate_test(#{description := Desc, expected := Exp, property := <<"div">>, z1 := Z1, z2 := Z2}) ->
+    generate_test(#{description => Desc, expected => Exp, property => <<"divide">>, z1 => Z1, z2 => Z2});
+generate_test(#{description := Desc, expected := Exp, property := Prop, z1 := Z1, z2 := Z2}) ->
+    TestName = tgen:to_test_name(Desc),
+    Property = binary_to_list(Prop),
+
+    Cplx1 = lists:map(fun to_num/1, Z1),
+    Cplx2 = lists:map(fun to_num/1, Z2),
+    Expected = lists:map(fun to_num/1, Exp),
+
+    Fn = tgs:simple_fun(TestName, [
+        tgs:call_macro("assert", [
+            tgs:call_macro("TESTED_MODULE:equal", [
+                tgs:call_macro("TESTED_MODULE:new", lists:map(fun tgs:value/1, Expected)),
+                tgs:call_macro("TESTED_MODULE:" ++ Property, [
+                    tgs:call_macro("TESTED_MODULE:new", lists:map(fun tgs:value/1, Cplx1)),
+                    tgs:call_macro("TESTED_MODULE:new", lists:map(fun tgs:value/1, Cplx2))])])])]),
+
+    {ok, Fn, [{Property, ["Z1", "Z2"]}, {"equal", ["Z1", "Z2"]}, {"new", ["R", "I"]}]}.
+
+rewrap([], {Fns, Props}) -> {ok, lists:reverse(Fns), Props};
+rewrap([{ok, Fn, Props}|Tail], {Fns, AccProps}) ->
+    rewrap(Tail, {[Fn|Fns], Props ++ AccProps}).
+
+to_num(N) when is_number(N) -> N;
+to_num(<<"pi">>) -> math:pi();
+to_num(<<"e">>) -> math:exp(1).

data/tracks/java/config.json

@@ -919,10 +919,10 @@
       "slug": "ocr-numbers",
       "topics": [
         "exception_handling",
-        "loops",
         "lists",
-        "strings",
-        "parsing"
+        "loops",
+        "parsing",
+        "strings"
       ],
       "unlocked_by": "robot-name",
       "uuid": "5cbc6a67-3a53-4aad-ae68-ff469525437f"
@@ -1039,7 +1039,12 @@
       "core": false,
       "difficulty": 9,
       "slug": "pythagorean-triplet",
-      "topics": null,
+      "topics": [
+        "integer",
+        "lists",
+        "logic",
+        "mathematics"
+      ],
       "unlocked_by": "triangle",
       "uuid": "88505f95-89e5-4a08-8ed2-208eb818cdf1"
     },
@@ -1108,4 +1113,4 @@
   ],
   "language": "Java",
   "solution_pattern": "reference"
-}
+}

data/tracks/javascript/config.json

@@ -1135,6 +1135,19 @@
         "searching",
         "trees"
       ]
+    },
+    {
+      "uuid": "8740af44-002c-4716-a759-a68ae4c68737",
+      "slug": "isbn-verifier",
+      "core": false,
+      "unlocked_by": "bob",
+      "difficulty": 4,
+      "topics": [
+        "conditionals",
+        "loops",
+        "pattern_matching",
+        "strings"
+      ]
     }
   ],
   "foregone": [],

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

@@ -0,0 +1,66 @@
+# 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.
+
+## Setup
+
+Go through the setup instructions for JavaScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/javascript
+
+## Making the Test Suite Pass
+
+Execute the tests with:
+
+    jasmine <exercise-name>.spec.js
+
+Replace `<exercise-name>` with the name of the current exercise. E.g., to
+test the Hello World exercise:
+
+    jasmine hello-world.spec.js
+
+In many test suites all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+changing `xit` to `it`.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/javascript/<exerciseName>` directory.
+
+For example, if you're submitting `bob.js` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/javascript/bob/bob.js`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/javascript).
+
+## 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)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/javascript/exercises/isbn-verifier/example.js

@@ -0,0 +1,24 @@
+'use strict';
+
+function ISBN(isbn) {
+  this.isbn = isbn.replace(/-/g, '');
+
+  this.isValid = function () {
+    if (!this.isbn.match(/^(\d{9}[\dX])$/)) {
+      return false;
+    }
+
+    var digits = this.isbn.split('');
+    if (digits[9] === 'X') {
+      digits[9] = 10;
+    }
+
+    var sum = digits.reduce(function (total, current, index) {
+      return total + ((10 - index) * parseInt(current, 10));
+    }, 0);
+
+    return sum % 11 === 0;
+  };
+}
+
+module.exports = ISBN;

data/tracks/javascript/exercises/isbn-verifier/isbn-verifier.spec.js

@@ -0,0 +1,68 @@
+var ISBN = require('./isbn-verifier');
+
+describe('ISBN', function () {
+  it('valid isbn number', function () {
+    var isbn = new ISBN('3-598-21508-8');
+    expect(isbn.isValid()).toBe(true);
+  });
+
+  it('invalid isbn check digit', function () {
+    var isbn = new ISBN('3-598-21508-9');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('valid isbn number with a check digit of 10', function () {
+    var isbn = new ISBN('3-598-21507-X');
+    expect(isbn.isValid()).toBe(true);
+  });
+
+  it('check digit is a character other than X', function () {
+    var isbn = new ISBN('3-598-21507-A');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('invalid character in isbn', function () {
+    var isbn = new ISBN('3-598-2K507-0');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('X is only valid as a check digit', function () {
+    var isbn = new ISBN('3-598-2X507-0');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('valid isbn without separating dashes', function () {
+    var isbn = new ISBN('3598215088');
+    expect(isbn.isValid()).toBe(true);
+  });
+
+  it('isbn without separating dashes and X as check digit', function () {
+    var isbn = new ISBN('359821507X');
+    expect(isbn.isValid()).toBe(true);
+  });
+
+  it('isbn without check digit and dashes', function () {
+    var isbn = new ISBN('359821507');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('too long isbn and no dashes', function () {
+    var isbn = new ISBN('3598215078X');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('isbn without check digit', function () {
+    var isbn = new ISBN('3-598-21507');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('too long isbn', function () {
+    var isbn = new ISBN('3-598-21507-XA');
+    expect(isbn.isValid()).toBe(false);
+  });
+
+  it('check digit of X should not be used for 0', function () {
+    var isbn = new ISBN('3-598-21515-X');
+    expect(isbn.isValid()).toBe(false);
+  });
+});