trackler 2.2.1.116 → 2.2.1.117

data/tracks/go/exercises/yacht/example.go

@@ -0,0 +1,74 @@
+//Package yacht is a sample solution to the yacht exercise for go
+package yacht
+
+import (
+	"sort"
+)
+
+//scoreN calculates the score of the lower categories
+//It returns the total of those dice that equal n
+func scoreN(dice []int, n int) int {
+	score := 0
+	for _, d := range dice {
+		if d == n {
+			score += n
+		}
+	}
+	return score
+}
+
+//scoreAll adds up and returns the total of the five dice
+func scoreAll(dice []int) int {
+	return dice[0] + dice[1] + dice[2] + dice[3] + dice[4]
+}
+
+var diceValueMap = map[string]int{
+	"ones": 1, "twos": 2, "threes": 3, "fours": 4, "fives": 5, "sixes": 6,
+}
+
+//Score returns the total score of a hand of Yacht dice in a given category.
+func Score(dice []int, category string) int {
+	sort.Ints(dice)
+	switch category {
+	case "ones", "twos", "threes", "fours", "fives", "sixes":
+		return scoreN(dice, diceValueMap[category])
+	case "full house":
+		//Note, a yacht scores zero as a full house
+		if dice[0] == dice[1] && dice[2] == dice[3] && dice[3] == dice[4] && dice[1] != dice[2] {
+			return scoreAll(dice)
+		}
+		if dice[0] == dice[1] && dice[1] == dice[2] && dice[3] == dice[4] && dice[2] != dice[3] {
+			return scoreAll(dice)
+		}
+		return 0
+	case "four of a kind":
+		//Note, a yacht can score as four of a kind, but only 4 dice are counted
+		if dice[0] == dice[1] && dice[1] == dice[2] && dice[2] == dice[3] {
+			return dice[0] * 4
+		}
+		if dice[1] == dice[2] && dice[2] == dice[3] && dice[3] == dice[4] {
+			return dice[1] * 4
+		}
+		return 0
+	case "little straight":
+		if dice[0] == 1 && dice[1] == 2 && dice[2] == 3 && dice[3] == 4 && dice[4] == 5 {
+			return 30
+		}
+		return 0
+	case "big straight":
+		if dice[0] == 2 && dice[1] == 3 && dice[2] == 4 && dice[3] == 5 && dice[4] == 6 {
+			return 30
+		}
+		return 0
+	case "choice":
+		return scoreAll(dice)
+	case "yacht":
+		if dice[0] == dice[1] && dice[1] == dice[2] && dice[2] == dice[3] && dice[3] == dice[4] {
+			return 50
+		}
+		return 0
+	default:
+		//This can't happen, so panic is appropriate
+		panic("Unknown category")
+	}
+}

data/tracks/go/exercises/yacht/yacht_test.go

@@ -0,0 +1,25 @@
+package yacht
+
+import (
+	"testing"
+)
+
+func TestScore(t *testing.T) {
+	for _, testCase := range testCases {
+		score := Score(testCase.dice, testCase.category)
+		if testCase.expected != score {
+			t.Fatalf("FAIL: %s\nScore %v as %s. expected %d, got %d",
+				testCase.description, testCase.dice, testCase.category,
+				testCase.expected, score)
+		}
+		t.Logf("PASS: %s", testCase.description)
+	}
+}
+
+func BenchmarkScore(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, testCase := range testCases {
+			Score(testCase.dice, testCase.category)
+		}
+	}
+}

data/tracks/haskell/config.json

@@ -791,6 +791,16 @@
         "Either"
       ]
     },
+    {
+      "uuid": "35bf659b-b139-4d09-bdae-326319160a27",
+      "slug": "poker",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 7,
+      "topics": [
+        "Maybe"
+      ]
+    },
     {
       "uuid": "2c009c74-fbf2-49f7-b626-0d9da10c18ea",
       "slug": "connect",

data/tracks/haskell/exercises/go-counting/README.md

@@ -11,6 +11,8 @@ Write a function that determines the territory of each player. You may
 assume that any stones that have been stranded in enemy territory have
 already been taken off the board.
 
+Write a function that determines the territory which includes a specified coordinate.
+
 Multiple empty intersections may be encircled at once and for encircling
 only horizontal and vertical neighbours count. In the following diagram
 the stones which matter are marked "O" and the stones that don't are

data/tracks/haskell/exercises/go-counting/package.yaml

@@ -1,5 +1,5 @@
 name: go-counting
-version: 0.1.0.2
+version: 1.0.0.3
 
 dependencies:
   - base

data/tracks/haskell/exercises/go-counting/test/Tests.hs

@@ -19,16 +19,6 @@ specs = do
                    , " W W "
                    , "  W  " ]
 
-        board9x9 = [ "  B   B  "
-                   , "B   B   B"
-                   , "WBBBWBBBW"
-                   , "W W W W W"
-                   , "         "
-                   , " W W W W "
-                   , "B B   B B"
-                   , " W BBB W "
-                   , "   B B   " ]
-
         shouldHaveTerritories = shouldMatchList
                               . map (first toAscList)
                               . territories
@@ -54,20 +44,24 @@ specs = do
                                          , ([ (4, 1)
                                             , (4, 2) ], Just White) ]
 
+    it "two territories of same player, rectangular board" $
+      [ " B " ] `shouldHaveTerritories` [ ([ (1, 1) ], Just Black)
+                                        , ([ (3, 1) ], Just Black) ]
+
     it "5x5 score" $
       board5x5 `shouldScore` [ (Nothing   , 9)
                              , (Just Black, 6)
                              , (Just White, 1) ]
 
-    it "5x5 territory for black" $
+    it "5x5 territory for black bordering edge" $
       territoryIn board5x5 (1, 2) `shouldBe` Just ([ (1, 1)
                                                    , (1, 2)
                                                    , (2, 1) ], Just Black)
 
-    it "5x5 territory for white" $
+    it "5x5 territory for white not bordering edge" $
       territoryIn board5x5 (3, 4) `shouldBe` Just ([ (3, 4) ], Just White)
 
-    it "5x5 open territory" $
+    it "5x5 open territory bordering edge" $
       territoryIn board5x5 (2, 5) `shouldBe` Just ([ (1, 4)
                                                    , (1, 5)
                                                    , (2, 5) ], Nothing)
@@ -75,12 +69,14 @@ specs = do
     it "5x5 non-territory (stone)" $
       territoryIn board5x5 (2, 2) `shouldBe` Nothing
 
-    it "5x5 non-territory (too low coordinate)" $
+    it "5x5 non-territory (X too low)" $
       territoryIn board5x5 (0, 2) `shouldBe` Nothing
 
-    it "5x5 non-territory (too high coordinate)" $
-      territoryIn board5x5 (2, 6) `shouldBe` Nothing
+    it "5x5 non-territory (X too high)" $
+      territoryIn board5x5 (6, 2) `shouldBe` Nothing
 
-    it "9x9 score" $
-      board9x9 `shouldScore` [ (Nothing   , 33)
-                             , (Just Black, 14) ]
+    it "5x5 non-territory (Y too low)" $
+      territoryIn board5x5 (2, 0) `shouldBe` Nothing
+
+    it "5x5 non-territory (Y too high)" $
+      territoryIn board5x5 (2, 6) `shouldBe` Nothing

data/tracks/haskell/exercises/poker/README.md

@@ -0,0 +1,66 @@
+# Poker
+
+Pick the best hand(s) from a list of poker hands.
+
+See [wikipedia](https://en.wikipedia.org/wiki/List_of_poker_hands) for an
+overview of poker hands.
+
+
+## Getting Started
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/haskell).
+
+## Running the tests
+
+To run the test suite, execute the following command:
+
+```bash
+stack test
+```
+
+#### If you get an error message like this...
+
+```
+No .cabal file found in directory
+```
+
+You are probably running an old stack version and need
+to upgrade it.
+
+#### Otherwise, if you get an error message like this...
+
+```
+No compiler found, expected minor version match with...
+Try running "stack setup" to install the correct GHC...
+```
+
+Just do as it says and it will download and install
+the correct compiler version:
+
+```bash
+stack setup
+```
+
+## Running *GHCi*
+
+If you want to play with your solution in GHCi, just run the command:
+
+```bash
+stack ghci
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/haskell](https://github.com/exercism/haskell) repository on
+GitHub is the home for all of the Haskell exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue.  We'll do our best to help you!
+
+## Source
+
+Inspired by the training course from Udacity. [https://www.udacity.com/course/viewer#!/c-cs212/](https://www.udacity.com/course/viewer#!/c-cs212/)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/haskell/exercises/poker/examples/success-standard/package.yaml

@@ -0,0 +1,16 @@
+name: poker
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Poker
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - poker
+      - hspec

data/tracks/haskell/exercises/poker/examples/success-standard/src/Poker.hs

@@ -0,0 +1,49 @@
+module Poker (bestHands) where
+
+import Data.Maybe (fromJust)
+import Data.List  (nub, elemIndex, sortBy)
+
+validHand :: [String] -> Bool
+validHand h = and [ length h == 5
+                  , all (`elem` "A23456789TJQK") (head <$> h)
+                  , all (`elem` "HSDC") (last <$> h)
+                  , all ((==2) . length) h]
+
+parseHand :: String -> [String]
+parseHand = map f . words
+  where
+    f ('1':'0':xs) = 'T' : xs
+    f xs           = xs
+
+rankHand :: [String] -> (Int, [Int])
+rankHand h | counts == [5]       = (9, ranks')
+           | straight && flush   = (8, ranks')
+           | counts == [4,1]     = (7, ranks')
+           | counts == [3,2]     = (6, ranks')
+           | flush               = (5, ranks')
+           | straight            = (4, ranks')
+           | counts == [3,1,1]   = (3, ranks')
+           | counts == [2,2,1]   = (2, ranks')
+           | counts == [2,1,1,1] = (1, ranks')
+           | otherwise           = (0, ranks')
+  where
+    r        = fromJust . flip elemIndex "..23456789TJQKA" . head <$> h
+    groups   = let x = nub r in sortBy (flip compare) (zip (times r <$> x) x)
+    counts   = fst <$> groups
+    ranks    = snd <$> groups
+    ranks'   = if ranks == [14,5,4,3,2] then [5,4,3,2,1] else ranks
+    straight = length counts == 5 && (maximum ranks' - minimum ranks') == 4
+    flush    = length (nub (last <$> h)) == 1
+    times xs x = length $ filter (==x) xs
+
+bestHands :: [String] -> Maybe [String]
+bestHands hands | not (all validHand hands') = Nothing
+                | otherwise                  = Just $ f (0,[]) [] (zip hands hands')
+  where
+    hands'  = parseHand <$> hands
+    f _ r []                              = r
+    f m r ((x,y):xs) | null r || rank > m = f rank [x] xs
+                     | rank == m          = f m (x : r) xs
+                     | otherwise          = f m r xs
+      where
+        rank = rankHand y

data/tracks/haskell/exercises/poker/package.yaml

@@ -0,0 +1,20 @@
+name: poker
+version: 1.1.0.1
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Poker
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - poker
+      - hspec

data/tracks/haskell/exercises/poker/src/Poker.hs

@@ -0,0 +1,4 @@
+module Poker (bestHands) where
+
+bestHands :: [String] -> Maybe [String]
+bestHands = error "You need to implement this function!"

data/tracks/haskell/exercises/poker/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-10.2

data/tracks/haskell/exercises/poker/test/Tests.hs

@@ -0,0 +1,174 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Data.List         (sort)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import Poker (bestHands)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "bestHands" $ for_ cases test
+  where
+
+    test Case{..} = it description assertion
+      where
+        assertion = (sort <$> bestHands input) `shouldBe` (sort <$> expected)
+
+data Case = Case { description :: String
+                 , input       :: [String]
+                 , expected    :: Maybe [String]
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "single hand always wins"
+               , input       = ["4S 5S 7H 8D JC"]
+               , expected    = Just ["4S 5S 7H 8D JC"]
+               }
+        , Case { description = "highest card out of all hands win"
+               , input       = [ "4D 5S 6S 8D 3C"
+                               , "2S 4C 7S 9H 10H"
+                               , "3S 4S 5D 6H JH"]
+               , expected    = Just ["3S 4S 5D 6H JH"]
+               }
+        , Case { description = "a tie has multiple winners"
+               , input       = [ "4D 5S 6S 8D 3C"
+                               , "2S 4C 7S 9H 10H"
+                               , "3S 4S 5D 6H JH"
+                               , "3H 4H 5C 6C JD"]
+               , expected    = Just [ "3S 4S 5D 6H JH"
+                                    , "3H 4H 5C 6C JD"]
+               }
+        , Case { description =  "multiple hands with the same high cards, tie compares next highest ranked, down to last card"
+               , input       = [ "3S 5H 6S 8D 7H"
+                               , "2S 5D 6D 8C 7S"]
+               , expected    = Just ["3S 5H 6S 8D 7H"]
+               }
+        , Case { description = "one pair beats high card"
+               , input       = [ "4S 5H 6C 8D KH"
+                               , "2S 4H 6S 4D JH"]
+               , expected    = Just ["2S 4H 6S 4D JH"]
+               }
+        , Case { description = "highest pair wins"
+               , input       = [ "4S 2H 6S 2D JH"
+                               , "2S 4H 6C 4D JD"]
+               , expected    = Just ["2S 4H 6C 4D JD"]
+               }
+        , Case { description = "two pairs beats one pair"
+               , input       = [ "2S 8H 6S 8D JH"
+                               , "4S 5H 4C 8C 5C"]
+               , expected    = Just ["4S 5H 4C 8C 5C"]
+               }
+        , Case { description = "both hands have two pairs, highest ranked pair wins"
+               , input       = [ "2S 8H 2D 8D 3H"
+                               , "4S 5H 4C 8S 5D"]
+               , expected    = Just ["2S 8H 2D 8D 3H"]
+               }
+        , Case { description = "both hands have two pairs, with the same highest ranked pair, tie goes to low pair"
+               , input       = [ "2S QS 2C QD JH"
+                               , "JD QH JS 8D QC"]
+               , expected    = Just ["JD QH JS 8D QC"]
+               }
+        , Case { description = "both hands have two identically ranked pairs, tie goes to remaining card (kicker)"
+               , input       = [ "JD QH JS 8D QC"
+                               , "JS QS JC 2D QD"]
+               , expected    = Just ["JD QH JS 8D QC"]
+               }
+        , Case { description = "three of a kind beats two pair"
+               , input       = [ "2S 8H 2H 8D JH"
+                               , "4S 5H 4C 8S 4H"]
+               , expected    = Just ["4S 5H 4C 8S 4H"]
+               }
+        , Case { description = "both hands have three of a kind, tie goes to highest ranked triplet"
+               , input       = [ "2S 2H 2C 8D JH"
+                               , "4S AH AS 8C AD"]
+               , expected    = Just ["4S AH AS 8C AD"]
+               }
+        , Case { description = "with multiple decks, two players can have same three of a kind, ties go to highest remaining cards"
+               , input       = [ "4S AH AS 7C AD"
+                               , "4S AH AS 8C AD"]
+               , expected    = Just ["4S AH AS 8C AD"]
+               }
+        , Case { description = "a straight beats three of a kind"
+               , input       = [ "4S 5H 4C 8D 4H"
+                               , "3S 4D 2S 6D 5C"]
+               , expected    = Just ["3S 4D 2S 6D 5C"]
+               }
+        , Case { description = "aces can end a straight (10 J Q K A)"
+               , input       = [ "4S 5H 4C 8D 4H"
+                               , "10D JH QS KD AC"]
+               , expected    = Just ["10D JH QS KD AC"]
+               }
+        , Case { description = "aces can start a straight (A 2 3 4 5)"
+               , input       = [ "4S 5H 4C 8D 4H"
+                               , "4D AH 3S 2D 5C"]
+               , expected    = Just ["4D AH 3S 2D 5C"]
+               }
+        , Case { description = "both hands with a straight, tie goes to highest ranked card"
+               , input       = [ "4S 6C 7S 8D 5H"
+                               , "5S 7H 8S 9D 6H"]
+               , expected    = Just ["5S 7H 8S 9D 6H"]
+               }
+        , Case { description = "even though an ace is usually high, a 5-high straight is the lowest-scoring straight"
+               , input       = [ "2H 3C 4D 5D 6H"
+                               , "4S AH 3S 2D 5H"]
+               , expected    = Just ["2H 3C 4D 5D 6H"]
+               }
+        , Case { description = "flush beats a straight"
+               , input       =  [ "4C 6H 7D 8D 5H"
+                                , "2S 4S 5S 6S 7S"]
+               , expected    = Just ["2S 4S 5S 6S 7S"]
+               }
+        , Case { description = "both hands have a flush, tie goes to high card, down to the last one if necessary"
+               , input       = [ "4H 7H 8H 9H 6H"
+                               , "2S 4S 5S 6S 7S"]
+               , expected    = Just ["4H 7H 8H 9H 6H"]
+               }
+        , Case { description = "full house beats a flush"
+               , input       =  [ "3H 6H 7H 8H 5H"
+                                , "4S 5H 4C 5D 4H"]
+               , expected    = Just ["4S 5H 4C 5D 4H"]
+               }
+        , Case { description = "both hands have a full house, tie goes to highest-ranked triplet"
+               , input       = [ "4H 4S 4D 9S 9D"
+                               , "5H 5S 5D 8S 8D"]
+               , expected    = Just ["5H 5S 5D 8S 8D"]
+               }
+        , Case { description = "with multiple decks, both hands have a full house with the same triplet, tie goes to the pair"
+               , input       = [ "5H 5S 5D 9S 9D"
+                               , "5H 5S 5D 8S 8D"]
+               , expected    = Just ["5H 5S 5D 9S 9D"]
+               }
+        , Case { description = "four of a kind beats a full house"
+               , input       =  [ "4S 5H 4D 5D 4H"
+                                , "3S 3H 2S 3D 3C"]
+               , expected    = Just ["3S 3H 2S 3D 3C"]
+               }
+        , Case { description = "both hands have four of a kind, tie goes to high quad"
+               , input       = [ "2S 2H 2C 8D 2D"
+                               , "4S 5H 5S 5D 5C"]
+               , expected    = Just ["4S 5H 5S 5D 5C"]
+               }
+        , Case { description = "with multiple decks, both hands with identical four of a kind, tie determined by kicker"
+               , input       = [ "3S 3H 2S 3D 3C"
+                               , "3S 3H 4S 3D 3C"]
+               , expected    = Just ["3S 3H 4S 3D 3C"]
+               }
+        , Case { description = "straight flush beats four of a kind"
+               , input       = [ "4S 5H 5S 5D 5C"
+                               , "7S 8S 9S 6S 10S"]
+               , expected    = Just ["7S 8S 9S 6S 10S"]
+               }
+        , Case { description = "both hands have straight flush, tie goes to highest-ranked card"
+               , input       = [ "4H 6H 7H 8H 5H"
+                               , "5S 7S 8S 9S 6S"]
+               , expected    = Just ["5S 7S 8S 9S 6S"]
+               }
+        , Case { description = "no winner if a hand is invalid"
+               , input       = [ "2H 2S 2D 2C 10XXXXXXH" ]
+               , expected    = Nothing
+               }
+        ]