Add annalyns-infiltration concept exercise

Author: dector

concepts/booleans/about.md

@@ -0,0 +1,18 @@
+Booleans in Kotlin are represented by the `Boolean` type, which values can be either `true` or `false`.
+
+Kotlin supports three built-in [boolean operators][reference]: `!` (negation aka NOT), `&&` (lazy conjunction aka AND), and `||` (lazy disjunction aka OR). The `&&` and `||` operators use _short-circuit evaluation_, which means that the right-hand side of the operator is only evaluated when needed.
+
+```kotlin
+true || false // => true
+true && false // => false
+```
+
+The three boolean operators each have a different [_operator precedence_][precedence]. As a consequence, they are evaluated in this order: `!` first, `&&` second, and finally `||`. If you want to 'escape' these rules, you can enclose a boolean expression in parentheses (`()`), as the parentheses have an even higher operator precedence.
+
+```kotlin
+!true && false   // => false
+!(true && false) // => true
+```
+
+[reference]: https://kotlinlang.org/docs/reference/basic-types.html#booleans
+[precedence]: https://kotlinlang.org/docs/reference/grammar.html#expressions

concepts/booleans/links.json

@@ -0,0 +1,10 @@
+[
+  {
+    "url": "https://kotlinlang.org/docs/reference/basic-types.html#booleans",
+    "description": "reference"
+  },
+  {
+    "url": "https://kotlinlang.org/docs/reference/grammar.html#expressions",
+    "description": "precedence"
+  }
+]

exercises/concept/annalyns-infiltration/.docs/hints.md

@@ -0,0 +1,10 @@
+## General
+
+- There are three [boolean operators][reference] to work with boolean values.
+- Multiple operators can be combined in a single expression.
+
+## 1. Check if a fast attack can be made
+
+- The [boolean operators][reference] can also be applied to boolean parameters.
+
+[reference]: https://kotlinlang.org/docs/reference/basic-types.html#booleans

exercises/concept/annalyns-infiltration/.docs/instructions.md

@@ -0,0 +1,64 @@
+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 signalled 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: if the prisoner is awake and the other two characters are sleeping, a sneaky entry into the camp can free the prisoner. This won't work if the prisoner is sleeping, as the prisoner will be startled by the sudden appearance of her friend and the knight and archer will be awoken. The prisoner can also be freed if the archer is sleeping and Annalyn has her pet dog with her, as the knight will be scared by the dog and will withdraw, and the archer can't equip his bow fast enough to prevent the prisoner from being freed.
+
+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.
+
+## Tasks
+
+## 1. Check if a fast attack can be made
+
+Implement the `canFastAttack()` method that takes a boolean value that indicates if the knight is awake. This method returns `true` if a fast attack can be made based on the state of the knight. Otherwise, returns `false`:
+
+```kotlin
+val knightIsAwake = true
+
+canFastAttack(knightIsAwake)
+// => false
+```
+
+## 2. Check if the group can be spied upon
+
+Implement the `canSpy()` method that takes three boolean values, indicating if the knight, archer and the prisoner, respectively, are awake. The method returns `true` if the group can be spied upon, based on the state of the three characters. Otherwise, returns `false`:
+
+```kotlin
+val knightIsAwake = false
+val archerIsAwake = true
+val prisonerIsAwake = false
+
+canSpy(knightIsAwake, archerIsAwake, prisonerIsAwake)
+// => true
+```
+
+## 3. Check if the prisoner can be signalled
+
+Implement the `canSignalPrisoner()` method that takes two boolean values, indicating if the archer and the prisoner, respectively, are awake. The method returns `true` if the prisoner can be signalled, based on the state of the two characters. Otherwise, returns `false`:
+
+```kotlin
+val archerIsAwake = false
+val prisonerIsAwake = true
+
+canSignalPrisoner(archerIsAwake, prisonerIsAwake)
+// => true
+```
+
+## 4. Check if the prisoner can be freed
+
+Implement the `canFreePrisoner()` method 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 method 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`:
+
+```kotlin
+val knightIsAwake = false
+val archerIsAwake = true
+val prisonerIsAwake = false
+val petDogIsPresent = false
+
+canFreePrisoner(knightIsAwake, archerIsAwake, prisonerIsAwake, petDogIsPresent)
+// => false
+```

exercises/concept/annalyns-infiltration/.docs/introduction.md

@@ -0,0 +1,5 @@
+## booleans
+
+Booleans in Kotlin are represented by the `Boolean` type, which values can be either `true` or `false`.
+
+Kotlin supports three built-in [boolean operators][reference]: `!` (negation aka NOT), `&&` (lazy conjunction aka AND), and `||` (lazy disjunction aka OR). The `&&` and `||` operators use _short-circuit evaluation_, which means that the right-hand side of the operator is only evaluated when needed.

exercises/concept/annalyns-infiltration/.meta/config.json

@@ -0,0 +1,9 @@
+{
+  "authors": [
+    {
+      "github_username": "dector",
+      "exercism_username": "dector"
+    }
+  ],
+  "forked_from": ["fsharp/booleans"]
+}

exercises/concept/annalyns-infiltration/.meta/design.md

@@ -0,0 +1,19 @@
+## Learning objectives
+
+- Know of the existence of the `Boolean` type and its two values.
+- Know about boolean operators and how to build logical expressions with them.
+- Know of the boolean operator precedence rules.
+
+## Out of scope
+
+- Pattern matching on booleans.
+
+## Concepts
+
+- `booleans`: know of the existence of the `Boolean` type and its two values; know about boolean operators and how to build logical expressions with them; know of the boolean operator precedence rules.
+
+## Prerequisites
+
+This exercise's prerequisites Concepts are:
+
+- `basics`: know how to define methods.

exercises/concept/annalyns-infiltration/.meta/src/main/kotlin/Example.kt

@@ -0,0 +1,23 @@
+fun canFastAttack(knightIsAwake: Boolean): Boolean =
+    !knightIsAwake
+
+fun canSpy(
+    knightIsAwake: Boolean,
+    archerIsAwake: Boolean,
+    prisonerIsAwake: Boolean
+): Boolean =
+    knightIsAwake || archerIsAwake || prisonerIsAwake
+
+fun canSignalPrisoner(archerIsAwake: Boolean, prisonerIsAwake: Boolean): Boolean =
+    !archerIsAwake && prisonerIsAwake
+
+fun canFreePrisoner(
+    knightIsAwake: Boolean,
+    archerIsAwake: Boolean,
+    prisonerIsAwake: Boolean,
+    petDogIsPresent: Boolean
+): Boolean =
+    !knightIsAwake &&
+        !archerIsAwake &&
+        prisonerIsAwake || !archerIsAwake &&
+        petDogIsPresent

exercises/concept/annalyns-infiltration/build.gradle.kts

@@ -0,0 +1,21 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
+plugins {
+    kotlin("jvm") version "1.4.10"
+}
+
+repositories {
+    jcenter()
+}
+
+dependencies {
+    testImplementation("org.junit.jupiter:junit-jupiter:5.5.2")
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+        events("passed", "failed", "skipped")
+    }
+}