Tournament (#890)

* Added Tournament exercise

* Added to config and refactored after review

* Added topics and fixed indentation

* Must be unlocked by a core exercise

config.json

@@ -692,6 +692,20 @@
     },
     {
       "core": false,
+      "difficulty": 6,
+      "slug": "tournament",
+      "topics": [
+        "loops",
+        "maps",
+        "sorting",
+        "parsing",
+        "text_formatting"
+      ],
+      "unlocked_by": "matrix",
+      "uuid": "99191d53-0fed-f680-de7a-55cfb872de17bc58629"
+    },
+    {
+      "core": false,
       "difficulty": 7,
       "slug": "anagram",
       "topics": [

exercises/settings.gradle

@@ -75,6 +75,7 @@ include 'spiral-matrix'
 include 'strain'
 include 'sublist'
 include 'sum-of-multiples'
+include 'tournament'
 include 'transpose'
 include 'triangle'
 include 'trinary'

exercises/tournament/.meta/src/reference/java/Result.java

@@ -0,0 +1,5 @@
+enum Result {
+    WIN,
+    DRAW,
+    LOSS
+}

exercises/tournament/.meta/src/reference/java/TeamResult.java

@@ -0,0 +1,41 @@
+class TeamResult {
+
+    private int wins;
+    private int losses;
+    private int draws;
+
+    TeamResult() {
+        wins = 0;
+        losses = 0;
+        draws = 0;
+    }
+
+    int getPlayed() {
+        return wins + losses + draws;
+    }
+
+    int getPoints() {
+        return wins * 3 + draws;
+    }
+
+    int getWins() {
+        return wins;
+    }
+
+    int getLosses() {
+        return losses;
+    }
+
+    int getDraws() {
+        return draws;
+    }
+
+    void applyResult(final Result result) {
+        switch (result) {
+            case WIN: wins++; break;
+            case DRAW: draws++; break;
+            case LOSS: losses++; break;
+        }
+    }
+
+}

exercises/tournament/.meta/src/reference/java/Tournament.java

@@ -0,0 +1,62 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+class Tournament {
+
+    private static Pattern separatorPattern = Pattern.compile(";");
+    private static Pattern newlinePattern = Pattern.compile("\\n");
+
+    private Map<String, TeamResult> results;
+
+    Tournament() {
+        results = new HashMap<>();
+    }
+
+    String printTable() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(String.format("%-30s | %2s | %2s | %2s | %2s | %2s\n",
+                "Team", "MP", "W", "D", "L", "P"));
+        results.entrySet()
+                .stream()
+                .sorted(Tournament::comparator)
+                .forEach(e -> sb.append(
+                        String.format("%-30s | %2d | %2d | %2d | %2d | %2d\n",
+                                e.getKey(), e.getValue().getPlayed(), e.getValue().getWins(), e.getValue().getDraws(),
+                                e.getValue().getLosses(), e.getValue().getPoints())));
+        return sb.toString();
+    }
+
+    private static int comparator(Map.Entry<String, TeamResult> teamA, Map.Entry<String, TeamResult> teamB) {
+        int compareByPoints = Integer.compare(teamB.getValue().getPoints(), teamA.getValue().getPoints());
+        return compareByPoints == 0 ? teamA.getKey().compareTo(teamB.getKey()) : compareByPoints;
+    }
+
+    void applyResults(final String resultString) {
+        String[] matches = newlinePattern.split(resultString);
+        for (String matchString: matches) {
+            String[] column = separatorPattern.split(matchString);
+            final TeamResult home = results.getOrDefault(column[0], new TeamResult());
+            final TeamResult away = results.getOrDefault(column[1], new TeamResult());
+            final Result result = Result.valueOf(column[2].toUpperCase());
+            switch (result) {
+                case WIN:
+                    home.applyResult(Result.WIN);
+                    away.applyResult(Result.LOSS);
+                    break;
+                case LOSS:
+                    home.applyResult(Result.LOSS);
+                    away.applyResult(Result.WIN);
+                    break;
+                case DRAW:
+                    home.applyResult(Result.DRAW);
+                    away.applyResult(Result.DRAW);
+                    break;
+            }
+            results.put(column[0], home);
+            results.put(column[1], away);
+        }
+    }
+
+
+}

exercises/tournament/README.md

@@ -0,0 +1,78 @@
+# Tournament
+
+Tally the results of a small football competition.
+
+Based on an input file containing which team played against which and what the
+outcome was, create a file with a table like this:
+
+```
+Team                           | MP |  W |  D |  L |  P
+Devastating Donkeys            |  3 |  2 |  1 |  0 |  7
+Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
+Blithering Badgers             |  3 |  1 |  0 |  2 |  3
+Courageous Californians        |  3 |  0 |  1 |  2 |  1
+```
+
+What do those abbreviations mean?
+
+- MP: Matches Played
+- W: Matches Won
+- D: Matches Drawn (Tied)
+- L: Matches Lost
+- P: Points
+
+A win earns a team 3 points. A draw earns 1. A loss earns 0.
+
+The outcome should be ordered by points, descending. In case of a tie, teams are ordered alphabetically.
+
+###
+
+Input
+
+Your tallying program will receive input that looks like:
+
+```
+Allegoric Alaskans;Blithering Badgers;win
+Devastating Donkeys;Courageous Californians;draw
+Devastating Donkeys;Allegoric Alaskans;win
+Courageous Californians;Blithering Badgers;loss
+Blithering Badgers;Devastating Donkeys;loss
+Allegoric Alaskans;Courageous Californians;win
+```
+
+The result of the match refers to the first team listed. So this line
+
+```
+Allegoric Alaskans;Blithering Badgers;win
+```
+
+Means that the Allegoric Alaskans beat the Blithering Badgers.
+
+This line:
+
+```
+Courageous Californians;Blithering Badgers;loss
+```
+
+Means that the Blithering Badgers beat the Courageous Californians.
+
+And this line:
+
+```
+Devastating Donkeys;Courageous Californians;draw
+```
+
+Means that the Devastating Donkeys and Courageous Californians tied.
+
+
+To run the tests:
+
+```sh
+$ gradle test
+```
+
+For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/tournament/build.gradle

@@ -0,0 +1,18 @@
+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/tournament/src/test/java/TournamentTest.java

@@ -0,0 +1,160 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TournamentTest {
+
+    private Tournament tournament;
+
+    @Before
+    public void setUp() {
+        tournament = new Tournament();
+    }
+
+    @Test
+    public void justTheHeaderIfNoInput() {
+        assertEquals("Team                           | MP |  W |  D |  L |  P\n", tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aWinIsThreePointsALossIsZeroPoints() {
+        tournament.applyResults("Allegoric Alaskans;Blithering Badgers;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n" +
+                "Blithering Badgers             |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aWinCanAlsoBeExpressedAsALoss() {
+        tournament.applyResults("Blithering Badgers;Allegoric Alaskans;loss");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n" +
+                "Blithering Badgers             |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aDifferentTeamCanWin() {
+        tournament.applyResults("Blithering Badgers;Allegoric Alaskans;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n" +
+                "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aDrawIsOnePointEach() {
+        tournament.applyResults( "Allegoric Alaskans;Blithering Badgers;draw");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1\n" +
+                "Blithering Badgers             |  1 |  0 |  1 |  0 |  1\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void thereCanBeMoreThanOneMatch() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Allegoric Alaskans;Blithering Badgers;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n" +
+                "Blithering Badgers             |  2 |  0 |  0 |  2 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void thereCanBeMoreThanOneWinner() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;loss\n" +
+                "Allegoric Alaskans;Blithering Badgers;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n" +
+                "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void thereCanBeMoreThanTwoTeams() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Blithering Badgers;Courageous Californians;win\n" +
+                "Courageous Californians;Allegoric Alaskans;loss");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n" +
+                "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n" +
+                "Courageous Californians        |  2 |  0 |  0 |  2 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void typicalInput() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Devastating Donkeys;Courageous Californians;draw\n" +
+                "Devastating Donkeys;Allegoric Alaskans;win\n" +
+                "Courageous Californians;Blithering Badgers;loss\n" +
+                "Blithering Badgers;Devastating Donkeys;loss\n" +
+                "Allegoric Alaskans;Courageous Californians;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n" +
+                "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n" +
+                "Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n" +
+                "Courageous Californians        |  3 |  0 |  1 |  2 |  1\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void incompleteCompetition() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;loss\n" +
+                "Devastating Donkeys;Allegoric Alaskans;loss\n" +
+                "Courageous Californians;Blithering Badgers;draw\n" +
+                "Allegoric Alaskans;Courageous Californians;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n" +
+                "Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n" +
+                "Courageous Californians        |  2 |  0 |  1 |  1 |  1\n" +
+                "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tiesBrokenAlphabetically() {
+        tournament.applyResults(
+                "Courageous Californians;Devastating Donkeys;win\n" +
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Devastating Donkeys;Allegoric Alaskans;loss\n" +
+                "Courageous Californians;Blithering Badgers;win\n" +
+                "Blithering Badgers;Devastating Donkeys;draw\n" +
+                "Allegoric Alaskans;Courageous Californians;draw");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n" +
+                "Courageous Californians        |  3 |  2 |  1 |  0 |  7\n" +
+                "Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n" +
+                "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1\n",
+                tournament.printTable());
+    }
+}