trackler 2.2.1.66 → 2.2.1.67

data/tracks/fsharp/generators/Generators.fs

@@ -681,6 +681,9 @@ type RobotSimulator() =
          // because useFullMethodName leads to very long names
          sprintf "%s - %s" canonicalDataCase.Property (canonicalDataCase.Description |> String.upperCaseFirst)
 
+type RotationalCipher() =
+    inherit Exercise()
+
 type RnaTranscription() =
     inherit Exercise()
 

data/tracks/go/exercises/grains/.meta/gen.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"strings"
+	"text/template"
+
+	"../../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("grains", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Groups []testGroup `json:"Cases"`
+}
+
+type testGroup struct {
+	Description string
+	Cases       []json.RawMessage `property:"RAW"`
+	SquareCases []SquareCase      `property:"square"`
+	// Note: canonical-data.json has a element of "cases"
+	// which includes a test for property 'total', but it is ignored here,
+	// since "expected" is a single known value.
+}
+
+type SquareCase struct {
+	Description string
+	Input       int
+	Expected    interface{}
+}
+
+func (c SquareCase) HasAnswer() bool {
+	hasAnswer, _ := determineExpected(c.Expected)
+	return hasAnswer
+}
+
+func (c SquareCase) Answer() uint64 {
+	_, answer := determineExpected(c.Expected)
+	return answer
+}
+
+func (c SquareCase) EditedDescription() string {
+	// Go doesn't raise exceptions, so replace the wording in .Description.
+	return strings.Replace(c.Description, "raises an exception", "returns an error", 1)
+}
+
+// determineExpected examines an .Expected interface{} object and determines
+// whether a test case has an answer or expects an error.
+// The return values are true and answer or false and zero.
+func determineExpected(expected interface{}) (bool, uint64) {
+	ans, ok := expected.(float64)
+	if ok {
+		if ans == float64(-1) {
+			return false, 0
+		}
+		return true, uint64(ans)
+	}
+	return false, 0
+}
+
+var tmpl = `package grains
+
+{{.Header}}
+
+{{range .J.Groups}}
+	{{- if .SquareCases }}
+		// {{ .Description }}
+		var squareTests = []struct {
+			description string
+			input int
+			expectedVal uint64
+			expectError bool
+		}{
+			{{- range .SquareCases}}
+			{
+				description: "{{.EditedDescription}}",
+				input: {{.Input}},
+				{{- if .HasAnswer}}
+					expectedVal: {{.Answer}},
+				{{- else}}
+					expectError: true,
+				{{- end}}
+			},
+			{{- end }}
+		}
+	{{- end }}
+{{end}}
+`

data/tracks/go/exercises/grains/cases_test.go

@@ -0,0 +1,64 @@
+package grains
+
+// Source: exercism/problem-specifications
+// Commit: d4554e6 grains: fix a typo in comments of canonical data
+// Problem Specifications Version: 1.0.0
+
+// returns the number of grains on the square
+var squareTests = []struct {
+	description string
+	input       int
+	expectedVal uint64
+	expectError bool
+}{
+	{
+		description: "1",
+		input:       1,
+		expectedVal: 1,
+	},
+	{
+		description: "2",
+		input:       2,
+		expectedVal: 2,
+	},
+	{
+		description: "3",
+		input:       3,
+		expectedVal: 4,
+	},
+	{
+		description: "4",
+		input:       4,
+		expectedVal: 8,
+	},
+	{
+		description: "16",
+		input:       16,
+		expectedVal: 32768,
+	},
+	{
+		description: "32",
+		input:       32,
+		expectedVal: 2147483648,
+	},
+	{
+		description: "64",
+		input:       64,
+		expectedVal: 9223372036854775808,
+	},
+	{
+		description: "square 0 returns an error",
+		input:       0,
+		expectError: true,
+	},
+	{
+		description: "negative square returns an error",
+		input:       -1,
+		expectError: true,
+	},
+	{
+		description: "square greater than 64 returns an error",
+		input:       65,
+		expectError: true,
+	},
+}

data/tracks/go/exercises/grains/grains_test.go

@@ -4,41 +4,25 @@ import (
 	"testing"
 )
 
-var squareTests = []struct {
-	input       int
-	expectedVal uint64
-	expectError bool
-}{
-	{1, 1, false},
-	{2, 2, false},
-	{3, 4, false},
-	{4, 8, false},
-	{16, 32768, false},
-	{32, 2147483648, false},
-	{64, 9223372036854775808, false},
-	{65, 0, true},
-	{0, 0, true},
-	{-1, 0, true},
-}
-
 func TestSquare(t *testing.T) {
 	for _, test := range squareTests {
 		actualVal, actualErr := Square(test.input)
 
 		// check actualVal only if no error expected
 		if !test.expectError && actualVal != test.expectedVal {
-			t.Errorf("Square(%d) expected %d, Actual %d", test.input, test.expectedVal, actualVal)
+			t.Fatalf("FAIL: %s\nSquare(%d) expected %d, Actual %d", test.description, test.input, test.expectedVal, actualVal)
 		}
 
 		// if we expect an error and there isn't one
 		if test.expectError && actualErr == nil {
-			t.Errorf("Square(%d) expected an error, but error is nil", test.input)
+			t.Fatalf("FAIL: %s\nSquare(%d) expected an error, but error is nil", test.description, test.input)
 		}
 		// if we don't expect an error and there is one
 		if !test.expectError && actualErr != nil {
 			var _ error = actualErr
-			t.Errorf("Square(%d) expected no error, but error is: %s", test.input, actualErr)
+			t.Fatalf("FAIL: %s\nSquare(%d) expected no error, but error is: %s", test.description, test.input, actualErr)
 		}
+		t.Logf("PASS: %s", test.description)
 	}
 }
 

data/tracks/go/exercises/space-age/space_age_test.go

@@ -1,12 +1,14 @@
 package space
 
 import (
+	"math"
 	"testing"
 )
 
 func TestAge(t *testing.T) {
+	const precision = 0.01
 	for _, tc := range testCases {
-		if actual := Age(tc.seconds, tc.planet); actual != tc.expected {
+		if actual := Age(tc.seconds, tc.planet); math.Abs(actual-tc.expected) > precision {
 			t.Fatalf("FAIL: %s\nExpected: %#v\nActual: %#v", tc.description, tc.expected, actual)
 		}
 		t.Logf("PASS: %s", tc.description)

data/tracks/java/config.json

@@ -179,6 +179,18 @@
       "unlocked_by": "rna-transcription",
       "uuid": "331073b3-bd1a-4868-b767-a64ce9fd9d97"
     },
+    {
+      "core": false,
+      "difficulty": 4,
+      "slug": "isbn-verifier",
+      "topics": [
+        "integers",
+        "loops",
+        "strings"
+      ],
+      "unlocked_by": "hamming",
+      "uuid": "838bc1d7-b2de-482a-9bfc-c881b4ccb04c"
+    },
     {
       "core": false,
       "difficulty": 4,

data/tracks/java/exercises/beer-song/.meta/src/reference/java/BeerSong.java

@@ -1,5 +1,5 @@
-public class BeerSong {
-    public String verse(int number) {
+class BeerSong {
+    String verse(int number) {
         switch (number) {
             case 0:
                 return "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n\n";
@@ -12,7 +12,7 @@ public class BeerSong {
         }
     }
 
-    public String sing(int start, int stop) {
+    String sing(int start, int stop) {
         StringBuilder songOutput = new StringBuilder();
 
         for (int i=start; i>=stop; i--) {
@@ -22,7 +22,7 @@ public class BeerSong {
         return songOutput.toString();
     }
 
-    public String singSong() {
+    String singSong() {
         return sing(99,0);
     }
 }

data/tracks/java/exercises/diamond/src/main/java/DiamondPrinter.java

@@ -0,0 +1,9 @@
+import java.util.List;
+
+class DiamondPrinter {
+
+    List<String> printToList(char a) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/isbn-verifier/.meta/src/reference/java/IsbnVerifier.java

@@ -0,0 +1,35 @@
+class IsbnVerifier {
+
+    boolean isValid(String stringToVerify) {
+
+        String isbn = stringToVerify.replace("-", "");
+        int total = 0;
+
+        if (isbn.length() != 10) {
+            return false;
+        }
+
+        for (int i = 0; i < isbn.length() - 1; i++) {
+            char currentChar = isbn.charAt(i);
+            if(Character.isDigit(currentChar)) {
+                int currentCharVal = Character.getNumericValue(currentChar);
+                total += currentCharVal * (10 - i);
+            } else {
+                return false;
+            }
+        }
+
+        char finalChar = isbn.charAt(isbn.length() - 1);
+        if (Character.isDigit(finalChar)) {
+            total += Character.getNumericValue(finalChar);
+        } else if (finalChar == 'X') {
+            total += 10;
+        } else {
+            return false;
+        }
+
+        return total % 11 == 0;
+
+    }
+
+}

data/tracks/java/exercises/isbn-verifier/.meta/version

@@ -0,0 +1 @@
+2.0.0

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

@@ -0,0 +1,53 @@
+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 the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## 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/java/exercises/isbn-verifier/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/isbn-verifier/src/main/java/IsbnVerifier.java

@@ -0,0 +1,7 @@
+class IsbnVerifier {
+
+    boolean isValid(String stringToVerify) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/isbn-verifier/src/test/java/IsbnVerifierTest.java

@@ -0,0 +1,94 @@
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+public class IsbnVerifierTest {
+    private IsbnVerifier isbnVerifier;
+
+    @Before
+    public void setUp() {
+        isbnVerifier = new IsbnVerifier();
+    }
+
+    @Test
+    public void validIsbnNumber() {
+        assertTrue(isbnVerifier.isValid("3-598-21508-8"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void invalidIsbnCheckDigit() {
+        assertFalse(isbnVerifier.isValid("3-598-21508-9"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void validIsbnNumberWithCheckDigitOfTen() {
+        assertTrue(isbnVerifier.isValid("3-598-21507-X"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void checkDigitIsACharacterOtherThanX() {
+        assertFalse(isbnVerifier.isValid("3-598-21507-A"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void invalidCharacterInIsbn() {
+        assertFalse(isbnVerifier.isValid("3-598-2K507-0"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void xIsOnlyValidAsACheckDigit() {
+        assertFalse(isbnVerifier.isValid("3-598-2X507-9"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void validIsbnWithoutSeparatingDashes() {
+        assertTrue(isbnVerifier.isValid("3598215088"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void isbnWithoutSeparatingDashesAndXAsCheckDigit() {
+        assertTrue(isbnVerifier.isValid("359821507X"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void isbnWithoutCheckDigitAndDashes() {
+        assertFalse(isbnVerifier.isValid("359821507"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tooLongIsbnAndNoDashes() {
+        assertFalse(isbnVerifier.isValid("3598215078X"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void isbnWithoutCheckDigit() {
+        assertFalse(isbnVerifier.isValid("3-598-21507"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tooLongIsbn() {
+        assertFalse(isbnVerifier.isValid("3-598-21507-XX"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void checkDigitOfXShouldNotBeUsedForZero() {
+        assertFalse(isbnVerifier.isValid("3-598-21515-X"));
+    }
+
+}