trackler 2.0.3.2 → 2.0.3.3

data/tracks/ecmascript/exercises/rna-transcription/example.js

@@ -7,7 +7,14 @@ const DNA_TO_RNA = {
 
 export default class Transcriptor {
   toRna(dna) {
-    return dna.replace(/./g, nucleotide => DNA_TO_RNA[nucleotide]);
+    let rna = dna.replace(/./g, nucleotide => DNA_TO_RNA[nucleotide])
+
+    if (rna.length !== dna.length) {
+      // invalid characters in the strand
+      throw new Error('Invalid input DNA.');
+    }
+    else {
+      return rna;
+    }
   }
 }
-

data/tracks/ecmascript/exercises/rna-transcription/rna-transcription.spec.js

@@ -24,4 +24,22 @@ describe('Transcriptor', () => {
         .toEqual('UGCACCAGAAUU');
   });
 
+  xit('correctly handles invalid input', () => {
+    expect(() => transcriptor.toRna('U')).toThrow(
+      new Error('Invalid input DNA.')
+    );
+  });
+
+  xit('correctly handles completely invalid input', () => {
+    expect(() => transcriptor.toRna('XXX')).toThrow(
+      new Error('Invalid input DNA.')
+    );
+  });
+
+  xit('correctly handles partially invalid input', () => {
+    expect(() => transcriptor.toRna('ACGTXXXCTTAA')).toThrow(
+      new Error('Invalid input DNA.')
+    );
+  });
+
 });

data/tracks/go/exercises/hello-world/example.go

@@ -1,7 +1,9 @@
-package hello
+package greeting
 
-const testVersion = 2
+const testVersion = 3
 
+// HelloWorld says hello to given name.
+// If no name is passed, it greets the world.
 func HelloWorld(name string) string {
 	if name == "" {
 		name = "World"

data/tracks/go/exercises/hello-world/hello_test.go

@@ -1,4 +1,4 @@
-package hello
+package greeting
 
 import "testing"
 
@@ -7,7 +7,7 @@ import "testing"
 // Also define a testVersion with a value that matches
 // the targetTestVersion here.
 
-const targetTestVersion = 2
+const targetTestVersion = 3
 
 func TestHelloWorld(t *testing.T) {
 	tests := []struct {
@@ -15,10 +15,10 @@ func TestHelloWorld(t *testing.T) {
 	}{
 		{"", "Hello, World!"},
 		{"Gopher", "Hello, Gopher!"},
+		{"ゴーファー", "Hello, ゴーファー!"},
 	}
 	for _, test := range tests {
-		observed := HelloWorld(test.name)
-		if observed != test.expected {
+		if observed := HelloWorld(test.name); observed != test.expected {
 			t.Fatalf("HelloWorld(%s) = %v, want %v", test.name, observed, test.expected)
 		}
 	}

data/tracks/go/exercises/hello-world/hello_world.go

@@ -1,23 +1,23 @@
 // This is a "stub" file.  It's a little start on your solution.
 // It's not a complete solution though; you have to write some code.
 
-// The package name is expected by the test program.
-// It has to stay just the way it is.
-package hello
+// Package greeting should have a package comment that summarizes what it's about.
+// https://golang.org/doc/effective_go.html#commentary
+package greeting
 
 // testVersion identifies the version of the test program that you are
 // writing your code to. If the test program changes in the future --
 // after you have posted this code to the Exercism site -- nitpickers
 // will see that your code can't necessarily be expected to pass the
 // current test suite because it was written to an earlier test version.
-const testVersion = 2
+const testVersion = 3
 
-// It's good style to write a comment here documenting HelloWorld.
-// (But delete all these instructional comments!)
+// HelloWorld needs a comment documenting it as package does.
 func HelloWorld(string) string {
 	// Write some code here to pass the test suite.
 
 	// When you have a working solution, REMOVE ALL THE STOCK COMMENTS.
 	// They're here to help you get started but they only clutter a finished solution.
 	// If you leave them in, nitpickers will protest!
+	return ""
 }

data/tracks/groovy/config.json

@@ -73,6 +73,11 @@
       "difficulty": 1,
       "slug": "word-count",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "phone-number",
+      "topics": []
     }
   ]
 }

data/tracks/groovy/exercises/phone-number/Example.groovy

@@ -0,0 +1,20 @@
+class PhoneNumber {
+
+    private static def REGEX = ~/^1?[\s\.\-\(]*(\d{3})[\s\.\-\)]*\s?(\d{3})[\s\.\-]*(\d{4})$/
+
+    String areaCode = '000', exchange = '000', subscriber = '0000'
+
+    public PhoneNumber(String input) {
+        def matcher = REGEX.matcher(input)
+        if ( matcher.matches() ) {
+            areaCode   = "${matcher.group(1)}"
+            exchange   = "${matcher.group(2)}"
+            subscriber = "${matcher.group(3)}"
+        }
+    }
+
+    String getNumber() { "${areaCode}${exchange}${subscriber}" }
+
+    String toString() { "(${areaCode}) ${exchange}-${subscriber}" }
+
+}

data/tracks/groovy/exercises/phone-number/PhoneNumberSpec.groovy

@@ -0,0 +1,75 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class PhoneNumberSpec extends Specification {
+
+    def 'a phone number is valid'() {
+        expect: new PhoneNumber('(123) 456-7890').number == '1234567890'
+    }
+
+    @Ignore
+    def 'a different phone number is valid'() {
+        expect: new PhoneNumber('(987) 654-3210').number == '9876543210'
+    }
+
+    @Ignore
+    def 'a phone nubmer separated by dots is valid'() {
+        expect: new PhoneNumber('456.123.7890').number == '4561237890'
+    }
+
+    @Ignore
+    def 'a letter-containing phone number is invalid'() {
+        expect: new PhoneNumber('123-abc-1234').number == '0000000000'
+    }
+
+    @Ignore
+    def 'a 9-digit number is invalid'() {
+        expect: new PhoneNumber('123456789').number == '0000000000'
+    }
+
+    @Ignore
+    def 'an 11-digit number starting with a 1 is valid'() {
+        expect: new PhoneNumber('19876543210').number == '9876543210'
+    }
+
+    @Ignore
+    def 'a 10-digit number, with an area code starting with 1, is valid'() {
+        expect: new PhoneNumber('1234567890').number == '1234567890'
+    }
+
+    @Ignore
+    def 'an 11-digit number, not beginning with a 1, is invalid'(){
+        expect: new PhoneNumber('21234567890').number == '0000000000'
+    }
+
+    @Ignore
+    def 'a 12-digit number, even one beginning with a 1, is invalid'(){
+        expect: new PhoneNumber('112345678901').number == '0000000000'
+    }
+
+    @Ignore
+    def 'a 10-digit number containing letters is inavlid'() {
+        expect: new PhoneNumber('1a2a3a4a5a6a7a8a9a0a').number == '0000000000'
+    }
+
+    @Ignore
+    def 'can extract area code from a phone number'() {
+        expect: new PhoneNumber('1234567890').areaCode == '123'
+    }
+
+    @Ignore
+    def 'can extract an area code from a different phone number'() {
+        expect: new PhoneNumber('9876543210').areaCode == '987'
+    }
+
+    @Ignore
+    def 'can pretty print a phone number'() {
+        expect: new PhoneNumber('5551234567').toString() == '(555) 123-4567'
+    }
+
+    @Ignore
+    def 'can pretty print a full U.S. phone number'() {
+        expect: new PhoneNumber('11234567890').toString() == '(123) 456-7890'
+    }
+
+}

data/tracks/haskell/exercises/difference-of-squares/test/Tests.hs

@@ -64,7 +64,9 @@ specs = describe "differenceOfSquares" $ do
           difference (12 :: Integer)
           `shouldBe` (5434 :: Integer)
 
+      {-
       describe "huge difference" $
         it "difference (1234567890 :: Integer)" $
           difference (1234567890 :: Integer)
           `shouldBe` (580764307309260838625720836817589660 :: Integer)
+      -}

data/tracks/java/config.json

@@ -52,7 +52,9 @@
     "robot-simulator",
     "bracket-push",
     "pythagorean-triplet",
-    "binary-search-tree"
+    "binary-search-tree",
+    "binary-search",
+    "all-your-base"
   ],
   "exercises": [
     {
@@ -299,6 +301,16 @@
       "slug": "binary-search-tree",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "binary-search",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "all-your-base",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/all-your-base/build.gradle

@@ -0,0 +1,17 @@
+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/all-your-base/src/example/java/BaseConverter.java

@@ -0,0 +1,80 @@
+import java.util.Arrays;
+
+final class BaseConverter {
+
+    private static final int MINIMUM_VALID_BASE = 2;
+
+    private static final String INVALID_BASE_ERROR_MESSAGE = "Bases must be at least 2.";
+
+    private final int numeral;
+
+    BaseConverter(final int originalBase, final int[] originalDigits) {
+        validateInputs(originalBase, originalDigits);
+        this.numeral = computeNumeral(originalBase, originalDigits);
+    }
+
+    int[] convertToBase(final int newBase) {
+        if (newBase < MINIMUM_VALID_BASE) {
+            throw new IllegalArgumentException(INVALID_BASE_ERROR_MESSAGE);
+        }
+
+        final int largestExponent = computeLargestExponentForBase(newBase);
+        final int[] result = new int[largestExponent + 1];
+        int remainder = numeral;
+
+        for (int currentExponent = largestExponent; currentExponent >= 0; currentExponent--) {
+            final int coefficient = (int) Math.floor(remainder / Math.pow(newBase, currentExponent));
+
+            result[largestExponent - currentExponent] = coefficient;
+
+            remainder -= coefficient * Math.pow(newBase, currentExponent);
+        }
+
+        return result;
+    }
+
+    private void validateInputs(final int originalBase, final int[] originalDigits) {
+        if (originalBase < MINIMUM_VALID_BASE) {
+            throw new IllegalArgumentException(INVALID_BASE_ERROR_MESSAGE);
+        }
+
+        if (originalDigits.length == 0) {
+            throw new IllegalArgumentException("You must supply at least one digit.");
+        }
+
+        if (originalDigits.length > 1 && originalDigits[0] == 0) {
+            throw new IllegalArgumentException("Digits may not contain leading zeros.");
+        }
+
+        if (Arrays.stream(originalDigits).min().getAsInt() < 0) {
+            throw new IllegalArgumentException("Digits may not be negative.");
+        }
+
+        if (Arrays.stream(originalDigits).max().getAsInt() >= originalBase) {
+            throw new IllegalArgumentException("All digits must be strictly less than the base.");
+        }
+    }
+
+    private int computeNumeral(final int originalBase, final int[] originalDigits) {
+        int result = 0;
+
+        final int largestExponent = originalDigits.length - 1;
+
+        for (int currentExponent = largestExponent; currentExponent >= 0; currentExponent--) {
+            result += originalDigits[largestExponent - currentExponent] * Math.pow(originalBase, currentExponent);
+        }
+
+        return result;
+    }
+
+    private int computeLargestExponentForBase(final int newBase) {
+        int result = 0;
+
+        while (Math.pow(newBase, result + 1) < numeral) {
+            result += 1;
+        }
+
+        return result;
+    }
+
+}

data/tracks/java/exercises/all-your-base/src/main/java/BaseConverter.java

@@ -0,0 +1,5 @@
+final class BaseConverter {
+
+
+
+}

data/tracks/java/exercises/all-your-base/src/test/java/BaseConverterTest.java

@@ -0,0 +1,256 @@
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public final class BaseConverterTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testSingleBitOneToDecimal() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
+
+        final int[] expectedDigits = new int[]{1};
+        final int[] actualDigits = baseConverter.convertToBase(10);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testBinaryToSingleDecimal() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
+
+        final int[] expectedDigits = new int[]{5};
+        final int[] actualDigits = baseConverter.convertToBase(10);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testSingleDecimalToBinary() {
+        final BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
+
+        final int[] expectedDigits = new int[]{1, 0, 1};
+        final int[] actualDigits = baseConverter.convertToBase(2);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testBinaryToMultipleDecimal() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+
+        final int[] expectedDigits = new int[]{4, 2};
+        final int[] actualDigits = baseConverter.convertToBase(10);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testDecimalToBinary() {
+        final BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
+
+        final int[] expectedDigits = new int[]{1, 0, 1, 0, 1, 0};
+        final int[] actualDigits = baseConverter.convertToBase(2);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testTrinaryToHexadecimal() {
+        final BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
+
+        final int[] expectedDigits = new int[]{2, 10};
+        final int[] actualDigits = baseConverter.convertToBase(16);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testHexadecimalToTrinary() {
+        final BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
+
+        final int[] expectedDigits = new int[]{1, 1, 2, 0};
+        final int[] actualDigits = baseConverter.convertToBase(3);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void test15BitInteger() {
+        final BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
+
+        final int[] expectedDigits = new int[]{6, 10, 45};
+        final int[] actualDigits = baseConverter.convertToBase(73);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testEmptyDigits() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply at least one digit.");
+
+        new BaseConverter(2, new int[]{});
+    }
+
+    @Test
+    public void testSingleZero() {
+        final BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
+
+        final int[] expectedDigits = new int[]{0};
+        final int[] actualDigits = baseConverter.convertToBase(2);
+
+        assertArrayEquals(
+                String.format(
+                        "Expected digits: %s but found digits: %s",
+                        Arrays.toString(expectedDigits),
+                        Arrays.toString(actualDigits)),
+                expectedDigits,
+                actualDigits);
+    }
+
+    @Test
+    public void testMultipleZeros() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Digits may not contain leading zeros.");
+
+        new BaseConverter(10, new int[]{0, 0, 0});
+    }
+
+    @Test
+    public void testLeadingZeros() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Digits may not contain leading zeros.");
+
+        new BaseConverter(7, new int[]{0, 6, 0});
+    }
+
+    @Test
+    public void testNegativeDigit() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Digits may not be negative.");
+
+        new BaseConverter(2, new int[]{1, -1, 1, 0, 1, 0});
+    }
+
+    @Test
+    public void testInvalidPositiveDigit() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("All digits must be strictly less than the base.");
+
+        new BaseConverter(2, new int[]{1, 2, 1, 0, 1, 0});
+    }
+
+    @Test
+    public void testFirstBaseIsOne() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Bases must be at least 2.");
+
+        new BaseConverter(1, new int[]{});
+    }
+
+    @Test
+    public void testSecondBaseIsOne() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Bases must be at least 2.");
+
+        baseConverter.convertToBase(1);
+    }
+
+    @Test
+    public void testFirstBaseIsZero() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Bases must be at least 2.");
+
+        new BaseConverter(0, new int[]{});
+    }
+
+    @Test
+    public void testSecondBaseIsZero() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Bases must be at least 2.");
+
+        baseConverter.convertToBase(0);
+    }
+
+    @Test
+    public void testFirstBaseIsNegative() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Bases must be at least 2.");
+
+        new BaseConverter(-2, new int[]{});
+    }
+
+    @Test
+    public void testSecondBaseIsNegative() {
+        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Bases must be at least 2.");
+
+        baseConverter.convertToBase(-7);
+    }
+
+}