trackler 2.2.1.74 → 2.2.1.75

data/tracks/go/exercises/all-your-base/example.go

@@ -5,19 +5,16 @@ import (
 	"math"
 )
 
-var (
-	ErrInvalidBase  = errors.New("invalid base given")
-	ErrInvalidDigit = errors.New("invalid digit given")
-)
-
-func ConvertToBase(inputBase uint64, inputDigits []uint64, outputBase uint64) ([]uint64, error) {
-	if inputBase < 2 || outputBase < 2 {
-		return nil, ErrInvalidBase
+// ConvertToBase converts given digits in input base to given output base
+func ConvertToBase(inputBase int, inputDigits []int, outputBase int) ([]int, error) {
+	if inputBase < 2 {
+		return nil, errors.New("input base must be >= 2")
+	} else if outputBase < 2 {
+		return nil, errors.New("output base must be >= 2")
 	}
-
 	for _, d := range inputDigits {
-		if d >= inputBase {
-			return nil, ErrInvalidDigit
+		if d < 0 || d >= inputBase {
+			return nil, errors.New("all digits must satisfy 0 <= d < input base")
 		}
 	}
 
@@ -25,34 +22,33 @@ func ConvertToBase(inputBase uint64, inputDigits []uint64, outputBase uint64) ([
 	return digitsInBase(total, outputBase), nil
 }
 
-func toCanonicalBase(inputBase uint64, inputDigits []uint64) uint64 {
-	var total uint64
+func toCanonicalBase(base int, digits []int) int {
+	var total int
 
-	digits := len(inputDigits)
-	for i := digits - 1; i >= 0; i-- {
-		total += inputDigits[digits-1-i] * uint64(math.Pow(float64(inputBase), float64(i)))
+	l := len(digits)
+	for i := l - 1; i >= 0; i-- {
+		total += digits[l-1-i] * int(math.Pow(float64(base), float64(i)))
 	}
 
 	return total
 }
 
-func reverse(digits []uint64) []uint64 {
-	var output = make([]uint64, len(digits))
-
-	for i, d := range digits {
-		output[len(digits)-1-i] = d
+func reverse(a []int) []int {
+	for i := len(a)/2 - 1; i >= 0; i-- {
+		opp := len(a) - 1 - i
+		a[i], a[opp] = a[opp], a[i]
 	}
-
-	return output
+	return a
 }
 
-func digitsInBase(total uint64, outputBase uint64) []uint64 {
-	var digits []uint64
-	for total >= outputBase {
-		digits = append(digits, total%outputBase)
-		total /= outputBase
+func digitsInBase(total, base int) []int {
+	var digits []int
+
+	for total >= base {
+		digits = append(digits, total%base)
+		total /= base
 	}
-	digits = append(digits, total%outputBase)
+	digits = append(digits, total%base)
 
 	return reverse(digits)
 }

data/tracks/java/CONTRIBUTING.md

@@ -171,7 +171,7 @@ You can do this by:
 
   2. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
 
-  3. Run `configlet generate . --only name_of_new_exercise` from the root of this repository.
+  3. Run `configlet generate . --only name_of_new_exercise --spec-path path_to_problem_specifications` from the root of this repository.
 
 * Check if there is canonical data for the exercise you're adding.
 This can be found at `https://github.com/exercism/problem-specifications/tree/master/exercises/EXERCISE-SLUG/canonical-data.json`.

data/tracks/java/POLICIES.md

@@ -17,7 +17,7 @@ Our policies are not set-in-stone. They represent directions chosen at a point i
 
 | Track Event | Policies to review |
 |:------------|:-----------------|
-| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test)
+| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation)
 | Track rearranged | [Starter implementations](#starter-implementations); [Multiple file submissions](#multiple-file-submissions) |
 | New issue observed in track | [Good first patches](#good-first-patches) |
 | "Good first patch" issue completed | [Good first patches](#good-first-patches) |
@@ -79,3 +79,17 @@ References: [[1](https://github.com/exercism/java/issues/395#issue-215734887)]
 > The exception to this is if the tests are split into several test classes where each test class tests different functionality. In that case each class should be named `SomeClassNameFunctionalityTest` where `Functionality` is the name of the functionality to be tested in that class. See the [clock exercise](https://github.com/exercism/java/tree/master/exercises/clock) as an example.
 
 References: [[1](https://github.com/exercism/java/issues/697)]
+
+### Add hint for the first exercises without starter implementation
+
+> According to the starter implementation policy, any exercise with difficulty 4 or lower should have starter implementation.
+> Any exercise with difficulty 5 or above will have no starter implementation (unless its signature is very complicated).
+> This could be confusing to users when tackling their first exercise with difficulty 5 when they are used to starter implementation being provided.
+
+> Therefore a hints.md file should be added to the .meta directory for every exercise with difficulty 5.
+> This file should explain what they need to do when there is no starter implementation.
+> The files should all be the same so you can copy it from any other exercise with difficulty 5, e.g. [flatten-array](https://github.com/exercism/java/tree/master/exercises/flatten-array/.meta/hints.md).
+
+> We add the file to every exercise with difficulty 5 because the structure of the track means that we don't know which exercise will be the first one without starter implementation that a user will be faced with.
+
+References: [[1](https://github.com/exercism/java/issues/1075)]

data/tracks/java/exercises/flatten-array/.meta/hints.md

@@ -0,0 +1,58 @@
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

data/tracks/java/exercises/flatten-array/README.md

@@ -10,6 +10,68 @@ input: [1,[2,3,null,4],[null],5]
 
 output: [1,2,3,4,5]
 
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/java/exercises/hamming/src/main/java/Hamming.java

@@ -1,4 +1,4 @@
-public class Hamming {
+class Hamming {
 
     Hamming(String leftStrand, String rightStrand) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");

data/tracks/java/exercises/matrix/.meta/src/reference/java/Matrix.java

@@ -1,11 +1,11 @@
 import java.util.regex.Pattern;
 
-public class Matrix {
+class Matrix {
     private int[][] matrix;
     private static Pattern spacePattern = Pattern.compile(" ");
     private static Pattern newlinePattern = Pattern.compile("\\n");
 
-    public Matrix(String matrixAsString) {
+     Matrix(String matrixAsString) {
         String[] rows = newlinePattern.split(matrixAsString);
         matrix = new int[rows.length][];
         for (int i = 0; i < rows.length; i++) {
@@ -17,11 +17,11 @@ public class Matrix {
         }
     }
 
-    public int[] getRow(int rowNumber) {
+    int[] getRow(int rowNumber) {
         return matrix[rowNumber];
     }
 
-    public int[] getColumn(int columnNumber) {
+    int[] getColumn(int columnNumber) {
         int[] column = new int[matrix.length];
         for(int i = 0; i < matrix.length; i++) {
             column[i] = matrix[i][columnNumber];
@@ -29,11 +29,11 @@ public class Matrix {
         return column;
     }
 
-    public int getRowsCount() {
+    int getRowsCount() {
         return matrix.length;
     }
 
-    public int getColumnsCount() {
+    int getColumnsCount() {
         return matrix[0].length;
     }
 }

data/tracks/java/exercises/meetup/.meta/src/reference/java/Meetup.java

@@ -2,10 +2,10 @@ import java.time.LocalDate;
 import java.time.DayOfWeek;
 
 
-public class Meetup {
+class Meetup {
     private final LocalDate startOfMonth;
 
-    public Meetup(int monthOfYear, int year) {
+    Meetup(int monthOfYear, int year) {
         startOfMonth = LocalDate.of(year, monthOfYear, 1);
     }
 

data/tracks/java/exercises/meetup/.meta/src/reference/java/MeetupSchedule.java

@@ -1,4 +1,4 @@
-public enum MeetupSchedule {
+enum MeetupSchedule {
     FIRST,
     SECOND,
     THIRD,

data/tracks/java/exercises/meetup/src/main/java/MeetupSchedule.java

@@ -1,4 +1,4 @@
-public enum MeetupSchedule {
+enum MeetupSchedule {
     FIRST,
     SECOND,
     THIRD,

data/tracks/java/exercises/pig-latin/.meta/hints.md

@@ -0,0 +1,58 @@
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+```
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

data/tracks/java/exercises/pig-latin/README.md

@@ -17,6 +17,67 @@ variants too.
 
 See <http://en.wikipedia.org/wiki/Pig_latin> for more details.
 
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+```
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
 # Running the tests
 
 You can run all the tests for an exercise by entering