add exercism exercises

Author: callaghan

.gitignore

@@ -1,3 +1,3 @@
-# .gitignore
+.gitignore
 *.json
 .idea

go/annalyns-infiltration/HELP.md

@@ -0,0 +1,40 @@
+# 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 annalyns_infiltration.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)
+- [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/annalyns-infiltration/HINTS.md

@@ -0,0 +1,23 @@
+# Hints
+
+## General
+
+- There are three [boolean operators][logical operators] to work with boolean values.
+- Multiple operators can be combined in a single expression.
+
+## 1. Check if a fast attack can be made
+
+- The logical NOT operator (`!`) can be placed before an expression to negate its value.
+
+## 2. Check if the group can be spied upon
+
+- Logical operators are typically used to evaluate whether two or more expressions are true or not true.
+
+## 3. Check if the prisoner can be signaled
+
+- Logical operators execute in the order of their precedence (from highest to lowest): `!`, `&&`, `||`.
+- For more details check out the Operator Precedence section on the [official golang documentation][operators] and the [truth table][truth table].
+
+[logical operators]: https://golang.org/ref/spec#Logical_operators
+[operators]: https://golang.org/ref/spec#Operators
+[truth table]: https://www.digitalocean.com/community/tutorials/understanding-boolean-logic-in-go

go/annalyns-infiltration/README.md

@@ -0,0 +1,96 @@
+# Annalyn's Infiltration
+
+Welcome to Annalyn's Infiltration 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
+
+Booleans in Go are represented by the predeclared boolean type `bool`, which values can be either `true` or `false`.
+It's a defined type.
+
+```go
+var closed bool    // boolean variable 'closed' implicitly initialized with 'false'
+speeding := true   // boolean variable 'speeding' initialized with 'true'
+hasError := false  // boolean variable 'hasError' initialized with 'false' 
+```
+
+Go supports three logical operators that can evaluate expressions down to Boolean values, returning either `true` or `false`.
+
+| Operator    | What it means                                 |
+| ----------- | --------------------------------------------- |
+| `&&` (and)  | It is true if both statements are true.       |
+| `\|\|` (or) | It is true if at least one statement is true. |
+| `!` (not)   | It is true only if the statement is false.    |
+
+## Instructions
+
+In this exercise, you'll be implementing the quest logic for a new RPG game a friend is developing. The game's main character is Annalyn, a brave girl with a fierce and loyal pet dog. Unfortunately, disaster strikes, as her best friend was kidnapped while searching for berries in the forest. Annalyn will try to find and free her best friend, optionally taking her dog with her on this quest.
+
+After some time spent following her best friend's trail, she finds the camp in which her best friend is imprisoned. It turns out there are two kidnappers: a mighty knight and a cunning archer.
+
+Having found the kidnappers, Annalyn considers which of the following actions she can engage in:
+
+- _Fast attack_: a fast attack can be made if the knight is sleeping, as it takes time for him to get his armor on, so he will be vulnerable.
+- _Spy_: the group can be spied upon if at least one of them is awake. Otherwise, spying is a waste of time.
+- _Signal prisoner_: the prisoner can be signaled using bird sounds if the prisoner is awake and the archer is sleeping, as archers are trained in bird signaling so they could intercept the message.
+- _Free prisoner_: Annalyn can try sneaking into the camp to free the prisoner.
+  This is a risky thing to do and can only succeed in one of two ways:
+  - If Annalyn has her pet dog with her she can rescue the prisoner if the archer is asleep.
+    The knight is scared of the dog and the archer will not have time to get ready before Annalyn and the prisoner can escape.
+  - If Annalyn does not have her dog then she and the prisoner must be very sneaky!
+    Annalyn can free the prisoner if the prisoner is awake and the knight and archer are both sleeping, but if the prisoner is sleeping they can't be rescued: the prisoner would be startled by Annalyn's sudden appearance and wake up the knight and archer.
+
+You have four tasks: to implement the logic for determining if the above actions are available based on the state of the three characters found in the forest and whether Annalyn's pet dog is present or not.
+
+## 1. Check if a fast attack can be made
+
+Define the `CanFastAttack()` function that takes a boolean value that indicates if the knight is awake. This function returns `true` if a fast attack can be made based on the state of the knight. Otherwise, returns `false`:
+
+```go
+var knightIsAwake = true
+fmt.Println(CanFastAttack(knightIsAwake))
+// Output: false
+```
+
+## 2. Check if the group can be spied upon
+
+Define the `CanSpy()` function that takes three boolean values, indicating if the knight, archer and the prisoner, respectively, are awake. The function returns `true` if the group can be spied upon, based on the state of the three characters. Otherwise, returns `false`:
+
+```go
+var knightIsAwake = false
+var archerIsAwake = true
+var prisonerIsAwake = false
+fmt.Println(CanSpy(knightIsAwake, archerIsAwake, prisonerIsAwake))
+// Output: true
+```
+
+## 3. Check if the prisoner can be signaled
+
+Define the `CanSignalPrisoner()` function that takes two boolean values, indicating if the archer and the prisoner, respectively, are awake. The function returns `true` if the prisoner can be signaled, based on the state of the two characters. Otherwise, returns `false`:
+
+```go
+var archerIsAwake = false
+var prisonerIsAwake = true
+fmt.Println(CanSignalPrisoner(archerIsAwake, prisonerIsAwake))
+// Output: true
+```
+
+## 4. Check if the prisoner can be freed
+
+Define the `CanFreePrisoner()` function that takes four boolean values. The first three parameters indicate if the knight, archer and the prisoner, respectively, are awake. The last parameter indicates if Annalyn's pet dog is present. The function returns `true` if the prisoner can be freed based on the state of the three characters and Annalyn's pet dog presence. Otherwise, it returns `false`:
+
+```go
+var knightIsAwake = false
+var archerIsAwake = true
+var prisonerIsAwake = false
+var petDogIsPresent = false
+fmt.Println(CanFreePrisoner(knightIsAwake, archerIsAwake, prisonerIsAwake, petDogIsPresent))
+// Output: false
+```
+
+## Source
+
+### Created by
+
+- @oanaOM

go/annalyns-infiltration/annalyns_infiltration.go

@@ -0,0 +1,22 @@
+package annalyn
+
+// CanFastAttack can be executed only when the knight is sleeping.
+func CanFastAttack(knightIsAwake bool) bool {
+	panic("Please implement the CanFastAttack() function")
+}
+
+// CanSpy can be executed if at least one of the characters is awake.
+func CanSpy(knightIsAwake, archerIsAwake, prisonerIsAwake bool) bool {
+	panic("Please implement the CanSpy() function")
+}
+
+// CanSignalPrisoner can be executed if the prisoner is awake and the archer is sleeping.
+func CanSignalPrisoner(archerIsAwake, prisonerIsAwake bool) bool {
+	panic("Please implement the CanSignalPrisoner() function")
+}
+
+// CanFreePrisoner can be executed if the prisoner is awake and the other 2 characters are asleep
+// or if Annalyn's pet dog is with her and the archer is sleeping.
+func CanFreePrisoner(knightIsAwake, archerIsAwake, prisonerIsAwake, petDogIsPresent bool) bool {
+	panic("Please implement the CanFreePrisoner() function")
+}