trackler 2.1.0.11 → 2.1.0.12

data/tracks/java/exercises/space-age/src/main/java/SpaceAge.java

@@ -0,0 +1,43 @@
+class SpaceAge {
+
+    SpaceAge(double seconds) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double getSeconds() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onEarth() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onMercury() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onVenus() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onMars() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onJupiter() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onSaturn() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onUranus() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    double onNeptune() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/javascript/config.json

@@ -11,7 +11,7 @@
     "rna-transcription",
     "bob",
     "gigasecond",
-		"perfect-numbers",
+    "perfect-numbers",
     "word-count",
     "isogram",
     "pangram",
@@ -74,7 +74,8 @@
     "bowling",
     "diamond",
     "all-your-base",
-    "run-length-encoding"
+    "run-length-encoding",
+    "minesweeper"
   ],
   "exercises": [
     {
@@ -516,6 +517,15 @@
       "difficulty": 1,
       "topics": [
       ]
+    },
+    {
+      "slug": "minesweeper",
+      "difficulty": 7,
+      "topics": [
+        "games",
+        "arrays",
+        "algorithms"
+      ]
     }
   ],
   "deprecated": [

data/tracks/javascript/docs/TESTS.md

@@ -22,7 +22,7 @@ Install [Visual Studio Express 2013 for web](http://www.visualstudio.com/en-us/p
 
 To get started, you can download a Visual Studio solution that is already set up to work with JavaScript and the other languages that Visual Studio supports.
 
-![Solution Explorer](http://x.exercism.io/v3/tracks/javascript/docs/img/SolutionExplorer.png)
+![Solution Explorer](/docs/img/SolutionExplorer.png)
 
 1. Download the [Exercism.io Visual Studio Template](https://github.com/rprouse/Exercism.VisualStudio) from GitHub by clicking the Download Zip button on the page.
 2. Unzip the template into your exercises directory, for example `C:\src\exercises`
@@ -37,7 +37,7 @@ To get started, you can download a Visual Studio solution that is already set up
 10. The exercise you just fetched will appear greyed out. Right click on the folder and **Include In Project**
 11. Get coding...
 
-![Add files](http://x.exercism.io/v3/tracks/javascript/docs/img/AddFiles.png)
+![Add files](/docs/img/AddFiles.png)
 
 If you have a paid version of Visual Studio, you should install the [Web Essentials](http://vswebessentials.com/) extension. It will make working with Javascript much easier.
 

data/tracks/javascript/exercises/minesweeper/example.js

@@ -0,0 +1,48 @@
+var Minesweeper = function() {
+  this.distanceXdistanceYs = [
+      [-1,-1],
+      [-1,0],
+      [-1,1],
+
+      [1,1],
+      [1,0],
+      [1,-1],
+
+      [0,1],
+      [0,-1]
+
+  ]
+};
+
+
+Minesweeper.prototype.annotate = function(rows) {
+  if (rows.length === 0 || rows[0].length === 0) {
+    return rows;
+  }
+  var board = rows.map(function(row) { return row.split(""); });
+  var outBoard = [];
+  for (var x = 0; x < board.length; x++) {
+    outBoard[x] = [];
+    for (var y = 0; y < board[x].length; y++) {
+      var spot = board[x][y];
+      if (spot === "*") {
+        outBoard[x][y] = spot;
+        continue;
+      }
+      var bombCount = this.distanceXdistanceYs.map(function(dxdy) {
+        if (board[x + dxdy[0]] === undefined) {
+          return 0;
+        }
+        return board[x + dxdy[0]][y + dxdy[1]] === "*" ? 1 : 0;
+      }).reduce(function(total, num) {
+        return total + num;
+      });
+      outBoard[x][y] = bombCount > 0 ? bombCount : " ";
+    }
+  }
+  return outBoard.map(function(row) {
+    return row.join("");
+  });
+};
+
+module.exports = Minesweeper;

data/tracks/javascript/exercises/minesweeper/minesweeper.spec.js

@@ -0,0 +1,182 @@
+var Minesweeper = require('./minesweeper');
+
+describe('Minesweeper()', function() {
+
+  it('handles no rows', function() {
+    var minesweeper = new Minesweeper();
+    expect(minesweeper.annotate([])).toEqual([]);
+  });
+
+  xit('handles no columns', function() {
+    var minesweeper = new Minesweeper();
+    expect(minesweeper.annotate([""])).toEqual([""]);
+  });
+
+  xit('handles no mines', function() {
+    var minesweeper = new Minesweeper();
+    var input = [
+        "   ",
+        "   ",
+        "   "
+    ];
+    var expected = [
+        "   ",
+        "   ",
+        "   "
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles board with only mines', function() {
+    var minesweeper = new Minesweeper();
+    var input = [
+        "***",
+        "***",
+        "***"
+    ];
+    var expected = [
+        "***",
+        "***",
+        "***"
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles mine surrounded by spaces', function() {
+    var minesweeper = new Minesweeper();
+    var input = [
+        "   ",
+        " * ",
+        "   "
+    ];
+    var expected = [
+        "111",
+        "1*1",
+        "111"
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles space surrounded by mines', function() {
+    var minesweeper = new Minesweeper();
+    var input = [
+        "***",
+        "* *",
+        "***"
+      ];
+    var expected = [
+        "***",
+        "*8*",
+        "***"
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles space surrounded by mines', function() {
+    var minesweeper = new Minesweeper();
+    var input = [
+        "***",
+        "* *",
+        "***"
+      ];
+    var expected = [
+        "***",
+        "*8*",
+        "***"
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles horizontal line', function() {
+    var minesweeper = new Minesweeper();
+    var input = [" * * "];
+    var expected = ["1*2*1"];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles horizontal line, mines at edges',function() {
+    var minesweeper = new Minesweeper();
+    var input = ["*   *"];
+    var expected = ["*1 1*"];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles vertical line', function() {
+    var minesweeper = new Minesweeper();
+    var input = [
+        " ",
+        "*",
+        " ",
+        "*",
+        " "
+      ];
+    var expected = [
+        "1",
+        "*",
+        "2",
+        "*",
+        "1"
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles vertical line, mines at edges', function() {
+    var minesweeper = new Minesweeper();
+    var input =  [
+        "*",
+        " ",
+        " ",
+        " ",
+        "*"
+      ];
+    var expected = [
+        "*",
+        "1",
+        " ",
+        "1",
+        "*"
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles cross', function() {
+    var minesweeper = new Minesweeper();
+    var input =   [
+        "  *  ",
+        "  *  ",
+        "*****",
+        "  *  ",
+        "  *  "
+    ];
+    var expected = [
+        " 2*2 ",
+        "25*52",
+        "*****",
+        "25*52",
+        " 2*2 "
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xit('handles large board', function() {
+    var minesweeper = new Minesweeper();
+    var input =  [
+        " *  * ",
+        "  *   ",
+        "    * ",
+        "   * *",
+        " *  * ",
+        "      "
+    ];
+    var expected = [
+        "1*22*1",
+        "12*322",
+        " 123*2",
+        "112*4*",
+        "1*22*2",
+        "111111"
+      ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+    
+});

data/tracks/lisp/.travis.yml

@@ -35,4 +35,4 @@ script:
 # Cut and paste above to run all tests locally.
 
 # Add a numeric argument to XLISP-TEST:RUN-TESTS-ALL between 0 and 7
-# to control optional verbosity (default is 2).
+# to control optional verbosity (default is 3).

data/tracks/lisp/bin/xlisp-test.lisp

@@ -20,6 +20,17 @@ http://exercism.io"))
 
 (in-package #:xlisp-test)
 
+;;; Exit states
+
+;;;; http://tldp.org/LDP/abs/html/exitcodes.html
+
+(defconstant +exit-tests-did-not-run+ 3
+  "Exit status for when tests don't run.")
+
+(defconstant +exit-tests-failed+ 4
+  "Exit status for when tests fail.")
+
+
 ;;; Optional messaging
 
 (defconstant +warn+  1 "Verbosity level for warnings only.")
@@ -52,9 +63,13 @@ http://exercism.io"))
 ;;; Managing paths and packages
 
 (defparameter *exercises*
-  (with-open-file (config-json "config.json")
-    (rest (assoc :problems
-                 (cl-json:decode-json config-json))))
+  (flet ((slug-name (exercise-config)
+           (cdr (assoc :slug exercise-config))))
+    (with-open-file (config-json "config.json")
+      (map 'list
+           #'slug-name
+           (cdr (assoc :exercises
+                        (cl-json:decode-json config-json))))))
   "List of exercise names.")
 
 (defun load-package (filename)
@@ -135,13 +150,16 @@ http://exercism.io"))
       (dolist (package (list example exercise))
         (when package (delete-package package))))))
 
-(defun test-exercises (&optional (verbosity +info+))
+(defun test-exercises (&optional (verbosity (+ +warn+ +info+)))
   "Run all exercise tests."
   (pushnew :xlisp-test *features*)
   (setf *verbosity* verbosity)
   (inform (format nil "Verbosity level: ~D" *verbosity*))
   (inform "Running all xlisp tests...")
   (and (problems-p) (delete-all-problems))
+  (unless *exercises*
+    (alert "No exercises defined.")
+    (uiop:quit +exit-tests-did-not-run+))
   (dolist (exercise *exercises* (problems-p))
     (test-exercise exercise)))
 
@@ -151,4 +169,4 @@ http://exercism.io"))
 
 (defun travis-build ()
   "Execute a full build, and if it fails, exit with an error code."
-  (when (full-build) (uiop:quit 4)))
+  (when (full-build) (uiop:quit +exit-tests-failed+)))

data/tracks/lisp/config.json

@@ -7,147 +7,232 @@
     {
       "slug": "hamming",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Equality",
+                 "Strings",
+                 "Filtering"]
     },
     {
       "slug": "leap",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Equality",
+                 "Integers",
+                 "Logic"]
     },
     {
       "slug": "grains",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Variables",
+                 "Integers",
+                 "Mathematics"]
     },
     {
       "slug": "gigasecond",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Variables",
+                 "Integers",
+                 "Date",
+                 "Time",
+                 "Transforming"]
     },
     {
       "slug": "bob",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Strings",
+                 "Parsing"]
     },
     {
       "slug": "rna-transcription",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Strings",
+                 "Transforming"]
     },
     {
       "slug": "robot-name",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Variables",
+                 "Strings",
+                 "Randomness"]
     },
     {
       "slug": "word-count",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Strings",
+                 "Filtering"]
     },
     {
       "slug": "raindrops",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Integers",
+                 "Filtering"]
     },
     {
       "slug": "grade-school",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Interfaces",
+                 "Variables",
+                 "Lists",
+                 "Maps",
+                 "Sorting"]
     },
     {
       "slug": "phone-number",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Interfaces",
+                 "Strings",
+                 "Parsing"]
     },
     {
       "slug": "etl",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (loops)",
+                 "Maps",
+                 "Transforming"]
     },
     {
       "slug": "beer-song",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Integers",
+                 "Text formatting"]
     },
     {
       "slug": "space-age",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Interfaces",
+                 "Floating-point numbers",
+                 "Transforming"]
     },
     {
       "slug": "anagram",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Equality",
+                 "Strings",
+                 "Filtering"]
     },
     {
       "slug": "nucleotide-count",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (loops)",
+                 "Strings",
+                 "Maps",
+                 "Sorting"]
     },
     {
       "slug": "meetup",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Dates",
+                 "Filtering"]
     },
     {
       "slug": "triangle",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Integers",
+                 "Floating-point numbers",
+                 "Mathematics",
+                 "Filtering"]
     },
     {
       "slug": "difference-of-squares",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (loops)",
+                 "Integers",
+                 "Floating-point numbers",
+                 "Mathematics"]
     },
     {
       "slug": "roman-numerals",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Integers",
+                 "Strings",
+                 "Text formatting"]
     },
     {
       "slug": "scrabble-score",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (loops)",
+                 "Maps",
+                 "Strings",
+                 "Games"]
     },
     {
       "slug": "binary",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Integers",
+                 "Bitwise operations"]
     },
     {
       "slug": "allergies",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Integers",
+                 "Bitwise operations",
+                 "Text formatting"]
     },
     {
       "slug": "sieve",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Integers",
+                 "Maps",
+                 "Mathematics",
+                 "Filtering"]
     },
     {
       "slug": "strain",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Sequences",
+                 "Filtering"]
     },
     {
       "slug": "atbash-cipher",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Sequences",
+                 "Transforming"]
     },
     {
       "slug": "prime-factors",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Integers",
+                 "Maps",
+                 "Mathematics",
+                 "Filtering"]
     },
     {
       "slug": "crypto-square",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Control-flow (loops)",
+                 "Strings",
+                 "Arrays",
+                 "Transforming"]
     },
     {
       "slug": "trinary",
       "difficulty": 1,
-      "topics": []
+      "topics": ["Control-flow (conditionals)",
+                 "Integers",
+                 "Mathematics"]
     }
   ],
   "deprecated": [