trackler 2.2.1.148 → 2.2.1.149

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbab684afe326ddd909b3361ba000477a186b627
-  data.tar.gz: 883862a6b7800c61b5210346f40e031c68058c69
+  metadata.gz: 42008f25c06e6b05e9f0ec0cba67f543bca6dbb1
+  data.tar.gz: f39be98e422e1df1bfc7ce5d221c7190e22ab4c8
 SHA512:
-  metadata.gz: 2643b2729030dfedb42b4305ef9e42ff4de1c628f753ff56ae9beb5dc44b71116013f4489396b202ce103c5e62bb0f12334af8fde4305ab60548dc4e5f0d2172
-  data.tar.gz: 74c5a67d7a337e2f26c9069634a19eb6804156c3c501b3e5b80d7460eb0fc3da0feb34e20ca2d3728da8c59318c5c652d013e4bb95599fa104e8b731218dddae
+  metadata.gz: f64e08b7041c734026adbb3034e64aadd14bc5eb666168b358f60ff158f6476326b788d1df596e8afa0f72eb5a98e8d81cf37ba4fb9dc741fc18cd9a47f6e8eb
+  data.tar.gz: 30293b1538d99bdcd9fc29a0676a31b5a7817af48f1413c2582babcc0548e2bd7ed4c76edd1bc3bbc8de7bbbc7eae5db8133af063450f1a33978ae30d197edfc

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.148"
+  VERSION = "2.2.1.149"
 end

data/problem-specifications/exercises/bracket-push/description.md

@@ -1,2 +1,3 @@
-Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
-verify that all the pairs are matched and nested correctly.
+Given a string containing brackets `[]`, braces `{}`, parentheses `()`,
+or any combination thereof, verify that any and all pairs are matched
+and nested correctly.

data/problem-specifications/exercises/forth/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "forth",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "comments": [
     "The cases are split into multiple sections, all with the same structure.",
     "In all cases, the `expected` key is the resulting stack",
@@ -364,6 +364,31 @@
           },
           "expected": [12]
         },
+        {
+          "description": "can use different words with the same name",
+          "property": "evaluate",
+          "input": {
+            "instructions": [
+              ": foo 5 ;",
+              ": bar foo ;",
+              ": foo 6 ;",
+              "bar foo"
+            ]
+          },
+          "expected": [5, 6]
+        },
+        {
+          "description": "can define word that uses word with the same name",
+          "property": "evaluate",
+          "input": {
+            "instructions": [
+              ": foo 10 ;",
+              ": foo foo 1 + ;",
+              "foo"
+            ]
+          },
+          "expected": [11]
+        },
         {
           "description": "cannot redefine numbers",
           "property": "evaluate",

data/problem-specifications/exercises/list-ops/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "list-ops",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "comments": [
     "Though there are no specifications here for dealing with large lists,",
     "implementers may add tests for handling large lists to ensure that the",
@@ -40,7 +40,7 @@
       ]
     },
     {
-      "description": "concat lists and lists of list into a new list",
+      "description": "concatenate a list of lists",
       "cases": [
         {
           "description": "empty list",
@@ -57,6 +57,14 @@
             "lists": [[1, 2], [3], [], [4, 5, 6]]
           },
           "expected": [1, 2, 3, 4, 5, 6]
+        },
+        {
+          "description": "list of nested lists",
+          "property": "concat",
+          "input": {
+            "lists": [[[1], [2]], [[3]], [[]], [[4, 5, 6]]]
+          },
+          "expected": [[1], [2], [3], [], [4, 5, 6]]
         }
       ]
     },

data/tracks/dart/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/delphi/exercises/bracket-push/README.md

@@ -1,7 +1,8 @@
 # Bracket Push
 
-Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
-verify that all the pairs are matched and nested correctly.
+Given a string containing brackets `[]`, braces `{}`, parentheses `()`,
+or any combination thereof, verify that any and all pairs are matched
+and nested correctly.
 
 ## Testing
 

data/tracks/elisp/config.json

@@ -9,6 +9,14 @@
       "unlocked_by": null,
       "uuid": "c4fdc935-885b-44bd-84e4-fae4a09e8c39"
     },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "two-fer",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "36e5dc3a-2122-484a-ae82-beb7b813e2cd"
+    },
     {
       "core": false,
       "difficulty": 1,
@@ -176,6 +184,14 @@
       "topics": null,
       "unlocked_by": null,
       "uuid": "a252e137-8a63-4f26-b119-7264f12a257a"
+    },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "armstrong-numbers",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "059141f0-f28d-4d10-a03a-7852dbfc2d2e"
     }
   ],
   "foregone": [],

data/tracks/elisp/exercises/armstrong-numbers/README.md

@@ -0,0 +1,19 @@
+## Armstrong numbers
+
+An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.
+
+For example:
+
+- 9 is an Armstrong number, because `9 = 9^1 = 9`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`
+- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
+- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+
+Write some code to determine whether a number is an Armstrong number.
+
+## Source
+
+See more at [wikipedia](https://en.wikipedia.org/wiki/Narcissistic_number)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elisp/exercises/armstrong-numbers/armstrong-numbers-test.el

@@ -0,0 +1,41 @@
+;;; armstrong-numbers-test.el --- Tests for armstrong-numbers (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(load-file "armstrong-numbers.el")
+
+(ert-deftest armstrong-number-5 ()
+  "Single digit numbers are Armstrong numbers"
+  (should (armstrong-p 5)))
+
+(ert-deftest not-armstrong-number-10 ()
+  "There are no 2 digit Armstrong numbers"
+  (should (not (armstrong-p 10))))
+
+(ert-deftest armstrong-number-153 ()
+  "Three digit number that should an Armstrong number"
+  (should (armstrong-p 153)))
+
+(ert-deftest not-armstrong-number-100 ()
+  "Three digit number that should an Armstrong number"
+  (should (not (armstrong-p 100))))
+
+(ert-deftest armstrong-number-9474 ()
+  "Four digit number that should an Armstrong number"
+  (should (armstrong-p 9474)))
+
+(ert-deftest not-armstrong-number-9475 ()
+  "Four digit number that should not an Armstrong number"
+  (should (not (armstrong-p 9476))))
+
+(ert-deftest armstrong-number-9926315 ()
+  "Seven digit number that should an Armstrong number"
+  (should (armstrong-p 9926315)))
+
+(ert-deftest not-armstrong-number-9926314 ()
+  "Seven digit number that should not an Armstrong number"
+  (should (not (armstrong-p 9926314))))
+
+;;; armstrong-numbers-test.el ends here

data/tracks/elisp/exercises/armstrong-numbers/armstrong-numbers.el

@@ -0,0 +1,8 @@
+;;; armstrong-numbers.el --- armstrong-numbers Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(provide 'armstrong-numbers)
+;;; armstrong-numbers.el ends here

data/tracks/elisp/exercises/armstrong-numbers/example.el

@@ -0,0 +1,13 @@
+;;; armstrong-numbers.el --- armstrong-numbers Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(defun armstrong-p (n)
+  (let* ((digits (mapcar #'(lambda (d) (- d ?0)) (string-to-list (int-to-string n))))
+	 (p (length digits)))
+    (= n (apply '+ (mapcar #'(lambda (d) (expt d p)) digits)))))
+
+(provide 'armstrong-numbers)
+;;; armstrong-numbers.el ends here

data/tracks/elisp/exercises/hello-world/example.el

@@ -4,10 +4,8 @@
 
 ;;; Code:
 
-(defun hello (&optional name)
-  "Say hello, optionally to NAME."
-  (let ((greetee (or name "World")))
-    (concat "Hello, " greetee "!")))
+(defun hello ()
+  "Hello, World!")
 
 (provide 'hello-world)
 ;;; hello-world.el ends here

data/tracks/elisp/exercises/hello-world/hello-world-test.el

@@ -1,18 +1,15 @@
 ;;; hello-world-test.el --- Tests for Hello World (exercism)
 
 ;;; Commentary:
+;; Common test data version: 1.1.0 be3ae66
 
 ;;; Code:
 
 (load-file "hello-world.el")
 
-(ert-deftest no-args ()
+(ert-deftest hello-world-test ()
   (should (equal (hello) "Hello, World!")))
 
-(ert-deftest with-args ()
-  (should (equal (hello "Emacs") "Hello, Emacs!"))
-  (should (equal (hello "Exercism") "Hello, Exercism!")))
-
 (provide 'hello-world-test)
 
 ;;; hello-world-test.el ends here

data/tracks/elisp/exercises/two-fer/README.md

@@ -0,0 +1,19 @@
+# Two Fer
+
+`Two-fer` or `2-fer` is short for two for one. One for you and one for me.
+
+```text
+"One for X, one for me."
+```
+
+When X is a name or "you".
+
+If the given name is "Alice", the result should be "One for Alice, one for me."
+If no name is given, the result should be "One for you, one for me."
+
+## Source
+
+[https://en.wikipedia.org/wiki/Two-fer](https://en.wikipedia.org/wiki/Two-fer)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elisp/exercises/two-fer/example.el

@@ -0,0 +1,13 @@
+;;; two-fer.el --- Two-fer Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(defun two-fer (&optional name)
+  (let ((player (or name "you")))
+    (concat "One for " player ", one for me.")))
+
+(provide 'two-fer)
+
+;;; two-fer.el ends here

data/tracks/elisp/exercises/two-fer/two-fer-test.el

@@ -0,0 +1,21 @@
+;;; two-fer-test.el --- Tests for Two-fer (exercism)
+
+;;; Commentary:
+;; Common test data version: 1.2.0 4fc1acb
+
+;;; Code:
+
+(load-file "two-fer.el")
+
+(ert-deftest no-name-given ()
+  (should (equal (two-fer) "One for you, one for me.")))
+
+(ert-deftest a-name-given ()
+  (should (equal (two-fer "Alice") "One for Alice, one for me.")))
+
+(ert-deftest another-name-given ()
+  (should (equal (two-fer "Bob") "One for Bob, one for me.")))
+
+(provide 'two-fer-test)
+
+;;; two-fer-test.el ends here

data/tracks/elisp/exercises/two-fer/two-fer.el

@@ -0,0 +1,9 @@
+;;; hello-world.el --- Hello World Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+
+(provide 'hello-world)
+;;; hello-world.el ends here

data/tracks/java/exercises/poker/.meta/src/reference/java/Card.java

@@ -16,10 +16,13 @@ class Card {
     }
 
     private int parseRank(String card) {
-        return "..23456789TJQKA".indexOf(card.charAt(0));
+    	if (card.substring(0, 2).equals("10")) {
+    		return 10;
+    	}
+    	return "..23456789TJQKA".indexOf(card.charAt(0));
     }
 
     private int parseSuit(String card) {
-        return ".HSDC".indexOf(card.charAt(1));
+        return ".HSDC".indexOf(card.charAt(card.length() - 1));
     }
 }

data/tracks/java/exercises/poker/.meta/src/reference/java/Hand.java

@@ -38,10 +38,9 @@ class Hand {
         }
         return frequencyMap;
     }
-
+    
     private int scoreHand(List<Card> cards) {
-        List<Card> cardsByRank = cards
-                .stream()
+        List<Card> cardsByRank = cards.stream()
                 .sorted(Comparator.comparing(Card::getRank))
                 .unordered()
                 .collect(Collectors.toList());
@@ -63,7 +62,10 @@ class Hand {
                 .stream()
                 .map(Map.Entry::getValue)
                 .collect(Collectors.toList());
-        List<Integer> suits = cards.stream().map(Card::getSuit).collect(Collectors.toList());
+        List<Integer> suits = cards
+                .stream()
+                .map(Card::getSuit)
+                .collect(Collectors.toList());
 
         return calculatedScore(frequencyMap, cardsByRank, ranks, rankCounts, suits);
     }
@@ -74,9 +76,15 @@ class Hand {
             ranks = Arrays.asList(5, 4, 3, 2, 1);
         }
 
-        boolean flush = suits.stream().distinct().count() == 1;
-        boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
+        boolean flush = suits
+                .stream()
+                .distinct()
+                .count() == 1;
+        boolean straight = ranks.stream().distinct().count() == 5 
+            && ranks.get(0) - ranks.get(4) == 4;
+        
         Iterator<Integer> iteratorOverFrequencies = frequencyMap.keySet().iterator();
+        
         int highestFrequency = iteratorOverFrequencies.next();
 
         if (straight && flush) {
@@ -86,24 +94,55 @@ class Hand {
             return 700 + cardsByRank.get(0).getRank();
         }
         if (rankCounts.equals(Arrays.asList(3, 2))) {
-            return 600 + cardsByRank.get(0).getRank();
+            int triplet = 0;
+            int pair = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                if (frequencyMap.get(key) == 2) {
+                    pair = (int) key;
+                }
+                if (frequencyMap.get(key) == 3) {
+                    triplet = 3 * (int) key;
+                }
+            }
+            return 600 + 3 * triplet + pair;
         }
         if (flush) {
             return 500 + highestFrequency;
         }
         if (straight) {
-            return 400 + highestFrequency;
+            int maxValue = Collections.max(ranks);
+            return 400 + maxValue;
         }
         if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
-            return 300 + cardsByRank.get(0).getRank();
+            List<Integer> uniqueCards = new ArrayList<Integer>();
+            int triplet = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                if (frequencyMap.get(key) == 1) {
+                    uniqueCards.add((int) key);
+                }
+                if (frequencyMap.get(key) == 3) {
+                    triplet = 3 * (int) key;
+                }
+            }
+            return 300 + triplet + Collections.max(uniqueCards);
         }
         if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
-            return 200 + Math.max(highestFrequency, iteratorOverFrequencies.next());
+            int productsOfFrequencyAndValue = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                int frequencyKey = (int) key;
+                int frequencyValue = frequencyMap.get(key);
+                productsOfFrequencyAndValue += frequencyKey * frequencyValue;
+            }
+            return 200 + productsOfFrequencyAndValue + 2 * Math.max(highestFrequency, iteratorOverFrequencies.next());
         }
         if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
             return 100 + highestFrequency;
         }
         ranks.sort(Comparator.naturalOrder());
-        return ranks.get(0);
+        int result = 0;
+        for (int i = 0; i < ranks.size(); i++) {
+            result += ranks.get(0) * (i + 1);
+        }
+        return result + ranks.get(ranks.size() - 1);
     }
-}
+}               

data/tracks/java/exercises/poker/.meta/version.txt

@@ -0,0 +1 @@
+1.1.0

data/tracks/java/exercises/poker/src/test/java/PokerTest.java

@@ -2,6 +2,7 @@ import org.junit.Ignore;
 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.Collections;
 
 import static org.junit.Assert.assertEquals;
 
@@ -9,99 +10,174 @@ public class PokerTest {
     @Test
     public void oneHand() {
         String hand = "4S 5S 7H 8D JC";
-        assertEquals(Arrays.asList(hand), new Poker(Arrays.asList(hand)).getBestHands());
+        assertEquals(Collections.singletonList(hand), new Poker(Collections.singletonList(hand)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void highestCardWins() {
+        String highest8 = "4D 5S 6S 8D 3C";
+        String highest10 = "2S 4C 7S 9H 10H";
+        String highestJ = "3S 4S 5D 6H JH";
+        assertEquals(Collections.singletonList(highestJ), new Poker(Arrays.asList(highest8, highest10, highestJ)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tieHasMultipleWinners() {
+        String highest8 = "4D 5S 6S 8D 3C";
+        String highest10 = "2S 4C 7S 9H 10H";
+        String highestJh = "3S 4S 5D 6H JH";
+        String highestJd = "3H 4H 5C 6C JD";
+        assertEquals(Arrays.asList(highestJh, highestJd),
+                new Poker(Arrays.asList(highest8, highest10, highestJh, highestJd)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameHighCards() {
+        String nextHighest3 = "3S 5H 6S 8D 7H";
+        String nextHighest2 = "2S 5D 6D 8C 7S";
+        assertEquals(Collections.singletonList(nextHighest3), new Poker(Arrays.asList(nextHighest3, nextHighest2)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nothingVsOnePair() {
-        String nothing = "4S 5H 6S 8D JH";
+        String nothing = "4S 5H 6C 8D KH";
         String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
+        assertEquals(Collections.singletonList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoPairs() {
         String pairOf2 = "4S 2H 6S 2D JH";
-        String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
+        String pairOf4 = "2S 4H 6C 4D JD";
+        assertEquals(Collections.singletonList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void onePairVsDoublePair() {
         String pairOf8 = "2S 8H 6S 8D JH";
-        String doublePair = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
+        String doublePair = "4S 5H 4C 8C 5C";
+        assertEquals(Collections.singletonList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoDoublePairs() {
-        String doublePair2And8 = "2S 8H 2S 8D JH";
-        String doublePair4And5 = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair2And8), new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
+        String doublePair2And8 = "2S 8H 2D 8D 3H";
+        String doublePair4And5 = "4S 5H 4C 8S 5D";
+        assertEquals(Collections.singletonList(doublePair2And8),
+                new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameHighestPair() {
+        String doublePair2AndQ = "2S QS 2C QD JH";
+        String doublePairJAndQ = "JD QH JS 8D QC";
+        assertEquals(Collections.singletonList(doublePairJAndQ),
+                new Poker(Arrays.asList(doublePairJAndQ, doublePair2AndQ)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void identicallyRankedPairs() {
+        String kicker8 = "JD QH JS 8D QC";
+        String kicker2 = "JS QS JC 2D QD";
+        assertEquals(Collections.singletonList(kicker8), new Poker(Arrays.asList(kicker8, kicker2)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void doublePairVsThree() {
-        String doublePair2And8 = "2S 8H 2S 8D JH";
-        String threeOf4 = "4S 5H 4S 8D 4H";
-        assertEquals(Arrays.asList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
+        String doublePair2And8 = "2S 8H 2H 8D JH";
+        String threeOf4 = "4S 5H 4C 8S 4H";
+        assertEquals(Collections.singletonList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoThrees() {
-        String threeOf2 = "2S 2H 2S 8D JH";
-        String threeOf1 = "4S AH AS 8D AH";
-        assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
+        String threeOf2 = "2S 2H 2C 8D JH";
+        String threeOf1 = "4S AH AS 8C AD";
+        assertEquals(Collections.singletonList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameThreesMultipleDecks() {
+        String remainingCard7 = "4S AH AS 7C AD";
+        String remainingCard8 = "4S AH AS 8C AD";
+        assertEquals(Collections.singletonList(remainingCard8),
+                new Poker(Arrays.asList(remainingCard7, remainingCard8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void threeVsStraight() {
-        String threeOf4 = "4S 5H 4S 8D 4H";
-        String straight = "3S 4H 2S 6D 5H";
-        assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
+        String threeOf4 = "4S 5H 4C 8D 4H";
+        String straight = "3S 4D 2S 6D 5C";
+        assertEquals(Collections.singletonList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void AcesCanEndAStraight() {
+        String hand = "4S 5H 4C 8D 4H";
+        String straightEndsA = "10D JH QS KD AC";
+        assertEquals(Collections.singletonList(straightEndsA), new Poker(Arrays.asList(hand, straightEndsA)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void AcesCanStartAStraight() {
+        String hand = "4S 5H 4C 8D 4H";
+        String straightStartA = "4D AH 3S 2D 5C";
+        assertEquals(Collections.singletonList(straightStartA), new Poker(Arrays.asList(hand, straightStartA)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoStraights() {
-        String straightTo8 = "4S 6H 7S 8D 5H";
+        String straightTo8 = "4S 6C 7S 8D 5H";
         String straightTo9 = "5S 7H 8S 9D 6H";
-        assertEquals(Arrays.asList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
+        assertEquals(Collections.singletonList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
+    }
 
-        String straightTo1 = "AS QH KS TD JH";
-        String straightTo5 = "4S AH 3S 2D 5H";
-        assertEquals(Arrays.asList(straightTo1), new Poker(Arrays.asList(straightTo1, straightTo5)).getBestHands());
+    @Ignore("Remove to run test")
+    @Test
+    public void theLowestStraightStartsWithAce() {
+        String straight = "2H 3C 4D 5D 6H";
+        String straightStartA = "4S AH 3S 2D 5H";
+        assertEquals(Collections.singletonList(straight), new Poker(Arrays.asList(straight, straightStartA)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void straightVsFlush() {
-        String straightTo8 = "4S 6H 7S 8D 5H";
+        String straightTo8 = "4C 6H 7D 8D 5H";
         String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
+        assertEquals(Collections.singletonList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoFlushes() {
-        String flushTo8 = "3H 6H 7H 8H 5H";
+        String flushTo8 = "4H 7H 8H 9H 6H";
         String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
+        assertEquals(Collections.singletonList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void flushVsFull() {
         String flushTo8 = "3H 6H 7H 8H 5H";
-        String full = "4S 5H 4S 5D 4H";
-        assertEquals(Arrays.asList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
+        String full = "4S 5H 4C 5D 4H";
+        assertEquals(Collections.singletonList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
@@ -109,55 +185,56 @@ public class PokerTest {
     public void twoFulls() {
         String fullOf4By9 = "4H 4S 4D 9S 9D";
         String fullOf5By8 = "5H 5S 5D 8S 8D";
-        assertEquals(Arrays.asList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
+        assertEquals(Collections.singletonList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void fullVsSquare() {
-        String full = "4S 5H 4S 5D 4H";
-        String squareOf3 = "3S 3H 2S 3D 3H";
-        assertEquals(Arrays.asList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
+    public void twoFullssameThripletMultipleDecks() {
+        String fullOf5By9 = "5H 5S 5D 9S 9D";
+        String fullOf5By8 = "5H 5S 5D 8S 8D";
+        assertEquals(Collections.singletonList(fullOf5By9), new Poker(Arrays.asList(fullOf5By9, fullOf5By8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void twoSquares() {
-        String squareOf2 = "2S 2H 2S 8D 2H";
-        String squareOf5 = "4S 5H 5S 5D 5H";
-        assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
+    public void fullVsSquare() {
+        String full = "4S 5H 4D 5D 4H";
+        String squareOf3 = "3S 3H 2S 3D 3C";
+        assertEquals(Collections.singletonList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void squareVsStraightFlush() {
-        String squareOf5 = "4S 5H 5S 5D 5H";
-        String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
+    public void twoSquares() {
+        String squareOf2 = "2S 2H 2C 8D 2D";
+        String squareOf5 = "4S 5H 5S 5D 5C";
+        assertEquals(Collections.singletonList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void twoStraightFlushes() {
-        String straightFlushTo8 = "4H 6H 7H 8H 5H";
-        String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
+    public void sameSquaresMultipleDecks() {
+        String kicker2 = "3S 3H 2S 3D 3C";
+        String kicker4 = "3S 3H 4S 3D 3C";
+        assertEquals(Collections.singletonList(kicker4), new Poker(Arrays.asList(kicker2, kicker4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void threeHandWithTie() {
-        String spadeStraightTo9 = "9S 8S 7S 6S 5S";
-        String diamondStraightTo9 = "9D 8D 7D 6D 5D";
-        String threeOf4 = "4D 4S 4H QS KS";
-        assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), new Poker(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)).getBestHands());
+    public void squareVsStraightFlush() {
+        String squareOf5 = "4S 5H 5S 5D 5C";
+        String straightFlushTo9 = "7S 8S 9S 6S 10S";
+        assertEquals(Collections.singletonList(straightFlushTo9),
+                new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void straightTo5AgainstAPairOfJacks() {
-        String straightTo5 = "2S 4D 5C 3S AS";
-        String twoJacks = "JD 8D 7D JC 5D";
-        assertEquals(Arrays.asList(straightTo5), new Poker(Arrays.asList(straightTo5, twoJacks)).getBestHands());
+    public void twoStraightFlushes() {
+        String straightFlushTo8 = "4H 6H 7H 8H 5H";
+        String straightFlushTo9 = "5S 7S 8S 9S 6S";
+        assertEquals(Collections.singletonList(straightFlushTo9),
+                new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
     }
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.148
+  version: 2.2.1.149
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-14 00:00:00.000000000 Z
+date: 2018-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -4081,6 +4081,10 @@ files:
 - tracks/elisp/exercises/anagram/anagram-test.el
 - tracks/elisp/exercises/anagram/anagram.el
 - tracks/elisp/exercises/anagram/example.el
+- tracks/elisp/exercises/armstrong-numbers/README.md
+- tracks/elisp/exercises/armstrong-numbers/armstrong-numbers-test.el
+- tracks/elisp/exercises/armstrong-numbers/armstrong-numbers.el
+- tracks/elisp/exercises/armstrong-numbers/example.el
 - tracks/elisp/exercises/atbash-cipher/README.md
 - tracks/elisp/exercises/atbash-cipher/atbash-cipher-test.el
 - tracks/elisp/exercises/atbash-cipher/atbash-cipher.el
@@ -4153,6 +4157,10 @@ files:
 - tracks/elisp/exercises/roman-numerals/example.el
 - tracks/elisp/exercises/roman-numerals/roman-numerals-test.el
 - tracks/elisp/exercises/roman-numerals/roman-numerals.el
+- tracks/elisp/exercises/two-fer/README.md
+- tracks/elisp/exercises/two-fer/example.el
+- tracks/elisp/exercises/two-fer/two-fer-test.el
+- tracks/elisp/exercises/two-fer/two-fer.el
 - tracks/elisp/exercises/word-count/README.md
 - tracks/elisp/exercises/word-count/example.el
 - tracks/elisp/exercises/word-count/word-count-test.el
@@ -7970,6 +7978,7 @@ files:
 - tracks/java/exercises/poker/.meta/src/reference/java/Card.java
 - tracks/java/exercises/poker/.meta/src/reference/java/Hand.java
 - tracks/java/exercises/poker/.meta/src/reference/java/Poker.java
+- tracks/java/exercises/poker/.meta/version.txt
 - tracks/java/exercises/poker/README.md
 - tracks/java/exercises/poker/build.gradle
 - tracks/java/exercises/poker/src/main/java/.keep