dominoes: add new exercise (#1379)

* dominoes: add new exercise

* dominoes: add new exercise

* dominoes: add new exercise

* dominoes: add new exercise

* dominoes: add new exercise

* dominoes: add new exercise

* dominoes: add new exercise

* dominoes: add new exercise

config.json

     },
     {
       "core": false,
+      "difficulty": 7,
+      "slug": "dominoes",
+      "topics": [
+        "games",
+        "algorithms",
+        "lists",
+        "exception_handling"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "8e3cb20e-623b-4b4d-8a91-d1a51c0911b5"
+    },
+    {
+      "core": false,
       "difficulty": 8,
       "slug": "ocr-numbers",
       "topics": [

exercises/dominoes/.meta/src/reference/java/ChainNotFoundException.java

+class ChainNotFoundException extends Exception {
+	public ChainNotFoundException(String message) {
+		super(message);
+	}
+}

exercises/dominoes/.meta/src/reference/java/Domino.java

+import java.util.Objects;
+
+class Domino {
+    private int left;
+    private int right;
+    Domino(int left, int right) {
+        this.left = left;
+        this.right = right;
+    }
+    
+    int getLeft() {
+    	return this.left;
+    }
+    
+    int getRight() {
+    	return this.right;
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+    	Domino otherDomino = (Domino) o;
+    	return (this.getLeft() == otherDomino.getLeft() && this.getRight() == otherDomino.getRight()) ||
+    			(this.getLeft() == otherDomino.getRight() && this.getRight() == otherDomino.getLeft());
+    }
+    
+    @Override
+    public int hashCode() {
+    	return Objects.hash(left, right);
+    }
+}

exercises/dominoes/.meta/src/reference/java/Dominoes.java

+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class Dominoes {
+	
+	List<Domino> formChain(List<Domino> inputDominoes) throws ChainNotFoundException {
+		if (inputDominoes.size() == 0) {
+			return inputDominoes;
+		} else {
+			return formPartialChain(new ArrayList<Domino>(), inputDominoes);
+		}
+	}
+	
+	private boolean isValidChain(ArrayList<Domino> chain) {
+		return isValidPartialChain(chain) && (chain.get(0).getLeft() == chain.get(chain.size() - 1).getRight());
+	}
+	
+	private boolean isValidPartialChain(ArrayList<Domino> chain) {
+		for (int i = 0; i < chain.size() - 1; i++) {
+			if (chain.get(i).getRight() != chain.get(i+1).getLeft()) {
+				return false;
+			}
+		}
+		
+		return true;
+	}
+	
+	ArrayList<Domino> formPartialChain(ArrayList<Domino> current, List<Domino> remaining) throws ChainNotFoundException {
+		if (remaining.size() == 0) {
+			if (isValidChain(current)) {
+				return current;
+			} else {
+				throw new ChainNotFoundException("No domino chain found.");
+			}
+		}
+		
+		for (int i = 0; i < remaining.size(); i++) {
+			ArrayList<Domino> newRemaining = new ArrayList<Domino>(remaining);
+			newRemaining.remove(i);
+			
+			ArrayList<Domino> newChainA = new ArrayList<Domino>(current);
+			newChainA.add(remaining.get(i));
+			
+			ArrayList<Domino> newChainB = new ArrayList<Domino>(current);
+			newChainB.add(new Domino(remaining.get(i).getRight(), remaining.get(i).getLeft()));
+			
+			if (isValidPartialChain(newChainA)) {
+				try {
+					return formPartialChain(newChainA, newRemaining);
+				} catch (ChainNotFoundException e) {
+					//This path does not have a valid chain
+				}
+			}
+			
+			if (isValidPartialChain(newChainB)) {
+				try {
+					return formPartialChain(newChainB, newRemaining);
+				} catch (ChainNotFoundException e) {
+					//This path doesn't have a valid chain
+				}
+			}
+		}
+		
+		throw new ChainNotFoundException("No domino chain found.");
+	}
+}

exercises/dominoes/.meta/version

+1.0.0
+

exercises/dominoes/README.md

+# Dominoes
+
+Make a chain of dominoes.
+
+Compute a way to order a given set of dominoes in such a way that they form a
+correct domino chain (the dots on one half of a stone match the dots on the
+neighbouring half of an adjacent stone) and that dots on the halfs of the stones
+which don't have a neighbour (the first and last stone) match each other.
+
+For example given the stones `[2|1]`, `[2|3]` and `[1|3]` you should compute something
+like `[1|2] [2|3] [3|1]` or `[3|2] [2|1] [1|3]` or `[1|3] [3|2] [2|1]` etc, where the first and last numbers are the same.
+
+For stones `[1|2]`, `[4|1]` and `[2|3]` the resulting chain is not valid: `[4|1] [1|2] [2|3]`'s first and last numbers are not the same. 4 != 3
+
+Some test cases may use duplicate stones in a chain solution, assume that multiple Domino sets are being used.
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/dominoes/build.gradle

+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"]
+    }
+}

exercises/dominoes/src/main/java/ChainNotFoundException.java

+class ChainNotFoundException extends Exception {
+	public ChainNotFoundException(String message) {
+		super(message);
+	}
+}

exercises/dominoes/src/main/java/Domino.java

+import java.util.Objects;
+
+class Domino {
+    private int left;
+    private int right;
+    Domino(int left, int right) {
+        this.left = left;
+        this.right = right;
+    }
+    
+    int getLeft() {
+    	return this.left;
+    }
+    
+    int getRight() {
+    	return this.right;
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+    	Domino otherDomino = (Domino) o;
+    	return (this.getLeft() == otherDomino.getLeft() && this.getRight() == otherDomino.getRight()) ||
+    			(this.getLeft() == otherDomino.getRight() && this.getRight() == otherDomino.getLeft());
+    }
+    
+    @Override
+    public int hashCode() {
+    	return Objects.hash(left, right);
+    }
+}

exercises/dominoes/src/test/java/DominoesTest.java

+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
+public class DominoesTest {
+	
+	@Rule
+	public ExpectedException expectedException = ExpectedException.none(); 
+	
+	@Test
+	public void emtpyInputEmptyOutputTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		List<Domino> dominoesList = new ArrayList<>();
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertEquals("The output list should be empty.", 0, chain.size());
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void singletonInputSingletonOutput() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 1)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void singletonCantBeChainedTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void threeElementsTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(3, 1), new Domino(2, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void canReverseDominoesTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(1, 3), new Domino(2, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void cantBeChainedTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(4, 1), new Domino(2, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void disconnectedSimpleTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 1), new Domino(2, 2)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void disconnectedDoubleLoopTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 1), new Domino(3, 4), new Domino(4, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void disconnectedSingleIsolatedTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 3), new Domino(3, 1), new Domino(4, 4)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void needBacktrackTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 3), new Domino(3, 1), new Domino(2, 4), new Domino(4, 2)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void separateLoopsTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 3), new Domino(3, 1),
+				new Domino(1, 1), new Domino(2, 2), new Domino(3, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void nineElementsTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(5, 3), new Domino(3, 1),
+				new Domino(1, 2), new Domino(2, 4), new Domino(1, 6),
+				new Domino(2, 3), new Domino(3, 4), new Domino(5, 6)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	private void assertValidChain(List<Domino> inputDominoes, List<Domino> outputDominoes) {
+		assertSameDominoes(inputDominoes, outputDominoes);
+		assertEndDominoesMatch(outputDominoes);
+		assertConsecutiveDominoes(outputDominoes);
+	}
+	
+	private void assertEndDominoesMatch(List<Domino> outputDominoes) {
+		int leftValueOfFirstDomino = outputDominoes.get(0).getLeft();
+		int rightValueOfLastDomino = outputDominoes.get(outputDominoes.size() - 1).getRight();
+		String errorMessage = "The left value of the first domino ("
+		    + leftValueOfFirstDomino
+		    + ") needs to match the right value of the last domino ("
+		    + rightValueOfLastDomino
+		    + ").";
+		
+		assertEquals(errorMessage, leftValueOfFirstDomino, rightValueOfLastDomino);
+	}
+	
+	private void assertSameDominoes(List<Domino> inputDominoes, List<Domino> outputDominoes) {
+		String errorMessage = "The number of dominoes in the input list (" + inputDominoes.size()
+				+ ") needs to match the number of dominoes in the output chain (" + outputDominoes.size() + ")";
+		
+		assertEquals(errorMessage, inputDominoes.size(), outputDominoes.size());
+		
+		for (Domino domino : inputDominoes) {
+			int inputFrequency = Collections.frequency(inputDominoes, domino);
+			int outputFrequency = Collections.frequency(outputDominoes, domino);
+			
+			String frequencyErrorMessage = "The frequency of domino (" + domino.getLeft() + ", " + domino.getRight() + ")"
+					+ " in the input is (" + inputFrequency + "), but (" + outputFrequency + ") in the output.";
+					
+			assertEquals(frequencyErrorMessage, inputFrequency, outputFrequency);
+		}
+	}
+	
+	private void assertConsecutiveDominoes(List<Domino> dominoes) {
+		for (int i = 0; i < dominoes.size() - 1; i++) {
+			
+			int rightValueOfIthDomino = dominoes.get(i).getRight();
+			int leftValueOfNextDomino = dominoes.get(i+1).getLeft();
+			String errorMessage = "The right value of domino number " + i + " ("
+			    + rightValueOfIthDomino
+			    + ") needs to match the left value of domino number " + (i+1) + " ("
+			    + leftValueOfNextDomino
+			    + ").";
+			
+			assertEquals(errorMessage, dominoes.get(i).getRight(), dominoes.get(i+1).getLeft());
+		}
+	}
+}

exercises/settings.gradle

 include 'diamond'
 include 'difference-of-squares'
 include 'diffie-hellman'
+include 'dominoes'
 include 'error-handling'
 include 'etl'
 include 'flatten-array'