trackler 2.2.1.51 → 2.2.1.52

data/tracks/fsharp/generators/Common.fs

@@ -57,6 +57,16 @@ module Option =
         | :? int32 as i -> if i < 0  then None else Some value
         | _ -> None
 
+    let ofNonFalse (value: obj) =
+        match value with
+        | :? bool as b when not b -> None
+        | _ -> Some value
+
+    let ofNonError (value: obj) =
+        match value with
+        | :? JToken as jToken when not (isNull jToken.["error"]) -> None
+        | _ -> Some value
+
 module String =
     open Humanizer
 

data/tracks/fsharp/generators/Exercise.fs

@@ -50,6 +50,7 @@ type Exercise() =
     abstract member RenderSutProperty : CanonicalDataCase -> string
     
     // Utility methods to customize rendered output
+    abstract member Properties : CanonicalDataCase -> string list
     abstract member PropertiesUsedAsSutParameter : CanonicalDataCase -> string list
     abstract member PropertiesWithIdentifier : CanonicalDataCase -> string list
     abstract member IdentifierTypeAnnotation: CanonicalDataCase * string * obj -> string option
@@ -214,11 +215,14 @@ type Exercise() =
 
     default this.RenderSutProperty canonicalDataCase = string canonicalDataCase.Property
 
+    default this.Properties canonicalDataCase =
+        List.append (this.PropertiesUsedAsSutParameter canonicalDataCase) ["expected"]
+
     default this.PropertiesUsedAsSutParameter canonicalDataCase = 
         canonicalDataCase.Properties
         |> Map.toList
         |> List.map fst
-        |> List.except ["property"; "expected"; "description"; "comments"]
+        |> List.except ["expected"; "property"; "description"; "comments"]
     
     // Utility methods to customize rendered output
 

data/tracks/fsharp/generators/Generators.fs

@@ -18,7 +18,7 @@ type AllYourBase() =
 
     override this.RenderExpected (canonicalDataCase, key, value) = value |> Option.ofObj |> formatValue
 
-    override this.PropertiesWithIdentifier canonicalDataCase = ["expected"; "input_base"; "input_digits"; "output_base"]
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
 type Allergies() =
     inherit Exercise()
@@ -72,8 +72,7 @@ type BookStore() =
     override this.RenderExpected (canonicalDataCase, key, value) = formatFloat value
 
     override this.PropertiesUsedAsSutParameter canonicalDataCase =
-        base.PropertiesUsedAsSutParameter canonicalDataCase
-        |> List.except ["targetgrouping"; "expected"; "description"]
+        base.PropertiesUsedAsSutParameter canonicalDataCase |> List.except ["targetgrouping"]
 
 type BracketPush() =
     inherit Exercise()
@@ -81,15 +80,11 @@ type BracketPush() =
 type Change() =
     inherit Exercise()
 
-    override this.MapCanonicalDataCaseProperty (canonicalDataCase, key, value) = 
-        match key with 
-        | "expected" -> 
-            match value with 
-            | :? JArray -> Option.ofObj value |> box
-            | _ -> value |> Option.ofNonNegativeInt |> box
-        | _ -> base.MapCanonicalDataCaseProperty (canonicalDataCase, key, value)
+    override this.RenderExpected (canonicalDataCase, key, value) =
+        let convertToOption = if value :? JArray then Option.ofObj else Option.ofNonNegativeInt
+        value |> convertToOption |> formatValue
 
-    override this.PropertiesWithIdentifier canonicalDataCase = ["coins"; "target"; "expected"]
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
     override this.IdentifierTypeAnnotation (canonicalDataCase, key, value) = 
         match key with 
@@ -145,12 +140,7 @@ type KindergartenGarden() =
         |> Seq.map toPlant
         |> formatList
 
-    override this.RenderSutProperty canonicalDataCase =
-        match Map.containsKey "students" canonicalDataCase.Properties with
-        | true  -> "plantsForCustomStudents"
-        | false -> "plantsForDefaultStudents"
-
-    override this.PropertiesWithIdentifier canonicalDataCase = ["student"; "students"; "diagram"; "expected"]
+    override this.PropertiesWithIdentifier canonicalDataCase = ["student"; "diagram"; "expected"]
 
     override this.UseFullMethodName canonicalDataCase = true
 
@@ -160,9 +150,10 @@ type LargestSeriesProduct() =
      override this.PropertiesWithIdentifier canonicalDataCase = ["digits"]
 
     override this.RenderExpected (canonicalDataCase, key, value) = 
-        match value :?> int64 with 
-        | -1L -> "None"
-        | _ -> value :?> int64 |> sprintf "(Some %d)"
+        value 
+        |> Option.ofNonNegativeInt 
+        |> formatValue 
+        |> parenthesizeOption
 
 type Leap() =
     inherit Exercise()
@@ -179,7 +170,7 @@ type Minesweeper() =
         |> Seq.map formatValue
         |> formatMultiLineList
 
-    override this.PropertiesWithIdentifier canonicalDataCase = ["input"; "expected"]
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
     override this.IdentifierTypeAnnotation (canonicalDataCase, key, value) = 
         match value :?> JArray |> Seq.isEmpty with 
@@ -190,9 +181,10 @@ type NthPrime() =
     inherit Exercise()
 
     override this.RenderExpected (canonicalDataCase, key, value) = 
-        match string value with 
-        | "False" -> "None"
-        | _ ->  value :?> int64 |> sprintf "(Some %d)"
+        value 
+        |> Option.ofNonFalse 
+        |> formatValue 
+        |> parenthesizeOption
 
 type Pangram() =
     inherit Exercise()
@@ -200,12 +192,14 @@ type Pangram() =
 type PerfectNumbers() =
     inherit Exercise()
 
+    let toClassification value = string value |> String.humanize
+
     override this.RenderExpected (canonicalDataCase, key, value) = 
-        match value |> string with 
-        | "perfect" -> "(Some Perfect)"
-        | "abundant" -> "(Some Abundant)"
-        | "deficient" -> "(Some Deficient)"
-        | _ -> "None"
+        value 
+        |> Option.ofNonError  
+        |> Option.map toClassification 
+        |> formatOption 
+        |> parenthesizeOption
 
 type PascalsTriangle() =
     inherit Exercise()
@@ -230,7 +224,10 @@ type PhoneNumber() =
     inherit Exercise()
     
     override this.RenderExpected (canonicalDataCase, key, value) =
-        value |> Option.ofObj |> formatValue |> backwardPipe
+        value 
+        |> Option.ofObj 
+        |> formatValue
+        |> parenthesizeOption
 
 type PigLatin() =
     inherit Exercise()
@@ -263,18 +260,110 @@ type QueenAttack() =
 type RailFenceCipher() =
     inherit Exercise()
 
-    override this.PropertiesWithIdentifier canonicalDataCase = ["rails"; "msg"; "expected"]
-
     override this.PropertiesUsedAsSutParameter canonicalDataCase = ["rails"; "msg"]
 
+    override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
+
 type Raindrops() =
     inherit Exercise()
 
+type RobotSimulator() =
+    inherit Exercise()
+
+    let resultIdentifierName = "actual"
+
+    override this.PropertiesWithIdentifier canonicalDataCase = ["robot"; "property"; "expected"]
+
+    member private this.RenderDirection (value: JToken) = 
+        sprintf "%s" (value.ToObject<string>() |> String.upperCaseFirst)  
+
+    member private this.RenderCoords (coords: JToken) = 
+        (coords.["x"].ToObject<int>(), coords.["y"].ToObject<int>()) 
+        |> formatValue
+
+    member private this.DefineRobot (direction: JToken) (coords: JToken) = 
+        sprintf "createRobot %s %s" (this.RenderDirection direction) (this.RenderCoords coords)
+
+    member private this.GetRobotProperties (value : JToken) = 
+        value.SelectToken("direction"), value.SelectToken("position")
+
+    override this.RenderArrange canonicalDataCase =
+        // one identifier may be empty if we only checking created object
+        // we need to filter out this empty line
+        base.RenderArrange canonicalDataCase
+        |> List.choose (
+            function
+            | "" -> None
+            | v -> Some v
+        )
+
+    override this.RenderValueWithoutIdentifier (canonicalDataCase, key, value) = 
+        match key with
+        | "robot" ->
+            let input = value :?> JToken
+            this.DefineRobot ("direction" |> input.SelectToken) ("position" |> input.SelectToken)
+        | "expected" -> 
+            // here we may need to render full robot object
+            // or just coordinate/direction values
+            let input = value :?> JToken
+            let direction, position = this.GetRobotProperties input
+            match isNull direction, isNull position with
+            | true, false ->
+                this.RenderCoords position
+            | false, true ->
+                this.RenderDirection direction
+            | false, false ->
+                this.DefineRobot ("direction" |> input.SelectToken) ("position" |> input.SelectToken)
+            | true, true -> 
+                ""
+        | _ -> ""
+
+    override this.RenderValueWithIdentifier (canonicalDataCase, key, value) = 
+        match key with 
+        | "property" -> 
+            let action = value :?> string
+            match action with 
+            | "instructions" -> 
+                 sprintf "let %s = simulate robot %s" resultIdentifierName (canonicalDataCase.Properties.["instructions"] |> formatValue)
+            | "create" -> 
+                ""
+            | _ -> 
+                 sprintf "let %s = %s robot" resultIdentifierName action
+            
+        | _ -> 
+            base.RenderValueWithIdentifier (canonicalDataCase, key, value)
+
+    override this.RenderSut canonicalDataCase = 
+        match canonicalDataCase.Property with
+        | "create" -> 
+            "robot"
+        | _ -> 
+            // depends on expected value we may need to 
+            // check whole robot or just one of its' properties
+            let direction, position = this.GetRobotProperties (canonicalDataCase.Properties.["expected"] :?> JToken)
+            match isNull direction, isNull position with
+            | true, false -> 
+                sprintf "%s.coordinate" resultIdentifierName
+            | false, true ->
+                sprintf "%s.bearing" resultIdentifierName
+            | true, true -> 
+                resultIdentifierName
+            | false, false -> 
+                match canonicalDataCase.Property with
+                | "create" -> "robot"
+                | _ -> resultIdentifierName
+    
+    override this.RenderTestMethodName canonicalDataCase =
+         // avoid duplicated method names
+         // for this generator it is preferable
+         // because useFullMethodName leads to very long names
+         sprintf "%s - %s" canonicalDataCase.Property (canonicalDataCase.Description |> String.upperCaseFirst)
+
 type RnaTranscription() =
     inherit Exercise()
 
     override this.RenderExpected (canonicalDataCase, key, value) =
-        value |> Option.ofObj |> formatValue |> backwardPipe
+        value |> Option.ofObj |> formatValue |> parenthesizeOption
 
 type RunLengthEncoding() =
     inherit Exercise()

data/tracks/fsharp/generators/Output.fs

@@ -16,9 +16,14 @@ let indent level value =
 
 let parenthesize value = sprintf "(%s)" value
 
+let parenthesizeOption value = 
+    match value with
+    | "None" -> value
+    | _ -> parenthesize value
+
 let backwardPipe value = sprintf "<| %s" value
 
-let backwardPipeConditional test value = if test value then backwardPipe value else value
+let backwardPipeIf test value = if test value then backwardPipe value else value
 
 let addTypeAnnotation typeAnnotation value = sprintf "%s: %s" value typeAnnotation
 

data/tracks/haskell/exercises/crypto-square/README.md

@@ -45,12 +45,14 @@ The message above is coded as:
 imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
 ```
 
-Output the encoded text in chunks.  Phrases that fill perfect squares
-`(r X r)` should be output in `r`-length chunks separated by spaces.
-Imperfect squares will have `n` empty spaces.  Those spaces should be distributed evenly across the last `n` rows.
+Output the encoded text in chunks.  Phrases that fill perfect rectangles
+`(r X c)` should be output `c` chunks of `r` length, separated by spaces.
+Phrases that do not fill perfect rectangles will have `n` empty spaces.
+Those spaces should be distributed evenly, added to the end of the last
+`n` chunks.
 
 ```text
-imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau
+imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 
 ```
 
 Notice that were we to stack these, we could visually decode the

data/tracks/haskell/exercises/kindergarten-garden/README.md

@@ -3,19 +3,19 @@
 Given a diagram, determine which plants each child in the kindergarten class is
 responsible for.
 
-The kindergarten class is learning about growing plants. The teachers
+The kindergarten class is learning about growing plants. The teacher
 thought it would be a good idea to give them actual seeds, plant them in
 actual dirt, and grow actual plants.
 
 They've chosen to grow grass, clover, radishes, and violets.
 
-To this end, they've put little styrofoam cups along the window sills,
-and planted one type of plant in each cup, choosing randomly from the
-available types of seeds.
+To this end, the children have put little cups along the window sills, and 
+planted one type of plant in each cup, choosing randomly from the available 
+types of seeds.
 
 ```text
 [window][window][window]
-........................ # each dot represents a styrofoam cup
+........................ # each dot represents a cup
 ........................
 ```
 
@@ -25,8 +25,8 @@ There are 12 children in the class:
 - Eve, Fred, Ginny, Harriet,
 - Ileana, Joseph, Kincaid, and Larry.
 
-Each child gets 4 cups, two on each row. The children are assigned to
-cups in alphabetical order.
+Each child gets 4 cups, two on each row. Their teacher assigns cups to 
+the children alphabetically by their names.
 
 The following diagram represents Alice's plants:
 
@@ -36,12 +36,12 @@ VR......................
 RG......................
 ```
 
-So in the row nearest the window, she has a violet and a radish; in the
-row behind that, she has a radish and some grass.
+In the first row, nearest the windows, she has a violet and a radish.  In the
+second row she has a radish and some grass.
 
 Your program will be given the plants from left-to-right starting with
 the row nearest the windows. From this, it should be able to determine
-which plants belong to which students.
+which plants belong to each student.
 
 For example, if it's told that the garden looks like so:
 

data/tracks/haskell/exercises/saddle-points/README.md

@@ -15,7 +15,7 @@ So say you have a matrix like so:
 It has a saddle point at (1, 0).
 
 It's called a "saddle point" because it is greater than or equal to
-every element in its row and the less than or equal to every element in
+every element in its row and less than or equal to every element in
 its column.
 
 A matrix may have zero or more saddle points.

data/tracks/haskell/exercises/space-age/README.md

@@ -12,7 +12,7 @@ Given an age in seconds, calculate how old someone would be on:
    - Neptune: orbital period 164.79132 Earth years
 
 So if you were told someone were 1,000,000,000 seconds old, you should
-be able to say that they're 31 Earth-years old.
+be able to say that they're 31.69 Earth-years old.
 
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).

data/tracks/java/config.json

@@ -917,7 +917,13 @@
       "core": false,
       "difficulty": 8,
       "slug": "ocr-numbers",
-      "topics": null,
+      "topics": [
+        "exception_handling",
+        "loops",
+        "lists",
+        "strings",
+        "parsing"
+      ],
       "unlocked_by": "robot-name",
       "uuid": "5cbc6a67-3a53-4aad-ae68-ff469525437f"
     },
@@ -1102,4 +1108,4 @@
   ],
   "language": "Java",
   "solution_pattern": "reference"
-}
+}

data/tracks/java/exercises/queen-attack/.meta/src/reference/java/BoardCoordinate.java

@@ -1,27 +1,27 @@
-public final class BoardCoordinate {
+final class BoardCoordinate {
 
-    private final int rank;
+    private final int row;
 
-    private final int file;
+    private final int column;
 
-    public BoardCoordinate(final int rank, final int file) throws IllegalArgumentException {
-        this.rank = rank;
-        this.file = file;
+    BoardCoordinate(final int row, final int column) throws IllegalArgumentException {
+        this.row = row;
+        this.column = column;
 
         validateInputs();
     }
 
-    public int getRank() {
-        return rank;
+    int getRow() {
+        return row;
     }
 
-    public int getFile() {
-        return file;
+    int getColumn() {
+        return column;
     }
 
     private void validateInputs() throws IllegalArgumentException {
-        validateCoordinateComponent(rank, "rank");
-        validateCoordinateComponent(file, "file");
+        validateCoordinateComponent(row, "row");
+        validateCoordinateComponent(column, "column");
     }
 
     private void validateCoordinateComponent(final int value, final String componentName)

data/tracks/java/exercises/queen-attack/.meta/src/reference/java/QueenAttackCalculator.java

@@ -1,10 +1,10 @@
-public final class QueenAttackCalculator {
+final class QueenAttackCalculator {
 
     private final BoardCoordinate whiteQueenCoordinate;
 
     private final BoardCoordinate blackQueenCoordinate;
 
-    public QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
+    QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
             throws IllegalArgumentException {
 
         this.whiteQueenCoordinate = whiteQueenCoordinate;
@@ -13,8 +13,8 @@ public final class QueenAttackCalculator {
         validateInputs();
     }
 
-    public boolean canQueensAttackOneAnother() {
-        return queensShareFile() || queensShareRank() || queensShareDiagonal();
+    boolean canQueensAttackOneAnother() {
+        return queensShareColumn() || queensShareRow() || queensShareDiagonal();
     }
 
     private void validateInputs() throws IllegalArgumentException {
@@ -27,28 +27,28 @@ public final class QueenAttackCalculator {
         }
     }
 
-    private boolean queensShareRank() {
-        return differenceBetweenRanks() == 0;
+    private boolean queensShareRow() {
+        return differenceBetweenRows() == 0;
     }
 
-    private boolean queensShareFile() {
-        return differenceBetweenFiles() == 0;
+    private boolean queensShareColumn() {
+        return differenceBetweenColumns() == 0;
     }
 
     private boolean queensShareBoardCoordinate() {
-        return queensShareRank() && queensShareFile();
+        return queensShareRow() && queensShareColumn();
     }
 
     private boolean queensShareDiagonal() {
-        return differenceBetweenRanks() == differenceBetweenFiles();
+        return differenceBetweenRows() == differenceBetweenColumns();
     }
 
-    private int differenceBetweenRanks() {
-        return Math.abs(whiteQueenCoordinate.getRank() - blackQueenCoordinate.getRank());
+    private int differenceBetweenRows() {
+        return Math.abs(whiteQueenCoordinate.getRow() - blackQueenCoordinate.getRow());
     }
 
-    private int differenceBetweenFiles() {
-        return Math.abs(whiteQueenCoordinate.getFile() - blackQueenCoordinate.getFile());
+    private int differenceBetweenColumns() {
+        return Math.abs(whiteQueenCoordinate.getColumn() - blackQueenCoordinate.getColumn());
     }
 
 }