trackler 2.0.8.11 → 2.0.8.12

data/tracks/factor/README.md

@@ -70,12 +70,6 @@ Here's what you need to do to start working with the Factor code in the `exercis
 
 If you think you've found a factual or technical error, or you just have a question or suggestion about some part of the Markdown or Factor documentation, we'd :heart: you to open an issue or pull request.
 
-## License
-
-The MIT License (MIT)
-
-Copyright (c) 2016 Katrina Owen, _@kytrinyx.com
-
 ### [Factor icon](https://github.com/exercism/xfactor/tree/master/img/icon.png)
 
 The Factor "Tyrannosaurus Rex" logo is owned by John Benediktsson. We have adapted it, changing the colour scheme, with his permission.

data/tracks/factor/config.json

@@ -6,7 +6,8 @@
   "test_pattern": "TODO",
 
   "problems": [
-    "hello-world"
+    "hello-world",
+    "leap"
   ],
 
   "exercises": [
@@ -19,6 +20,16 @@
           "text formatting",
           "quotations"
       ]
+    },
+    {
+      "slug": "leap",
+      "difficulty": 2,
+      "topics": [
+        "quotations",
+        "word definition",
+        "conditionals",
+        "logical operators"
+      ]
     }
   ],
 
@@ -27,8 +38,7 @@
 
   "ignored": [
     "bin",
-    "docs",
-    "exercism-testing"
+    "docs"
   ],
 
   "foregone": [

data/tracks/factor/docs/INSTALLATION.md

@@ -1,27 +1,19 @@
 # Installing Factor, and making Factor and Exercism play nice
 
-[**Even if you already have Factor installed, you still need to read the last section of this document for important information about testing Factor code in the Exercism environment.**](#play-nice)
+[**Even if you already have Factor 0.98 installed, you still need to read the last section of this document for important information about testing Factor code in the Exercism environment.**](#play-nice)
 
 ---
 
 ## Installing Factor
 
-To install Factor, you have a couple of choices.
+To install Factor, you should use a [nightly](#nightly) or [bleeding-edge](#autobuild-from-source) build.
 
-For production servers and mission-critical applications, we recommend a stable binary release from the homepage, but because all commits and pulls are thoroughly tested and carefully reviewed, the [nightly builds](#nightly) and even the [bleeding edge of `git`](#autobuild-from-source) are quite safe.
-
----
-
-### Stable
-
-Download a binary for your platform from <http://factorcode.org>, and run the installer.
-
-These binaries and sources are typically a few months behind `git`. If you want the latest bugfixes and features (dark mode UI, perhaps?), or if your platform isn't listed on that page (i.e. not Windows, Linux or Mac), then see the ["build from source"](#autobuild-from-source) section below, to obtain the up-to-the-minute version.
+***The last stable release of Factor was [0.97 released 2 Nov 2014](https://re-factor.blogspot.com/2014/11/factor-097-now-available.html) -- this is quite out of date and not recommended.***
 
 ---
 ### Nightly
 
-The website also provides nightly binaries, built from git. Only builds that pass are shown.
+<http://factorcode.org> also provides nightly binaries, built from git. Only builds that pass are shown.
 
 ---
 
@@ -29,12 +21,15 @@ The website also provides nightly binaries, built from git. Only builds that pas
 
 If neither of the above options are good enough for you, and you need all the latest tech, then you will need a modern C++ compiler like GCC >=4.8 or Clang >=3.5, `make`, `curl`, and:
 
-1. Download the `build` shell script: [**here** for `sh`, `bash`, etc](https://raw.githubusercontent.com/factor/factor/master/build.sh) or [**here** for Windows](https://raw.githubusercontent.com/factor/factor/master/build.cmd). Put it in the directory where Factor should be installed.
-2. Run it with the `install` argument: `./build.sh install`, or `.\build.cmd install` on Windows. This will clone Factor's `git` repository, build it, and download a Factor VM image from <http://factorcode.org>. This process will take between 2 and 20 minutes, depending on the speed of your internet connection and processor.
+1. Download the `build` shell script: [**here** for Unix-likes / POSIX shells](https://raw.githubusercontent.com/factor/factor/master/build.sh) or [**here** for Windows](https://raw.githubusercontent.com/factor/factor/master/build.cmd). Put it in the directory where Factor should be installed.
+
+2. Run it like `./build.sh install`, or `.\build.cmd install` on Windows. <sub>This will clone Factor's `git` repository, build it, and download a Factor VM image from <http://factorcode.org>. This process will take between 2 and 20 minutes, depending on the speed of your internet connection and processor.</sub>
+
 3. You can now run the generated `factor` or `factor.exe` binary. Try `factor --help` for help. You can also access documentation from the command line, or by pressing <kbd>F1</kbd> in the GUI Listener, which will open the docs browser.
-4. In the future, just `cd` into Factor's cloned repository and type `./build.sh update` or `.\build.cmd update`, respectively, to pull from git and rebuild in-place, and download a new VM image if the checksums differ.
 
-Your tree, from the working directory of the original build script, might look something like this:
+4. In the future, just `cd` into Factor's installation and type `./build.sh update`, or `.\build.cmd update` on Windows, to pull from git and rebuild in-place, and download a new VM image if one exists.
+
+The file structure may now look like this:
 
 ```
 .
@@ -42,24 +37,17 @@ Your tree, from the working directory of the original build script, might look s
 └── factor
     ├── basis
     ├── boot.unix-x86.64.image
-    ├── boot.unix-x86.64.image.bak
     ├── build.cmd
     ├── build.sh
-    ├── checksums.txt
     ├── core
     ├── extra
     ├── factor
     ├── Factor.app
-    ├── factor.bak
     ├── factor.image
-    ├── factor.image.bak
-    ├── factor.image.fresh
     ├── GNUmakefile
-    ├── key-log.txt
     ├── libfactor.a
     ├── libfactor-ffi-test.so
     ├── LICENSE.txt
-    ├── logs
     ├── misc
     ├── Nmakefile
     ├── README.md
@@ -68,13 +56,13 @@ Your tree, from the working directory of the original build script, might look s
     └── work
 ```
 
-You no longer need the top level buildscript.
+You no longer need the top level `build.sh`.
 
 ---
 
-### (Actually) Build from source
+### Manually build from source
 
-Not recommended as the buildscripts are quite good at touchlessly setting things up, but this may be your only option. In most cases, a simple `make` should suffice.
+Clone the [repository](https://github.com/factor/factor) and use `make` in that folder.
 
 If `make` fails with an error about a non-present target, try `make factor` or, if you can read a Makefile, find the make target for your platform in `GNUmakefile`.
 
@@ -82,12 +70,21 @@ If *that* fails, open an issue on [factor/factor](https://github.com/factor/fact
 
 ---
 
+#### Stable (not recommended)
+
+**Note that [the automated test framework](languages/factor/tests) for Factor exercises on Exercism requires at least a [nightly build](#nightly)**.
+
+If you *don't* want automated testing or thousands of new features and bugfixes, download a Stable release binary for your platform from <http://factorcode.org>, and run the installer.
+
+---
+
 ## Making Exercism and Factor work together <a name="play-nice"> </a>
 
-Name clashes between Exercism and the Factor standard library, Exercism and Factor's mutual strictness about filenames, and Factor's reluctance to find vocabularies outside its source tree are all **factor**s making it kind of tricky for Exercism users to test their Factor code.
 
-A [wrapper vocabulary](https://github.com/catb0t/exercism.factor) has been written to streamline the Factor workflow in an Exercism context. This vocab allows users like you, and xfactor contributors alike, to use the `tools.test` framework to write tests in a familiar way, but automating and eliminating the manual configuration which was otherwise necessary.
+Due to limitations like name clashes and filename disagreements, it's rather difficult to use `tools.test` on Exercism exercises out of the box.
+
+Instead, there is a [wrapper vocabulary](https://github.com/catb0t/exercism.factor) for the Factor workflow in an Exercism context. Users and Exercism maintainers alike can write tests in a familiar way, with much less overhead.
 
-To test your Factor code in your `exercism/factor` folder, just download [exercism.factor](https://github.com/catb0t/exercism.factor/archive/master.zip) and unzip it somewhere Factor can find it. `resource:work/exercism` is a good choice, so `testing.factor` is `resource:work/exercism/testing/testing.factor`.
+To test your Factor solutions in your `exercism/factor` folder, follow the directions in [the README](https://github.com/catb0t/exercism.factor#getting-started).
 
 For information on using `exercism.testing`, refer to the [testing documentation](exercism.io/languages/factor#test), or to `exercism.testing`'s documentation by running `"exercism.testing" help` in Factor.

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

@@ -1,6 +1,6 @@
-USING: formatting kernel ;
+USING: formatting kernel sequences ;
 IN: hello-world
 
 : hello-name ( name -- string )
-  dup "" = [ drop "World" ] when
+  dup empty? [ drop "World" ] when
   "Hello, %s!" sprintf ;

data/tracks/factor/exercises/leap/leap-example.factor

@@ -0,0 +1,9 @@
+USING: formatting kernel math ;
+IN: leap
+
+: my-leap-year? ( year -- leap-year? )
+  dup odd?
+  [ drop f ]
+  [ dup [ 100 mod 0 > ] [ 400 mod zero? ] bi or
+    [ 4 mod zero? ] dip and
+  ] if ;

data/tracks/factor/exercises/leap/leap-tests.factor

@@ -0,0 +1,32 @@
+USING: io leap tools.test ;
+IN: leap.tests
+
+"Leap year:" print
+
+"not very common" print
+{ f } [ 2015 my-leap-year? ] unit-test
+
+"introduced every 4 years to adjust about a day" print
+{ t } [ 2016 my-leap-year? ] unit-test
+
+"skipped every 100 years to remove an extra day" print
+{ f } [ 1900 my-leap-year? ] unit-test
+
+"reintroduced every 400 years to adjust yet another day" print
+{ t } [ 2000 my-leap-year? ] unit-test
+
+
+
+"Additional corner cases of leap years:" print
+
+"not a leap year" print
+{ f } [ 1978 my-leap-year? ] unit-test
+
+"a common leap year" print
+{ t } [ 1992 my-leap-year? ] unit-test
+
+"is skipped every 100 years" print
+{ f } [ 2100 my-leap-year? ] unit-test
+
+"reintroduced every 400 years" print
+{ f } [ 2100 my-leap-year? ] unit-test

data/tracks/go/exercises/phone-number/phone_number_test.go

@@ -21,10 +21,13 @@ var numberTests = []testCase{
 	{"123456789", "", true},
 }
 
-func TestNumber(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestNumber(t *testing.T) {
 	for _, test := range numberTests {
 		actual, actualErr := Number(test.input)
 		if !test.expectErr {

data/tracks/go/exercises/pig-latin/example.go

@@ -5,6 +5,8 @@ import (
 	"strings"
 )
 
+const testVersion = 1
+
 var vowel = regexp.MustCompile(`^([aeiou]|y[^aeiou]|xr)[a-z]*`)
 var cons = regexp.MustCompile(`^([^aeiou]?qu|[^aeiou]+)([a-z]*)`)
 

data/tracks/go/exercises/pig-latin/pig_latin_test.go

@@ -2,6 +2,8 @@ package igpay
 
 import "testing"
 
+const targetTestVersion = 1
+
 var tests = []struct{ pl, in string }{
 	{"appleay", "apple"},
 	{"earay", "ear"},
@@ -20,6 +22,12 @@ var tests = []struct{ pl, in string }{
 	{"xrayay", "xray"},
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
+	}
+}
+
 func TestPigLatin(t *testing.T) {
 	for _, test := range tests {
 		if pl := PigLatin(test.in); pl != test.pl {

data/tracks/java/config.json

@@ -308,6 +308,11 @@
       "slug": "list-ops",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "ocr-numbers",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/anagram/src/test/java/AnagramTest.java

@@ -116,4 +116,18 @@ public class AnagramTest {
         List<String> anagrams = detector.match(Arrays.asList("cashregister", "Carthorse", "radishes"));
         assertThat(anagrams, hasItem("Carthorse"));
     }
+
+    @Ignore
+    @Test
+    public void testWordIsNotItsOwnAnagram() {
+        Anagram detector = new Anagram("banana");
+        assertTrue(detector.match(Arrays.asList("Banana")).isEmpty());
+    }
+
+    @Ignore
+    @Test
+    public void testAnagramMustUseAllLettersExactlyOnce() {
+        Anagram detector = new Anagram("tapper");
+        assertTrue(detector.match(Arrays.asList("patter")).isEmpty());
+    }
 }

data/tracks/java/exercises/ocr-numbers/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/ocr-numbers/src/example/java/Digit.java

@@ -0,0 +1,63 @@
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Arrays.stream;
+
+enum Digit {
+
+    ZERO(asList(" _ ",
+                "| |",
+                "|_|")),
+
+    ONE(asList("   ",
+               "  |",
+               "  |")),
+
+    TWO(asList(" _ ",
+               " _|",
+               "|_ ")),
+
+    THREE(asList(" _ ",
+                 " _|",
+                 " _|")),
+
+    FOUR(asList("   ",
+                "|_|",
+                "  |")),
+
+    FIVE(asList(" _ ",
+                "|_ ",
+                " _|")),
+
+    SIX(asList(" _ ",
+               "|_ ",
+               "|_|")),
+
+    SEVEN(asList(" _ ",
+                 "  |",
+                 "  |")),
+
+    EIGHT(asList(" _ ",
+                 "|_|",
+                 "|_|")),
+
+    NINE(asList(" _ ",
+                "|_|",
+                " _|"));
+
+    private final List<String> ssdRepresentation;
+
+    Digit(List<String> ssd) {
+        this.ssdRepresentation = ssd;
+    }
+
+    static String fromSsdConfiguration(final List<String> ssdConfiguration) {
+        return stream(values())
+                .filter(digit -> digit.ssdRepresentation.equals(ssdConfiguration))
+                .map(Digit::ordinal)
+                .map(Object::toString)
+                .findFirst()
+                .orElse("?");
+    }
+
+}

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

@@ -0,0 +1,67 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+ * This example solution uses the abbreviation "SSD", short for Seven-Segment Display, throughout.
+ *
+ * For more information, see https://en.wikipedia.org/wiki/Seven-segment_display.
+ */
+final class OpticalCharacterReader {
+
+    private static final int ROWS_PER_LINE  = 4;
+
+    private static final int COLS_PER_SSD = 3;
+
+    String parse(final List<String> input) {
+        validateInput(input);
+
+        final List<String> parsedLines = new ArrayList<>();
+
+        for (int nLine = 0; nLine < input.size() / ROWS_PER_LINE; nLine++) {
+            final int nFirstRowCurrentLine = nLine * ROWS_PER_LINE;
+            final int nFirstRowNextLine = nFirstRowCurrentLine + ROWS_PER_LINE;
+
+            final List<String> currentLine = input.subList(nFirstRowCurrentLine, nFirstRowNextLine);
+            parsedLines.add(parseLine(currentLine));
+        }
+
+        return String.join(",", parsedLines);
+    }
+
+    private String parseLine(final List<String> currentLine) {
+        final List<String> parsedDigits = new ArrayList<>();
+
+        for (int nSsd = 0; nSsd < currentLine.get(0).length() / COLS_PER_SSD; nSsd++) {
+            final int nFirstColCurrentSsd = nSsd * COLS_PER_SSD;
+            final int nFirstColNextSsd = nFirstColCurrentSsd + COLS_PER_SSD;
+
+            final List<String> currentSsdConfiguration = new ArrayList<>();
+
+            // Bottom row of each line is a spacer, so we ignore that row when constructing SSD configurations.
+            for (int nRow = 0; nRow < ROWS_PER_LINE - 1; nRow++) {
+                currentSsdConfiguration.add(currentLine.get(nRow).substring(nFirstColCurrentSsd, nFirstColNextSsd));
+            }
+
+            parsedDigits.add(Digit.fromSsdConfiguration(currentSsdConfiguration));
+        }
+
+        return String.join("", parsedDigits);
+    }
+
+    private void validateInput(final List<String> input) {
+        final int inputRowCount = input.size();
+
+        if (inputRowCount == 0 || inputRowCount % 4 != 0) {
+            throw new IllegalArgumentException(
+                    "Number of input rows must be a positive multiple of " + ROWS_PER_LINE);
+        }
+
+        final int inputColumnCount = input.get(0).length();
+
+        if (inputColumnCount == 0 || inputColumnCount % 3 != 0) {
+            throw new IllegalArgumentException(
+                    "Number of input columns must be a positive multiple of " + COLS_PER_SSD);
+        }
+    }
+
+}