trackler 2.2.1.175 → 2.2.1.176

data/tracks/ecmascript/exercises/reverse-string/example.js

@@ -0,0 +1,9 @@
+function reverseString(string) {
+  let revString = '';
+  for (let i = string.length - 1; i >= 0; i -= 1) {
+    revString += string[i];
+  }
+  return revString;
+}
+
+export default reverseString;

data/tracks/ecmascript/exercises/reverse-string/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "xecmascript",
+  "version": "0.0.0",
+  "description": "Exercism exercises in ECMAScript 6.",
+  "author": "Katrina Owen",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xecmascript"
+  },
+  "devDependencies": {
+    "babel-jest": "^21.2.0",
+    "babel-plugin-transform-builtin-extend": "^1.1.2",
+    "babel-preset-env": "^1.4.0",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb": "^15.0.1",
+    "eslint-plugin-import": "^2.2.0",
+    "eslint-plugin-jsx-a11y": "^5.0.1",
+    "eslint-plugin-react": "^7.0.1",
+    "jest": "^21.2.1"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "package.json"
+    ]
+  },
+  "babel": {
+    "presets": [["env",{"targets":[{"node": "current"}]}]
+    ],
+    "plugins": [
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ],
+      [
+        "transform-regenerator"
+      ]
+    ]
+  },
+  "scripts": {
+    "test": "jest --no-cache ./*",
+    "watch": "jest --no-cache --watch ./*",
+    "lint": "eslint .",
+    "lint-test": "eslint . && jest --no-cache ./* "
+  },
+  "eslintConfig": {
+    "parserOptions": {
+      "ecmaVersion": 6,
+      "sourceType": "module"
+    },
+    "env": {
+      "es6": true,
+      "node": true,
+      "jest": true
+    },
+    "extends": "airbnb",
+    "rules": {
+      "import/no-unresolved": "off",
+      "import/extensions": "off"
+    }
+  },
+  "licenses": [
+    "MIT"
+  ],
+  "dependencies": {}
+}

data/tracks/ecmascript/exercises/reverse-string/reverse-string.spec.js

@@ -0,0 +1,33 @@
+import reverseString from './reverse-string';
+
+describe('ReverseString', () => {
+  test('empty string', () => {
+    const expected = '';
+    const actual = reverseString('');
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('a word', () => {
+    const expected = 'tobor';
+    const actual = reverseString('robot');
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('a capitalized word', () => {
+    const expected = 'nemaR';
+    const actual = reverseString('Ramen');
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('a sentence with punctuation', () => {
+    const expected = '!yrgnuh ma I';
+    const actual = reverseString('I am hungry!');
+    expect(actual).toEqual(expected);
+  });
+
+  xtest('a palindrome', () => {
+    const expected = 'racecar';
+    const actual = reverseString('racecar');
+    expect(actual).toEqual(expected);
+  });
+});

data/tracks/erlang/config.json

@@ -199,6 +199,17 @@
         "mathematics"
       ]
     },
+    {
+      "slug": "armstrong-numbers",
+      "uuid": "a639ce2f-48e3-46cd-9d11-955ba2a9eaaa",
+      "core": false,
+      "unlocked_by": "collatz-conjecture",
+      "difficulty": 2,
+      "topics": [
+        "integers",
+        "mathematics"
+      ]
+    },
     {
       "slug": "anagram",
       "uuid": "8f0570ae-223f-4da4-8b84-268b797b28ad",

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

@@ -0,0 +1,53 @@
+An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.
+
+For example:
+
+- 9 is an Armstrong number, because `9 = 9^1 = 9`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`
+- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
+- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+
+Write some code to determine whether a number is an Armstrong number.
+
+## 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.
+

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

@@ -0,0 +1,30 @@
+%% Erlang compiler options
+{erl_opts, [debug_info]}.
+
+{deps, [{erl_exercism, "0.1.1"}]}.
+
+{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/armstrong-numbers/src/armstrong_numbers.app.src

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

data/tracks/erlang/exercises/armstrong-numbers/src/armstrong_numbers.erl

@@ -0,0 +1,8 @@
+-module(armstrong_numbers).
+
+-export([is_armstrong_number/1, test_version/0]).
+
+is_armstrong_number(N) ->
+	undefined.
+
+test_version() -> 1.

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

@@ -0,0 +1,29 @@
+-module(example).
+
+-export([is_armstrong_number/1, test_version/0]).
+
+is_armstrong_number(N) ->
+	{Digits, Count}=to_digits(N),
+	N==calc_number(Digits, Count).
+
+calc_number(Digits, Count) ->
+	calc_number(Digits, Count, 0).
+
+calc_number([], _, Acc) ->
+	Acc;
+
+calc_number([Digit|More], Count, Acc) ->
+	calc_number(More, Count, Acc+trunc(math:pow(Digit, Count))).
+
+to_digits(N) ->
+	to_digits(N, [], 0).
+
+to_digits(0, AccD, AccN) ->
+	{AccD, AccN};
+
+to_digits(N, Digits, Count) ->
+	Digit=N rem 10,
+	NewN=N div 10,
+	to_digits(NewN, [Digit|Digits], Count+1).
+
+test_version() -> 1.

data/tracks/erlang/exercises/armstrong-numbers/test/armstrong_numbers_tests.erl

@@ -0,0 +1,33 @@
+%% based on canonical data version 1.0.0
+%% https://raw.githubusercontent.com/exercism/problem-specifications/master/exercises/armstrong-numbers/canonical-data.json
+
+-module(armstrong_numbers_tests).
+
+-define(TESTED_MODULE, (sut(<erlangified_slug_name>))).
+-define(TEST_VERSION, 1).
+-include_lib("erl_exercism/include/exercism.hrl").
+-include_lib("eunit/include/eunit.hrl").
+
+single_digit_numbers_test() ->
+	?assert(armstrong_numbers:is_armstrong_number(5)).
+
+two_digit_numbers_test() ->
+	?assertNot(armstrong_numbers:is_armstrong_number(10)).
+
+three_digit_armstrong_numbers_test() ->
+	?assert(armstrong_numbers:is_armstrong_number(153)).
+
+three_digit_not_armstrong_numbers_test() ->
+	?assertNot(armstrong_numbers:is_armstrong_number(100)).
+
+four_digit_armstrong_numbers_test() ->
+	?assert(armstrong_numbers:is_armstrong_number(9474)).
+
+four_digit_not_armstrong_numbers_test() ->
+	?assertNot(armstrong_numbers:is_armstrong_number(9475)).
+
+seven_digit_armstrong_numbers_test() ->
+	?assert(armstrong_numbers:is_armstrong_number(9926315)).
+
+seven_digit_not_armstrong_numbers_test() ->
+	?assertNot(armstrong_numbers:is_armstrong_number(9926314)).

data/tracks/erlang/exercises/bracket-push/src/example.erl

@@ -1,4 +1,4 @@
--module(bracket_push).
+-module(example).
 
 -export([is_paired/1, test_version/0]).
 

data/tracks/erlang/exercises/isbn-verifier/src/example.erl

@@ -1,4 +1,4 @@
--module(isbn_verifier).
+-module(example).
 
 -export([is_valid/1, test_version/0]).
 

data/tracks/julia/config.json

@@ -407,6 +407,18 @@
         "exceptions"
       ]
     },
+    {
+    "uuid": "3a2facfd-5ec8-49a0-a5aa-2229f07da896",
+    "slug": "spiral-matrix",
+    "core": false,
+    "unlocked_by": null,
+    "difficulty": 3,
+    "topics": [
+    "matrix",
+    "mathematics",
+    "iterators"
+    ]
+    },
     {
       "slug": "isbn-verifier",
       "uuid": "22b64a2b-7f08-444d-be6e-8b42e5c9207c",

data/tracks/julia/docs/ABOUT.md

@@ -1,7 +1,7 @@
 The creators of Julia want to eat their cake and have it too. As they describe in their blog post ["Why We Created Julia"](http://julialang.org/blog/2012/02/why-we-created-julia) they want the speed of C, the dynamism of Ruby, the familiar mathematical notation of Matlab. They want it to be their favourite things from their favourite languages. String processing like Perl. Glue like the shell. Powerful but not impenetrably complex.
 
-Julia has a dynamic, nominative and parametric [type system](http://docs.julialang.org/en/stable/manual/types/). This allows writing dynamic code and specifying types if additional expressiveness is needed for simplification or performance increases. The language features multiple dispatch, meaning it chooses which method is called based on the types of each argument. This lets you write specific methods for certain types while providing generic fallbacks and is particularly useful for mathematical code, where it is not clear why an operation should belong to a specific argument.
+Julia has a powerful, yet clear and intuitive, dynamic [type system](http://docs.julialang.org/en/stable/manual/types/). It allows writing dynamic code and specifying types if additional expressiveness is needed for simplification or performance increases. The language features multiple dispatch, meaning it chooses which method is called based on the types of each argument. This lets you write specific methods for certain types while providing generic fallbacks and is particularly useful for mathematical code, where it is not clear why an operation should belong to a specific argument.
 
-[Metaprogramming](http://docs.julialang.org/en/stable/manual/metaprogramming/) is easy in Julia due to its homoiconicity, i.e. Julia code can be represented in Julia itself. Large parts of [Julia's base library](https://github.com/julialang/julia) are also written in Julia. Understanding and changing it does not require knowledge of another language. If a library you need to use is written in another language, such as [C, Fortran](http://docs.julialang.org/en/stable/manual/calling-c-and-fortran-code/) or [Python](https://github.com/JuliaPy/PyCall.jl), you can use simple interfaces to call them directly from your code.
+[Metaprogramming](http://docs.julialang.org/en/stable/manual/metaprogramming/) is easy in Julia due to its homoiconicity, i.e. Julia code can be represented in Julia itself, just like in Lisp. Large parts of [Julia's base and standard library](https://github.com/julialang/julia) are also written in Julia. Understanding and changing it does not require knowledge of another language. If a library you need to use is written in another language, such as [C, Fortran](http://docs.julialang.org/en/stable/manual/calling-c-and-fortran-code/) or [Python](https://github.com/JuliaPy/PyCall.jl), you can use simple interfaces to call them directly from your code.
 
-Despite its young age, Julia is already being used in the real world in a variety of fields, such as but not limited to Finance, Data Science and Scientific Computing. You can find many showcase applications on [juliabloggers.com](http://www.juliabloggers.com/) and a list of publications about the language and its technical computing applications [here](http://julialang.org/publications/).
+Despite its young age, Julia is already being used in the real world in a variety of fields, such as but not limited to Finance, Data Science and Scientific Computing. You can find many showcase applications on [juliabloggers.com](http://www.juliabloggers.com/) and a list of publications about the language and its applications [here](http://julialang.org/publications/).

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

@@ -0,0 +1,31 @@
+# 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
+```
+## Source
+
+Reddit r/dailyprogrammer challenge #320 [Easy] Spiral Ascension. [https://www.reddit.com/r/dailyprogrammer/comments/6i60lr/20170619_challenge_320_easy_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/julia/exercises/spiral-matrix/example.jl

@@ -0,0 +1,9 @@
+#Credit to u/SingularInfinity on Redit: https://www.reddit.com/r/dailyprogrammer/comments/6i60lr/20170619_challenge_320_easy_spiral_ascension/djb8po0
+
+function spiral_matrix(n::Int)
+    n < 0 && throw(DomainError("n should be positive"))
+    n == 0 && return Matrix{Int}(0,0)
+    n == 1 && return reshape(Int[1], 1, 1)
+    m = (2n - 1) .+ spiral_matrix(n-1)
+    return [ RowVector(1:n); rot180(m) n+1:2n-1 ]
+end

data/tracks/julia/exercises/spiral-matrix/runtests.jl

@@ -0,0 +1,25 @@
+using Base.Test
+
+include("spiral-matrix.jl")
+
+
+@testset "Different valid values" begin
+    @testset "Empty spiral" begin
+        @test spiral_matrix(0) == Matrix{Int}(0,0)
+    end
+    @testset "Trivial spiral" begin
+        @test spiral_matrix(1) == reshape([1],(1,1))
+    end
+    @testset "Spiral of size 2" begin
+        @test spiral_matrix(2) == [1 2; 4 3]
+    end
+    @testset "Spiral of size 3" begin
+        @test spiral_matrix(3) == [1 2 3; 8 9 4; 7 6 5]
+    end
+    @testset "Spiral of size 4" begin
+        @test spiral_matrix(4) == [1 2 3 4; 12 13 14 5; 11 16 15 6; 10 9 8 7]
+    end
+    @testset "Spiral of size 5" begin
+        @test 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/julia/exercises/spiral-matrix/spiral-matrix.jl

@@ -0,0 +1,3 @@
+function spiral_matrix(n::Int)
+
+end

data/tracks/perl5/config.json

@@ -9,6 +9,7 @@
       "slug": "hello-world",
       "uuid": "e436ce92-78b9-4b3b-b87e-581fa54cdc65",
       "core": false,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": []

data/tracks/perl5/docs/ABOUT.md

@@ -1,6 +1,7 @@
-# What is Perl5?
-Perl v5 is a high-level general purpose programming language invented by Larry Wall and first
-released in 1987. It is an eclectic interpreted, procedural, loosely typed language which had its peak of popularity with the rise of the World Wide Web, though it remains widely used in Quality Assurance, IT infrastructure automation, text processing, bioinformatics and web application development, just to name a few areas. It is highly flexible, but this flexibility can have a follow-on maintenance cost.
+Perl v5 is a high-level general purpose programming language invented by Larry Wall and first released in 1987. 
+It is an eclectic interpreted, procedural, loosely typed language. 
+Its popularity peaked with the rise of the World Wide Web, though it remains widely used in Quality Assurance, IT infrastructure automation, text processing, bioinformatics and web application development, just to name a few areas. 
+It is highly flexible, but this flexibility can have a follow-on maintenance cost.
 
  Perl also has