trackler 2.2.0.4 → 2.2.0.5

data/tracks/erlang/exercises/space-age/README.md

@@ -65,4 +65,3 @@ Partially inspired by Chapter 1 in Chris Pine's online Learn to Program tutorial
 
 ## 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/spiral-matrix/README.md

@@ -71,4 +71,3 @@ Reddit r/dailyprogrammer challenge #320 [Easy] Spiral Ascension. [https://www.re
 
 ## 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/strain/README.md

@@ -81,4 +81,3 @@ Conversation with James Edward Gray II [https://twitter.com/jeg2](https://twitte
 
 ## 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/sum-of-multiples/README.md

@@ -59,4 +59,3 @@ A variation on Problem 1 at Project Euler [http://projecteuler.net/problem=1](ht
 
 ## 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/triangle/README.md

@@ -67,4 +67,3 @@ The Ruby Koans triangle project, parts 1 & 2 [http://rubykoans.com](http://rubyk
 
 ## 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/word-count/README.md

@@ -60,4 +60,3 @@ This is a classic toy problem, but we were reminded of it by seeing it in the Go
 
 ## 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/zipper/README.md

@@ -72,4 +72,3 @@ environment expected by the exercises.
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.
-

data/tracks/factor/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "factor",
   "language": "Factor",
-  "repository": "https://github.com/exercism/factor",
   "active": false,
   "test_pattern": "TODO",
   "exercises": [

data/tracks/fsharp/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "fsharp",
   "language": "F#",
-  "repository": "https://github.com/exercism/fsharp",
   "active": true,
   "exercises": [
     {

data/tracks/go/config.json

@@ -320,9 +320,10 @@
       "slug": "bank-account",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 4,
       "topics": [
-
+        "Concurrency",
+        "Integers"
       ]
     },
     {
@@ -330,9 +331,12 @@
       "slug": "crypto-square",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 3,
       "topics": [
-
+        "Filtering",
+        "Strings",
+        "Text Formatting",
+        "Transforming"
       ]
     },
     {
@@ -340,9 +344,11 @@
       "slug": "luhn",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 2,
       "topics": [
-
+        "Algorithms",
+        "Integers",
+        "Strings"
       ]
     },
     {

data/tracks/go/exercises/bank-account/bank_account_test.go

@@ -6,10 +6,24 @@
 // (Account) Deposit(amount int64) (newBalance int64, ok bool)
 //
 // If Open is given a negative initial deposit, it must return nil.
-// Deposit must handle a negative amount as a withdrawal.
+// Deposit must handle a negative amount as a withdrawal. Withdrawals must
+// not succeed if they result in a negative balance.
 // If any Account method is called on an closed account, it must not modify
 // the account and must return ok = false.
 
+// The tests will execute some operations concurrently. You should strive
+// to ensure that operations on the Account leave it in a consistent state.
+// For example: multiple goroutines may be depositing and withdrawing money
+// simultaneously, two withdrawals occurring concurrently should not be able
+// to bring the balance into the negative.
+
+// If you are new to concurrent operations in Go it will be worth looking
+// at the sync package, specifically Mutexes:
+//
+// https://golang.org/pkg/sync/
+// https://tour.golang.org/concurrency/9
+// https://gobyexample.com/mutexes
+
 package account
 
 import (
@@ -295,3 +309,48 @@ func TestConcDeposit(t *testing.T) {
 			"a.Balance = %d, %t.  Want 0, true", p, ok)
 	}
 }
+
+// The benchmark operations are here to encourage you to try different
+// implementations to see which ones perform better. These are worth
+// exploring after the tests pass.
+//
+// There is a basic benchmark and a parallelized version of the same
+// benchmark. You run the benchmark using:
+// go test --bench=.
+//
+// The output will look something like this:
+// goos: linux
+// goarch: amd64
+// BenchmarkAccountOperations-8             10000000        130 ns/op
+// BenchmarkAccountOperationsParallel-8     3000000         488 ns/op
+// PASS
+//
+// You will notice that parallelism does not increase speed in this case, in
+// fact it makes things slower! This is because none of the operations in our
+// Account benefit from parallel processing. We are specifically protecting
+// the account balance internals from being accessed by multiple processes
+// simultaneously. Your protections will make the parallel processing slower
+// because there is some overhead in managing the processes and protections.
+//
+// The interesting thing to try here is to experiment with the protections
+// and see how their implementation changes the results of the parallel
+// benchmark.
+func BenchmarkAccountOperations(b *testing.B) {
+	a := Open(0)
+	defer a.Close()
+	for n := 0; n < b.N; n++ {
+		a.Deposit(10)
+		a.Deposit(-10)
+	}
+}
+
+func BenchmarkAccountOperationsParallel(b *testing.B) {
+	a := Open(0)
+	defer a.Close()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			a.Deposit(10)
+			a.Deposit(-10)
+		}
+	})
+}

data/tracks/go/exercises/error-handling/common.go

@@ -2,6 +2,16 @@ package erratum
 
 import "io"
 
+// These are the support types and interface definitions used in the
+// implementation if your Use function. See the test suite file at
+// for information on the expected implementation.
+//
+// Because this is part of the package "erratum", if your solution file
+// is also declared in the package you will automatically have access to
+// these definitions (you do not have to re-declare them).
+
+// TransientError is an error that may occur while opening a resource via
+// ResourceOpener.
 type TransientError struct {
 	err error
 }
@@ -10,6 +20,10 @@ func (e TransientError) Error() string {
 	return e.err.Error()
 }
 
+// FrobError is a possible error from doing some frobbing, your implementation
+// will require calling your Resource's Defrob(string) method.
+// When this error occurs, the FrobError's defrobTag string will contain the
+// string you must pass into Defrob.
 type FrobError struct {
 	defrobTag string
 	inner     error
@@ -20,6 +34,9 @@ func (e FrobError) Error() string {
 }
 
 type Resource interface {
+
+	// Resource is using composition to inherit the requirements of the io.Closer
+	// interface. What this means is that a Resource will have a .Close() method.
 	io.Closer
 
 	// Frob does something with the input string.

data/tracks/go/exercises/error-handling/error_handling_test.go

@@ -5,10 +5,43 @@ import (
 	"testing"
 )
 
-// Define a function `Use(o ResourceOpener, input string) error` that
-// opens a resource, calls Frob(input) and closes the resource
-// (in all cases). The function should properly handle errors,
-// as defined by the expectations of this test suite.
+// Because this exercise is generally unique to each language and how it
+// handles errors, most of the definition of your expected solution is provided
+// here instead of the README.
+// You should read this carefully (more than once) before implementation.
+
+// Define a function `Use(o ResourceOpener, input string) error` that opens a
+// resource, calls Frob(input) and closes the resource (in all cases). Your
+// function should properly handle errors, as defined by the expectations of
+// this test suite. ResourceOpener will be a function you may invoke directly
+// `o()` in an attempt to "open" the resource. It returns a Resource and error
+// value in the idiomatic Go fashion:
+// https://blog.golang.org/error-handling-and-go
+//
+// See the ./common.go file for the definitions of Resource, ResourceOpener,
+// FrobError and TransientError.
+//
+// There will be a few places in your Use function where errors may occur:
+//
+// - Invoking the ResourceOpener function passed into Use as the first
+//   parameter, it may fail with a TransientError, if so keep trying to open it.
+//   If it is some other sort of error, return it.
+//
+// - Calling the Frob function on the Resource returned from the ResourceOpener
+//   function, it may panic with a FrobError (or another type of error). If
+//   it is indeed a FrobError you will have to call the Resource's Defrob
+//   function using the FrobError's defrobTag variable as input. Either way
+//   return the error.
+//
+// Also note: if the Resource was opened successfully make sure to call its
+// Close function no matter what (even if errors occur).
+//
+// If you are new to Go errors or panics here is a good place to start:
+// https://blog.golang.org/defer-panic-and-recover
+//
+// You may also need to look at named return values as a helpful way to
+// return error information from panic recovery:
+// https://tour.golang.org/basics/7
 
 const targetTestVersion = 2
 

data/tracks/haskell/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "haskell",
   "language": "Haskell",
-  "repository": "https://github.com/exercism/haskell",
   "active": true,
   "exercises": [
     {

data/tracks/java/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "java",
   "language": "Java",
-  "repository": "https://github.com/exercism/java",
   "active": true,
   "exercises": [
     {
@@ -768,6 +766,16 @@
 
       ]
     },
+    {
+      "uuid": "f0c0316d-3fb5-455e-952a-91161e7fb298",
+      "slug": "forth",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 9,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "377fe38b-08ad-4f3a-8118-a43c10f7b9b2",
       "slug": "custom-set",

data/tracks/java/exercises/forth/README.md

@@ -0,0 +1,41 @@
+# Forth
+
+Implement an evaluator for a very simple subset of Forth.
+
+[Forth](https://en.wikipedia.org/wiki/Forth_%28programming_language%29)
+is a stack-based programming language. Implement a very basic evaluator
+for a small subset of Forth.
+
+Your evaluator has to support the following words:
+
+- `+`, `-`, `*`, `/` (integer arithmetic)
+- `DUP`, `DROP`, `SWAP`, `OVER` (stack manipulation)
+
+Your evaluator also has to support defining new words using the
+customary syntax: `: word-name definition ;`.
+
+To keep things simple the only data type you need to support is signed
+integers of at least 16 bits size.
+
+You should use the following rules for the syntax: a number is a
+sequence of one or more (ASCII) digits, a word is a sequence of one or
+more letters, digits, symbols or punctuation that is not a number.
+(Forth probably uses slightly different rules, but this is close
+enough.)
+
+Words are case-insensitive.
+
+
+To run the tests:
+
+```sh
+$ gradle test
+```
+
+For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
+
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

data/tracks/java/exercises/forth/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

data/tracks/java/exercises/forth/src/example/java/ForthEvaluator.java

@@ -0,0 +1,154 @@
+import java.util.*;
+import java.util.function.UnaryOperator;
+
+class ForthEvaluator {
+
+    private static final Map<String, UnaryOperator<Deque<Integer>>> BUILT_IN_OPS
+            = new HashMap<String, UnaryOperator<Deque<Integer>>>() {{
+
+                put("+", values -> {
+                    if (values.size() < 2) {
+                        throw new IllegalArgumentException(
+                                "Addition requires that the stack contain at least 2 values");
+                    }
+
+                    values.push(values.pop() + values.pop());
+                    return values;
+                });
+
+                put("-", values -> {
+                    if (values.size() < 2) {
+                        throw new IllegalArgumentException(
+                                "Subtraction requires that the stack contain at least 2 values");
+                    }
+
+                    int topValue = values.pop();
+                    int secondValue = values.pop();
+
+                    values.push(secondValue - topValue);
+                    return values;
+                });
+
+                put("*", values -> {
+                    if (values.size() < 2) {
+                        throw new IllegalArgumentException(
+                                "Multiplication requires that the stack contain at least 2 values");
+                    }
+
+                    values.push(values.pop() * values.pop());
+                    return values;
+                });
+
+                put("/", values -> {
+                    if (values.size() < 2) {
+                        throw new IllegalArgumentException(
+                                "Division requires that the stack contain at least 2 values");
+                    }
+
+                    int topValue = values.pop();
+                    int secondValue = values.pop();
+
+                    if (topValue == 0) {
+                        throw new IllegalArgumentException("Division by 0 is not allowed");
+                    }
+
+                    values.push(secondValue / topValue);
+                    return values;
+                });
+
+                put("dup", values -> {
+                    if (values.isEmpty()) {
+                        throw new IllegalArgumentException(
+                                "Duplicating requires that the stack contain at least 1 value");
+                    }
+
+                    values.push(values.peek());
+                    return values;
+                });
+
+                put("drop", values -> {
+                    if (values.isEmpty()) {
+                        throw new IllegalArgumentException(
+                                "Dropping requires that the stack contain at least 1 value");
+                    }
+
+                    values.pop();
+                    return values;
+                });
+
+                put("swap", values -> {
+                    if (values.size() < 2) {
+                        throw new IllegalArgumentException(
+                                "Swapping requires that the stack contain at least 2 values");
+                    }
+
+                    int topValue = values.pop();
+                    int secondValue = values.pop();
+                    values.push(topValue);
+                    values.push(secondValue);
+                    return values;
+                });
+
+                put("over", values -> {
+                    if (values.size() < 2) {
+                        throw new IllegalArgumentException(
+                                "Overing requires that the stack contain at least 2 values");
+                    }
+
+                    int topValue = values.pop();
+                    int secondValue = values.peek();
+                    values.push(topValue);
+                    values.push(secondValue);
+                    return values;
+                });
+    }};
+
+    private Deque<Integer> values = new ArrayDeque<>();
+
+    private List<Token> tokens = new ArrayList<>();
+
+    private Map<String, List<Token>> userOps = new HashMap<>();
+
+    List<Integer> evaluateProgram(final List<String> program) {
+        parse(program);
+        evaluate();
+
+        final List<Integer> result = new ArrayList<>(values);
+        Collections.reverse(result);
+        return result;
+    }
+
+    private void parse(final List<String> program) {
+        program.forEach(string -> tokens.addAll(Token.fromString(string)));
+    }
+
+    private void evaluate() {
+        while (!tokens.isEmpty()) {
+            final Token token = tokens.remove(0);
+
+            if (token instanceof Token.OpDefToken) {
+                final Token.OpDefToken opDefToken = (Token.OpDefToken) token;
+                userOps.put(opDefToken.getNewOp().toLowerCase(), opDefToken.getNewOpDefTokens());
+            } else if (token instanceof Token.OpToken) {
+                evaluateOpToken((Token.OpToken) token);
+            } else if (token instanceof Token.IntToken) {
+                values.push(((Token.IntToken) token).getRawValue());
+            }
+        }
+    }
+
+    private void evaluateOpToken(final Token.OpToken opToken) {
+        final String op = opToken.getOp();
+
+        if (userOps.containsKey(op)) {
+            final List<Token> replacementOps = userOps.get(op);
+            Collections.reverse(replacementOps);
+            replacementOps.forEach(token -> tokens.add(0, token));
+        } else if (BUILT_IN_OPS.containsKey(op)) {
+            values = BUILT_IN_OPS.get(op).apply(values);
+        } else {
+            throw new IllegalArgumentException("No definition available for operator \"" + op + "\"");
+        }
+    }
+
+}

data/tracks/java/exercises/forth/src/example/java/Token.java

@@ -0,0 +1,90 @@
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+class Token {
+
+    static class OpDefToken extends Token {
+
+        static OpDefToken opDefTokenFromString(final String string) {
+            final String trimmedLine = string.substring(2, string.length() - 2);
+            final int newOpEnd = trimmedLine.indexOf(" ");
+
+            if (newOpEnd == -1) {
+                throw new IllegalArgumentException("Incomplete operation definition");
+            }
+
+            final Token newOpToken = Token.fromString(trimmedLine.substring(0, newOpEnd)).get(0);
+
+            if (!(newOpToken instanceof OpToken)) {
+                throw new IllegalArgumentException("Cannot redefine numbers");
+            }
+
+            final List<Token> newOpDefTokens = Token.fromString(trimmedLine.substring(newOpEnd + 1));
+            return new OpDefToken(((OpToken) newOpToken).getOp(), newOpDefTokens);
+        }
+
+        private final String newOp;
+
+        private final List<Token> newOpDefTokens;
+
+        private OpDefToken(final String newOp, final List<Token> newOpDefTokens) {
+            this.newOp = newOp;
+            this.newOpDefTokens = newOpDefTokens;
+        }
+
+        String getNewOp() {
+            return newOp;
+        }
+
+        List<Token> getNewOpDefTokens() {
+            return newOpDefTokens;
+        }
+
+    }
+
+    static class OpToken extends Token {
+
+        private final String op;
+
+        OpToken(final String op) {
+            this.op = op;
+        }
+
+        String getOp() {
+            return op;
+        }
+
+    }
+
+    static class IntToken extends Token {
+
+        private final int rawValue;
+
+        IntToken(final int rawValue) {
+            this.rawValue = rawValue;
+        }
+
+        int getRawValue() {
+            return rawValue;
+        }
+
+    }
+
+    static List<Token> fromString(final String string) {
+        if (string.startsWith(":")) {
+            return Collections.singletonList(OpDefToken.opDefTokenFromString(string));
+        } else if (string.matches("[A-z+/*\\-]+(?:-[A-z+/*\\-]+)*")) {
+            return Collections.singletonList(new OpToken(string.toLowerCase()));
+        } else if (string.matches("\\d+")) {
+            return Collections.singletonList(new IntToken(Integer.parseInt(string)));
+        } else {
+            return Arrays.stream(string.split(" "))
+                    .map(Token::fromString)
+                    .flatMap(List::stream)
+                    .collect(Collectors.toList());
+        }
+    }
+
+}