canonical-data.json

{
  "exercise": "dominoes",
  "comments": [
    "Inputs are given as lists of two-element lists.",
    "Feel free to convert the input to a sensible type in the specific language",
    "For example, if the target language has 2-tuples, that is a good candidate.",
    "",
    "There are two levels of this exercise that can be implemented and/or tested:",
    "",
    "1: Given a list of dominoes, determine whether it can be made into a chain.",
    "Under this scheme, the submitted code only needs to return a boolean.",
    "The test code only needs to check that that boolean value matches up.",
    "",
    "2: Given a list of dominoes, determine one possible chain, if one exists, or else conclude that none can be made.",
    "Under this scheme, the submitted code needs to either return a chain, or signal that none exists.",
    "Different languages may do this differently:",
    "return Option<Vector<Domino>>, return ([]Domino, error), raise exception, etc.",
    "The test code needs to check that the returned chain is correct (see below).",
    "",
    "It's infeasible to list every single possible result chain in this file.",
    "That's because for even a simple list [(1, 2), (2, 3), (3, 1)],",
    "the possible chains are that order, any rotation of that order,",
    "and any rotation of that order with all dominoes reversed.",
    "",
    "For this reason, this JSON file will only list whether a chain is possible.",
    "Tracks wishing to verify correct results of the second level must separately perform this verification.",
    "",
    "The properties to verify are:",
    "1. The submitted code claims there is a chain if and only if there actually is one.",
    "2. The number of dominoes in the output equals the number of dominoes in the input.",
    "3a. For each adjacent pair of dominoes ... (a, b), (c, d) ...: b is equal to c.",
    "3b. For the dominoes on the ends (a, b) ... (c, d): a is equal to d.",
    "4. Every domino appears in the output an equal number of times as the number of times it appears in the input.",
    "(in other words, the dominoes in the output are the same dominoes as the ones in the input)",
    "",
    "Feel free to examine the Rust track for ideas on implementing the second level verification."
  ],
  "cases": [
    {
      "uuid": "31a673f2-5e54-49fe-bd79-1c1dae476c9c",
      "description": "empty input = empty output",
      "property": "canChain",
      "input": {
        "dominoes": []
      },
      "expected": true
    },
    {
      "uuid": "4f99b933-367b-404b-8c6d-36d5923ee476",
      "description": "singleton input = singleton output",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 1]]
      },
      "expected": true
    },
    {
      "uuid": "91122d10-5ec7-47cb-b759-033756375869",
      "description": "singleton that can't be chained",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2]]
      },
      "expected": false
    },
    {
      "uuid": "be8bc26b-fd3d-440b-8e9f-d698a0623be3",
      "description": "three elements",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [3, 1], [2, 3]]
      },
      "expected": true
    },
    {
      "uuid": "99e615c6-c059-401c-9e87-ad7af11fea5c",
      "description": "can reverse dominoes",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [1, 3], [2, 3]]
      },
      "expected": true
    },
    {
      "uuid": "51f0c291-5d43-40c5-b316-0429069528c9",
      "description": "can't be chained",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [4, 1], [2, 3]]
      },
      "expected": false
    },
    {
      "uuid": "9a75e078-a025-4c23-8c3a-238553657f39",
      "description": "disconnected - simple",
      "comments": [
        "This meets the requirement of being possibly-Eulerian.",
        "All vertices have even degree.",
        "Nevertheless, there is no chain here, as there's no way to get from 1 to 2.",
        "This test (and the two following) prevent solutions from using the even-degree test as the sole criterion,",
        "as that is not a sufficient condition."
      ],
      "property": "canChain",
      "input": {
        "dominoes": [[1, 1], [2, 2]]
      },
      "expected": false
    },
    {
      "uuid": "0da0c7fe-d492-445d-b9ef-1f111f07a301",
      "description": "disconnected - double loop",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [2, 1], [3, 4], [4, 3]]
      },
      "expected": false
    },
    {
      "uuid": "b6087ff0-f555-4ea0-a71c-f9d707c5994a",
      "description": "disconnected - single isolated",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [2, 3], [3, 1], [4, 4]]
      },
      "expected": false
    },
    {
      "uuid": "2174fbdc-8b48-4bac-9914-8090d06ef978",
      "description": "need backtrack",
      "comments": [
        "Some solutions may make a chain out of (1, 2), (2, 3), (3, 1)",
        "then decide that since there are no more dominoes containing a 1,",
        "there is no chain possible.",
        "There is indeed a chain here, so this test checks for this line of reasoning.",
        "You need to place the (2, 4) after the (1, 2) rather than the (2, 3)."
      ],
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [2, 3], [3, 1], [2, 4], [2, 4]]
      },
      "expected": true
    },
    {
      "uuid": "167bb480-dfd1-4318-a20d-4f90adb4a09f",
      "description": "separate loops",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [2, 3], [3, 1], [1, 1], [2, 2], [3, 3]]
      },
      "expected": true
    },
    {
      "uuid": "cd061538-6046-45a7-ace9-6708fe8f6504",
      "description": "nine elements",
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [5, 3], [3, 1], [1, 2], [2, 4], [1, 6], [2, 3], [3, 4], [5, 6]]
      },
      "expected": true
    },
    {
      "uuid": "44704c7c-3adb-4d98-bd30-f45527cf8b49",
      "description": "separate three-domino loops",
      "comments": [
        "Some solutions only check if each stone has at least two other neighbors,       ",
        "but this test case should still fail due to the separate loops not being linked."
      ],
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [2, 3], [3, 1], [4, 5], [5, 6], [6, 4]]
      },
      "expected": false
    },
    {
      "uuid": "709f7b9e-239d-4e20-b4a1-61f46257a647",
      "description": "can't try forever",
      "comments": [
        "Some solutions try to build a chain and backtrack when none is found",
        "but can end up in infinite loops, when not properly taken care of.",
        "This ensures that such cases are identified."
      ],
      "property": "canChain",
      "input": {
        "dominoes": [[1, 2], [2, 4], [4, 2], [4, 3]]
      },
      "expected": false
    }
  ]
}