Start go/blackjack

go/blackjack/HELP.md

@@ -0,0 +1,41 @@
+# Help
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `--bench` and `--benchmem`
+flags:
+
+    go test -v --bench . --benchmem
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Submitting your solution
+
+You can submit your solution using the `exercism submit blackjack.go` command.
+This command will upload your solution to the Exercism website and print the solution page's URL.
+
+It's possible to submit an incomplete solution which allows you to:
+
+- See how others have completed the exercise
+- Request help from a mentor
+
+## Need to get help?
+
+If you'd like help solving the exercise, check the following pages:
+
+- The [Go track's documentation](https://exercism.org/docs/tracks/go)
+- The [Go track's programming category on the forum](https://forum.exercism.org/c/programming/go)
+- [Exercism's programming category on the forum](https://forum.exercism.org/c/programming/5)
+- The [Frequently Asked Questions](https://exercism.org/docs/using/faqs)
+
+Should those resources not suffice, you could submit your (incomplete) solution to request mentoring.
+
+To get help if you're having trouble, you can use one of the following resources:
+
+- [How to Write Go Code](https://golang.org/doc/code.html)
+- [Effective Go](https://golang.org/doc/effective_go.html)
+- [Go Resources](http://golang.org/help)
+- [StackOverflow](http://stackoverflow.com/questions/tagged/go)

go/blackjack/HINTS.md

@@ -0,0 +1,23 @@
+# Hints
+
+## 1. Calculate the value of any given card.
+
+- The `ParseCard` function should take the `card` string (e.g. `ace`) and return its value (e.g. 11).
+- Use a big [`switch` statement][switch_statement] on the `card` variable.
+- King, Queen, Jack and 10 can be handled with a single case.
+- The switch can have a `default` case. In any case the function should return `0` for unknown cards.
+
+## 2. Implement the decision logic for the first turn.
+
+- Use function `ParseCard` to determined the value for each card.
+- Compute the player score by adding up the values of the two player cards
+- You can either use a big [`switch` statement][switch_statement] on the player
+  score (maybe with nested `if`-statements on the dealer-score in some cases),
+- or you could distinguish separate player score categories (say "small hands"
+  with a score less than 12, "medium hands" with a score in the range 12..20 and
+  "large hands" with a score greater than 20) and write separate functions for
+  all (or some) of these categories.
+
+[logical_operators]: https://golang.org/ref/spec#Logical_operators
+[if_statement]: https://golang.org/ref/spec#If_statements
+[switch_statement]: https://golang.org/ref/spec#Switch_statements

go/blackjack/README.md

@@ -0,0 +1,110 @@
+# Blackjack
+
+Welcome to Blackjack on Exercism's Go Track.
+If you need help running the tests or submitting your code, check out `HELP.md`.
+If you get stuck on the exercise, check out `HINTS.md`, but try and solve it without using those first :)
+
+## Introduction
+
+Like other languages, Go also provides a `switch` statement. Switch statements are a shorter way to write long `if ... else if` statements. To make a switch, we start by using the keyword `switch` followed by a value or expression. We then declare each one of the conditions with the `case` keyword. We can also declare a `default` case, that will run when none of the previous `case` conditions matched:
+
+```go
+operatingSystem := "windows"
+
+switch operatingSystem {
+case "windows":
+    // do something if the operating system is windows
+case "linux":
+    // do something if the operating system is linux
+case "macos":
+    // do something if the operating system is macos
+default:
+    // do something if the operating system is none of the above
+} 
+```
+
+One interesting thing about switch statements, is that the value after the `switch` keyword can be omitted, and we can have boolean conditions for each `case`:
+
+```go
+age := 21
+
+switch {
+case age > 20 && age < 30:
+    // do something if age is between 20 and 30
+case age == 10:
+    // do something if age is equal to 10
+default:
+    // do something else for every other case
+}
+```
+
+## Instructions
+
+In this exercise we will simulate the first turn of a [Blackjack](https://en.wikipedia.org/wiki/Blackjack) game.
+
+You will receive two cards and will be able to see the face up card of the dealer. All cards are represented using a string such as "ace", "king", "three", "two", etc. The values of each card are:
+
+| card  | value | card    | value |
+| :---: | :---: | :-----: | :---: |
+|  ace  |  11   | eight   |   8   |
+|  two  |   2   | nine    |   9   |
+| three |   3   |  ten    |  10   |
+| four  |   4   | jack    |  10   |
+| five  |   5   | queen   |  10   |
+|  six  |   6   | king    |  10   |
+| seven |   7   | *other* |   0   |
+
+**Note**: Commonly, aces can take the value of 1 or 11 but for simplicity we will assume that they can only take the value of 11.
+
+Depending on your two cards and the card of the dealer, there is a strategy for the first turn of the game, in which you have the following options:
+
+- Stand (S)
+- Hit (H)
+- Split (P)
+- Automatically win (W)
+
+Although not optimal yet, you will follow the strategy your friend Alex has been developing, which is as follows:
+
+- If you have a pair of aces you must always split them.
+- If you have a Blackjack (two cards that sum up to a value of 21), and the dealer does not have an ace, a figure or a ten then you automatically win. If the dealer does have any of those cards then you'll have to stand and wait for the reveal of the other card.
+- If your cards sum up to a value within the range [17, 20] you should always stand.
+- If your cards sum up to a value within the range [12, 16] you should always stand unless the dealer has a 7 or higher, in which case you should always hit.
+- If your cards sum up to 11 or lower you should always hit.
+
+## 1. Calculate the value of any given card.
+
+Implement a function to calculate the numerical value of a card:
+
+```go
+value := ParseCard("ace")
+fmt.Println(value)
+// Output: 11
+```
+
+## 2. Implement the decision logic for the first turn.
+
+Write a function that implements the decision logic as described above:
+
+```go
+func FirstTurn(card1, card2, dealerCard string) string
+```
+
+Here are some examples for the expected outcomes:
+
+```go
+FirstTurn("ace", "ace", "jack") == "P"
+FirstTurn("ace", "king", "ace") == "S"
+FirstTurn("five", "queen", "ace") == "H"
+```
+
+## Source
+
+### Created by
+
+- @andres-zartab
+
+### Contributed to by
+
+- @tehsphinx
+- @andrerfcsantos
+- @norbs57

go/blackjack/blackjack.go

@@ -0,0 +1,12 @@
+package blackjack
+
+// ParseCard returns the integer value of a card following blackjack ruleset.
+func ParseCard(card string) int {
+	panic("Please implement the ParseCard function")
+}
+
+// FirstTurn returns the decision for the first turn, given two cards of the
+// player and one card of the dealer.
+func FirstTurn(card1, card2, dealerCard string) string {
+	panic("Please implement the FirstTurn function")
+}