trackler 2.2.1.44 → 2.2.1.45

data/tracks/java/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'

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

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

data/tracks/java/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;
+        }
+    }
+
+}

data/tracks/java/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);
+        }
+    }
+
+
+}

data/tracks/java/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.

data/tracks/java/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"]
+    }
+}

data/tracks/java/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());
+    }
+}

data/tracks/php/config.json

@@ -574,6 +574,20 @@
       "topics": [
         "Arrays"
       ]
+    },
+    {
+      "uuid": "94f22d74-e358-41cb-be64-8abc111ff95a",
+      "core" :  false,
+      "difficulty" : 1,
+      "slug" : "collatz-conjecture",
+      "topics": [
+        "Control-flow (loops)",
+        "Control-flow (conditionals)",
+        "Integers",
+        "Algorithms",
+        "Mathematics"
+      ],
+      "unlocked_by": "null"
     }
   ]
 }

data/tracks/php/exercises/collatz-conjecture/collatz-conjecture_test.php

@@ -0,0 +1,44 @@
+<?php
+
+require "collatz-conjecture.php";
+
+class CollatzConjecture extends PHPUnit\Framework\TestCase
+{
+
+    public function testZeroStepsForOne()
+    {
+        $this->assertEquals(0, steps(1));
+    }
+
+    public function testDivideIfEven()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(4, steps(16));
+    }
+
+    public function testEvenAndOddSteps()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(9, steps(12));
+    }
+
+    public function testLargeNumberOfEvenAndOddSteps()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(152, steps(1000000));
+    }
+
+    public function testZeroIsAnError()
+    {
+        $this->markTestSkipped();
+        $this->expectException('InvalidArgumentException', 'Only positive numbers are allowed');
+        steps(0);
+    }
+
+    public function testNegativeValueIsAnError()
+    {
+        $this->markTestSkipped();
+        $this->expectException('InvalidArgumentException', 'Only positive numbers are allowed');
+        steps(-1);
+    }
+}

data/tracks/php/exercises/collatz-conjecture/example.php

@@ -0,0 +1,18 @@
+<?php
+
+function steps($number)
+{
+    $stepCount = 0;
+    if ($number < 1) {
+        throw new InvalidArgumentException('Only positive numbers are allowed');
+    }
+    do {
+        if ($number === 1) {
+            break;
+        }
+        $stepCount++;
+        $number = ( $number % 2 === 0 ? $number / 2 : 3 * $number + 1);
+    } while ($number !== 0);
+
+    return $stepCount;
+}

data/tracks/python/exercises/circular-buffer/circular_buffer.py

@@ -7,5 +7,5 @@ class BufferEmptyException(Exception):
 
 
 class CircularBuffer(object):
-    def __init__(self):
+    def __init__(self, capacity):
         pass

data/tracks/python/exercises/clock/clock.py

@@ -1,3 +1,3 @@
 class Clock(object):
-    def __init__(self):
+    def __init__(self, hour, minute):
         pass

data/tracks/python/exercises/etl/etl.py

@@ -1,2 +1,2 @@
-def transform():
+def transform(legacy_data):
     pass

data/tracks/python/exercises/grade-school/grade_school.py

@@ -1,3 +1,3 @@
 class School(object):
-    def __init__(self):
+    def __init__(self, name):
         pass

data/tracks/python/exercises/grains/grains.py

@@ -1,6 +1,6 @@
-def on_square():
+def on_square(integer_number):
     pass
 
 
-def total_after():
+def total_after(integer_number):
     pass

data/tracks/python/exercises/kindergarten-garden/kindergarten_garden.py

@@ -1,3 +1,3 @@
 class Garden(object):
-    def __init__(self):
+    def __init__(self, diagram, students):
         pass

data/tracks/python/exercises/linked-list/linked_list.py

@@ -1,5 +1,5 @@
 class Node(object):
-    def __init__(self):
+    def __init__(self, value, next=None, previous=None):
         pass
 
 

data/tracks/python/exercises/rectangles/rectangles.py

@@ -1,2 +1,2 @@
-def count():
+def count(ascii_diagram):
     pass

data/tracks/python/exercises/sum-of-multiples/sum_of_multiples.py

@@ -1,2 +1,2 @@
-def sum_of_multiples():
+def sum_of_multiples(limit, multiples):
     pass

data/tracks/rust/exercises/bob/tests/bob.rs

@@ -63,6 +63,7 @@ fn test_shouting_numbers() {
 }
 
 #[test]
+#[ignore]
 fn test_only_numbers() {
     assert_eq!("Whatever.", bob::reply("1, 2, 3"));
 }

data/tracks/rust/exercises/crypto-square/tests/crypto-square.rs

@@ -12,6 +12,7 @@ fn test_empty_input() {
 
 
 #[test]
+#[ignore]
 fn test_encrypt_also_decrypts_square() {
     // note that you only get the exact input back if:
     // 1. no punctuation
@@ -23,6 +24,7 @@ fn test_encrypt_also_decrypts_square() {
 }
 
 #[test]
+#[ignore]
 fn test_example() {
     test(
         "If man was meant to stay on the ground, god would have given us roots.",
@@ -31,11 +33,13 @@ fn test_example() {
 }
 
 #[test]
+#[ignore]
 fn test_empty_last_line() {
     test("congratulate", "crl oaa ntt gue")
 }
 
 #[test]
+#[ignore]
 fn test_spaces_are_reorganized() {
     test("abet", "ae bt");
     test("a bet", "ae bt");
@@ -43,6 +47,7 @@ fn test_spaces_are_reorganized() {
 }
 
 #[test]
+#[ignore]
 fn test_everything_becomes_lowercase() {
     test("caSe", "cs ae");
     test("cAsE", "cs ae");
@@ -50,6 +55,7 @@ fn test_everything_becomes_lowercase() {
 }
 
 #[test]
+#[ignore]
 fn test_ignore_non_ascii_chars() {
     test(
         "She got her education, then got rich programming: 👩‍🎓🎓👩‍💻💰",
@@ -58,6 +64,7 @@ fn test_ignore_non_ascii_chars() {
 }
 
 #[test]
+#[ignore]
 fn test_long() {
     test(
         r#"

data/tracks/rust/exercises/gigasecond/tests/gigasecond.rs

@@ -8,7 +8,7 @@ extern crate gigasecond;
  *
  * The first time you run `cargo test`, the Chrono crate will automatically be downloaded
  * and installed. More information on crates can be found at
- * https://doc.rust-lang.org/book/guessing-game.html#generating-a-secret-number
+ * https://doc.rust-lang.org/book/second-edition/ch02-00-guessing-game-tutorial.html#generating-a-random-number
  *
  * In order to use the crate, your solution will need to start with the two following lines
 */

data/tracks/rust/exercises/phone-number/Cargo.lock

@@ -1,4 +1,4 @@
 [root]
 name = "phone-number"
-version = "0.0.0"
+version = "1.2.0"
 

data/tracks/rust/exercises/phone-number/Cargo.toml

@@ -1,3 +1,3 @@
 [package]
 name = "phone-number"
-version = "0.0.0"
+version = "1.2.0"

data/tracks/rust/exercises/phone-number/example.rs

@@ -1,27 +1,21 @@
 pub fn number(s: &str) -> Option<String> {
-    let digits: String = s
-        .chars()
-        .filter(|&c| c.is_digit(10))
-        .collect();
+    let digits: String = s.chars().filter(|&c| c.is_digit(10)).collect();
     match digits.len() {
-        10 => Some(digits),
-        11 => match digits.chars().nth(0) {
-            Some('1') => Some(digits[1..].to_string()),
-            _   => None
-        },
-        _  => None
+        10 => {
+            match (digits.chars().nth(0), digits.chars().nth(3)) {
+                (Some('0'), _) => None,
+                (Some('1'), _) => None,
+                (_, Some('0')) => None,
+                (_, Some('1')) => None,
+                _ => Some(digits),
+            }
+        }
+        11 => {
+            match digits.chars().nth(0) {
+                Some('1') => Some(digits[1..].to_string()),
+                _ => None,
+            }
+        }
+        _ => None,
     }
 }
-
-pub fn area_code(s: &str) -> Option<String> {
-    number(s).map(|n| n[..3].to_string())
-}
-
-pub fn pretty_print(s: &str) -> String {
-    number(s).map(|n|
-        format!("({area}) {prefix}-{exchange}",
-                area=&n[..3],
-                prefix=&n[3..6],
-                exchange=&n[6..])
-    ).unwrap_or("invalid".to_string())
-}