trackler 2.0.8.11 → 2.0.8.12

data/tracks/java/exercises/ocr-numbers/src/main/java/OpticalCharacterReader.java

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

data/tracks/java/exercises/ocr-numbers/src/test/java/OpticalCharacterReaderTest.java

@@ -0,0 +1,248 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public final class OpticalCharacterReaderTest {
+
+    /*
+     * 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 testReaderRecognizesSingle0() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "| |",
+                "|_|",
+                "   "
+        ));
+
+        assertEquals("0", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle1() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "   ",
+                "  |",
+                "  |",
+                "   "
+        ));
+
+        assertEquals("1", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderReturnsQuestionMarkForUnreadableButCorrectlySizedInput() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "   ",
+                "  _",
+                "  |",
+                "   "
+        ));
+
+        assertEquals("?", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderThrowsExceptionWhenNumberOfInputLinesIsNotAMultipleOf4() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Number of input rows must be a positive multiple of 4");
+
+        new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "| |",
+                "   "
+        ));
+    }
+
+    @Ignore
+    @Test
+    public void testReaderThrowsExceptionWhenNumberOfInputColumnsIsNotAMultipleOf3() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Number of input columns must be a positive multiple of 3");
+
+        new OpticalCharacterReader().parse(Arrays.asList(
+                "    ",
+                "   |",
+                "   |",
+                "    "
+        ));
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesBinarySequence110101100() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "       _     _        _  _ ",
+                "  |  || |  || |  |  || || |",
+                "  |  ||_|  ||_|  |  ||_||_|",
+                "                           "
+        ));
+
+        assertEquals("110101100", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderReplacesUnreadableDigitsWithQuestionMarksWithinSequence() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "       _     _           _ ",
+                "  |  || |  || |     || || |",
+                "  |  | _|  ||_|  |  ||_||_|",
+                "                           "
+        ));
+
+        assertEquals("11?10?1?0", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle2() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                " _|",
+                "|_ ",
+                "   "
+        ));
+
+        assertEquals("2", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle3() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                " _|",
+                " _|",
+                "   "
+        ));
+
+        assertEquals("3", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle4() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "   ",
+                "|_|",
+                "  |",
+                "   "
+        ));
+
+        assertEquals("4", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle5() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "|_ ",
+                " _|",
+                "   "
+        ));
+
+        assertEquals("5", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle6() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "|_ ",
+                "|_|",
+                "   "
+        ));
+
+        assertEquals("6", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle7() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "  |",
+                "  |",
+                "   "
+        ));
+
+        assertEquals("7", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle8() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "|_|",
+                "|_|",
+                "   "
+        ));
+
+        assertEquals("8", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSingle9() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                " _ ",
+                "|_|",
+                " _|",
+                "   "
+        ));
+
+        assertEquals("9", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesSequence1234567890() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "    _  _     _  _  _  _  _  _ ",
+                "  | _| _||_||_ |_   ||_||_|| |",
+                "  ||_  _|  | _||_|  ||_| _||_|",
+                "                              "
+        ));
+
+        assertEquals("1234567890", parsedInput);
+    }
+
+    @Ignore
+    @Test
+    public void testReaderRecognizesAndCorrectlyFormatsMultiRowInput() {
+        String parsedInput = new OpticalCharacterReader().parse(Arrays.asList(
+                "    _  _ ",
+                "  | _| _|",
+                "  ||_  _|",
+                "         ",
+                "    _  _ ",
+                "|_||_ |_ ",
+                "  | _||_|",
+                "         ",
+                " _  _  _ ",
+                "  ||_||_|",
+                "  ||_| _|",
+                "         "
+        ));
+
+        assertEquals("123,456,789", parsedInput);
+    }
+
+}

data/tracks/java/exercises/perfect-numbers/src/example/java/NaturalNumber.java

@@ -5,7 +5,7 @@ final class NaturalNumber {
     private final int naturalNumber;
 
     NaturalNumber(int naturalNumber) {
-        if (naturalNumber <= 0) throw new IllegalStateException("Natural numbers are all positive.");
+        if (naturalNumber <= 0) throw new IllegalArgumentException("You must supply a natural number (positive integer)");
         this.naturalNumber = naturalNumber;
     }
 

data/tracks/java/exercises/perfect-numbers/src/test/java/NaturalNumberTest.java

@@ -1,10 +1,23 @@
 import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.0.0
+ * https://github.com/exercism/x-common/blob/19d0c7714ce664a1ad762af624c17f8e269fa8b2/exercises/perfect-numbers/canonical-data.json
+ */
 public final class NaturalNumberTest {
 
+    /*
+     * 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 testSmallPerfectNumberIsClassifiedCorrectly() {
         assertEquals(Classification.PERFECT, new NaturalNumber(6).getClassification());
@@ -31,7 +44,7 @@ public final class NaturalNumberTest {
     @Ignore
     @Test
     public void testMediumAbundantNumberIsClassifiedCorrectly() {
-        assertEquals(Classification.ABUNDANT, new NaturalNumber(24).getClassification());
+        assertEquals(Classification.ABUNDANT, new NaturalNumber(30).getClassification());
     }
 
     @Ignore
@@ -42,14 +55,20 @@ public final class NaturalNumberTest {
 
     @Ignore
     @Test
-    public void testSmallDeficientNumberIsClassifiedCorrectly() {
-        assertEquals(Classification.DEFICIENT, new NaturalNumber(8).getClassification());
+    public void testSmallestPrimeDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, new NaturalNumber(2).getClassification());
+    }
+
+    @Ignore
+    @Test
+    public void testSmallestNonPrimeDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, new NaturalNumber(4).getClassification());
     }
 
     @Ignore
     @Test
-    public void testMediumNumberIsClassifiedCorrectly() {
-        assertEquals(Classification.DEFICIENT, new NaturalNumber(31).getClassification());
+    public void testMediumDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, new NaturalNumber(32).getClassification());
     }
 
     @Ignore
@@ -58,4 +77,32 @@ public final class NaturalNumberTest {
         assertEquals(Classification.DEFICIENT, new NaturalNumber(33550337).getClassification());
     }
 
+    @Ignore
+    @Test
+    /*
+     * The number 1 has no proper divisors (https://en.wikipedia.org/wiki/Divisor#Further_notions_and_facts), and the
+     * additive identity is 0, so the aliquot sum of 1 should be 0. Hence 1 should be classified as deficient.
+     */
+    public void testThatOneIsCorrectlyClassifiedAsDeficient() {
+        assertEquals(Classification.DEFICIENT, new NaturalNumber(1).getClassification());
+    }
+
+    @Ignore
+    @Test
+    public void testThatNonNegativeIntegerIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply a natural number (positive integer)");
+
+        new NaturalNumber(0);
+    }
+
+    @Ignore
+    @Test
+    public void testThatNegativeIntegerIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply a natural number (positive integer)");
+
+        new NaturalNumber(-1);
+    }
+
 }

data/tracks/java/exercises/settings.gradle

@@ -32,6 +32,7 @@ include 'meetup'
 include 'minesweeper'
 include 'nth-prime'
 include 'nucleotide-count'
+include 'ocr-numbers'
 include 'octal'
 include 'palindrome-products'
 include 'pangram'

data/tracks/javascript/exercises/phone-number/phone-number.spec.js

@@ -11,13 +11,23 @@ describe('PhoneNumber()', function() {
     expect(phone.number()).toEqual('1234567890');
   });
 
+  xit('cleans some other number with dots', function() {
+    var phone = new PhoneNumber('555.456.7890');
+    expect(phone.number()).toEqual('5554567890');
+  });
+
   xit('valid when 11 digits and first digit is 1', function() {
     var phone = new PhoneNumber('11234567890');
     expect(phone.number()).toEqual('1234567890');
   });
 
-  xit('invalid when 11 digits', function() {
-    var phone = new PhoneNumber('21234567890');
+  xit('invalid when 11 digits and the first digit is NOT 1', function() {
+    var phone = new PhoneNumber('2  1234567890');
+    expect(phone.number()).toEqual('0000000000');
+  });
+
+  xit('invalid when 12 digits', function() {
+    var phone = new PhoneNumber('991234567890');
     expect(phone.number()).toEqual('0000000000');
   });
 
@@ -31,8 +41,18 @@ describe('PhoneNumber()', function() {
     expect(phone.areaCode()).toEqual('123');
   });
 
+  xit('has some other area code', function() {
+    var phone = new PhoneNumber('5554567890');
+    expect(phone.areaCode()).toEqual('555');
+  });
+
   xit('formats a number', function() {
     var phone = new PhoneNumber('1234567890');
     expect(phone.toString()).toEqual('(123) 456-7890');
   });
+
+  xit('formats some other number', function() {
+    var phone = new PhoneNumber('5554567890');
+    expect(phone.toString()).toEqual('(555) 456-7890');
+  });
 });

data/tracks/julia/exercises/bob/example.jl

@@ -16,7 +16,7 @@ issilence(stimulus::AbstractString) = isempty(stimulus)
 isquestion(stimulus::AbstractString) = endswith(stimulus, '?')
 
 function isshouting(stimulus::AbstractString)
-    isupper(stimulus) && return true
+    all(isupper, stimulus) && return true
     !any(isalpha, stimulus) && return false
 
     for c in stimulus

data/tracks/julia/exercises/custom-set/HINTS.md

@@ -1 +1,3 @@
 The tests require a constructor that takes an array. The internals of your custom set implementation can use other data structures but you may have to implement an outer constructor that takes exactly one array for the tests to pass.
+
+Certain methods have a unicode operator equivalent. E.g. `intersect(CustomSet([1, 2, 3, 4]), CustomSet([]))` is equivalent to `CustomSet([1, 2, 3, 4]) ∩ CustomSet([])`.

data/tracks/julia/exercises/custom-set/runtests.jl

@@ -14,7 +14,7 @@ end
     @test !(4 in CustomSet([1, 2, 3]))
 end
 
-@testset "subset" begin  # TODO ⊆, ⊈
+@testset "subset" begin
     @test  issubset(CustomSet([]), CustomSet([]))
     @test  issubset(CustomSet([]), CustomSet([1]))
     @test !issubset(CustomSet([1]), CustomSet([]))
@@ -90,7 +90,7 @@ end
             cs1 == CustomSet([2, 3])
         end
     end
-    @testset "not in-place" begin  # TODO use operator ∩
+    @testset "not in-place" begin
         @test isempty(intersect(CustomSet([]), CustomSet([])))
         @test isempty(intersect(CustomSet([]), CustomSet([3, 2, 5])))
         @test isempty(intersect(CustomSet([1, 2, 3, 4]), CustomSet([])))

data/tracks/prolog/README.md

@@ -45,7 +45,7 @@ file for the real implementation. The example solution should have the
   This allows the tests to be run on CI and configures tests to be skipped with
   the `condition(pending)` flag.
 
-```prolog 
+```prolog
 pending :-
     current_prolog_flag(argv, ['--all'|_]).
 pending :-
@@ -58,7 +58,7 @@ pending :-
   first test should have `condition(true)` as an example of how to change the
   tests to run. Here are the first two tests in the `hello_world` exercise.
 
-```prolog 
+```prolog
 test(hello_world, condition(true)) :-
     hello_world('Hello World!').
 
@@ -74,3 +74,7 @@ with `bin/build.sh`. Please run this command before submitting your PR.
 The MIT License (MIT)
 
 Copyright (c) 2016 Katrina Owen, _@kytrinyx.com
+
+### [SWI Prolog icon](https://github.com/exercism/xprolog/tree/master/img/icon.png)
+
+The SWI Prolog "Owlie" logo is owned by the SWI Prolog maintainers and released under the Simplified BSD license. We have adapted it for use on Exercism, changing the colour scheme, with [the express permission of `anne@swiprolog.org`](https://github.com/exercism/xprolog/issues/1#issuecomment-283122027).