In this lesson, you’ve learned about the various types of collections that exist in Kotlin. In this project, you’ll be honing your knowledge of lists, sets, and maps as well as all previously covered Kotlin concepts, by building a program that keeps track of a caregiver's daily responsibilities at an animal sanctuary. 



First and foremost, let's gather our responsibilities for the day and organize them in a list. 

Declare a variable, `responsibilities`, which stores a list with the following tasks: 

- `"feed the chimps"`
- `"play a random game"`
- `"conduct a health check on Foxie"`

We don't expect to change our responsibilities, so feel free to store this data in an immutable list. Also, make sure to organize your list in the same order as above. 

Next, we'll declare 3 variables to keep track of our time and how many responsibilities we've completed. 

First, declare a variable, `responsibilitiesComplete`, and assign it the value, `0`. 

Additionally, declare a variable, `timeSpent`, and also assign it the value of `0`. 

As we go through our program and check off tasks, we'll add to these values. 

Finally, declare a variable, `totalShiftTime`, which represents the hour length of our daily shift. Set this value to `4`. This value will not change throughout the program. 
 

Finally, we're going to need to create the following two map collections: 

- `foxiesHealthCheck` should be defined as an empty mutable map with `String` keys and `Any?` values. Specifying `Any?` will allow us to store a value of any type. We will add data on Foxie's well being to this map later in the project. 

- `chimpsHaveEaten` should be defined as a mutable map populated with the following values: 

 - `"Bonnie" to false`
 - `"Jubilee" to false`
 - `"Frodo" to false`
 - `"Foxie" to false`

We've clocked in and we're ready to tackle the first responsibility on our list! 

Add a `println()` statement specifying what tasks needs to be accomplished. Within the print statement, write code to output the first responsibility:

``` 
First, responsibilities[index].
```




Now it's time to feed the chimps one by one. We'll start with Bonnie. Construct another print statement that relays this information: 

```
Feeding Bonnie....
``` 

Following this print statement, write code to update the `"Bonnie"` key in the map to hold the value `true` now that she's been fed. 

Repeat this process for each chimp in the map. 

Before we move on to the next responsibility, we must track the time that it took and how many responsibilities we've completed thus far. 

We spent an hour feeding all the chimps. Add `1` to `timeSpent`. 

We've completed a single responsibility; also add `1` to `responsibilitiesComplete`. 

Lastly, create a `println()` statement that outputs the following text: 

```
All chimps have now been fed! You've completed [responsibilitiesComplete] / [total responsibilities]) responsibilities.
```

Replace `[total responsibilities]` with a property appended to `responsibilities` that returns the number of items in the list. 

Now, let's move on to the second responsibility on the list. 

Add a print statement specifying what task needs to be accomplished now. Within the print statement, write code to output the second responsibility:

```
Next, responsibilities[index].
```


Next, the chimps will get to play a random game that's fun and stimulates their thinking.

First, declare a set, `games`, containing the following values: 

- `"tug-of-war with a blanket"`
- `"catch and throw"`
- `"number game"`

On the following line, use a function on `games` to return a random game from the set. Store this code in a variable, `randomGame`.   

Lastly, add a print statement to output the value of `randomGame` to see which game the chimps will play. 

While the chimps finish their game, let's write code to wrap up this task by updating the time spent and the responsibilities we've completed thus far. 

We've spent an hour preparing the game and playing with the chimps. Add `1` to `timeSpent`. 

Since we've completed another responsibility, also add `1` to `responsibilitiesComplete`. 

Lastly, create a print statement that outputs the following text: 

```
Each chimp has now played a game of [randomGame]! You've completed [responsibilitiesComplete] / [total responsibilities] responsibilities.
```

Now, let's move on to the third and final item on our to-do list. 

Add a print statement specifying what task needs to be accomplished now. Within the print statement, write code to output the third responsibility:

``` 
Next, responsibilities[index].
```

To do a health check on Foxie, we need to measure her temperature and assess her mood. As we complete each task, we'll update the `foxiesHealthCheck` map with information on how she's feeling today. Let's get started. 

Grabbing the thermometer and applying it under her arm, we see that Foxie's temperature is `32.7`. Let's write code that adds a `"temperature"` key with a value of `32.7` to the map. 

Next, assessing Foxie's mood, we conclude that she's in a "happy" state. Let's write code that adds a `"mood"` key with a value of `"happy"` to the map. 

Finally, let's add a print statement to relay our findings: 

``` 
Foxie has a temperature of [temperature] and is feeling [mood].
```  

Now that we've completed the final task, let's update the time spent and the responsibilities we've completed. 

We've spent an hour completing the health assessment. Add `1` to `timeSpent`. 

Similarly, add `1` to `responsibilitiesComplete`. 

Lastly, create a print statement that outputs the following text: 

```
You've now completed [responsibilitiesComplete] / [total responsibilities] responsibilities.
```

Finally, we'll add some logic to or program to check if we've completed all of our responsibilities on time.

Set up an `if`-`else` expression with an `else-if` condition that accomplishes the following: 

- Check if the `timeSpent` was less than or equal to `totalShiftTime` and if all of the responsibilities were complete. 
 - If so, output text that congratulates the caregiver on a great job of completing the responsibilities on time. 

- Check if the `timeSpent` was greater than or equal to `totalShiftTime` and if all of the responsibilities were complete.
 - If so, output text that states that all responsibilities were complete but with overtime. 

- In all other cases, output text that says all of the responsibilities were not complete and took extra time. 

Excellent work! 👏 You've completed the project and built a useful program for tracking the responsibilities of a caregiver. 

Run your program several times to ensure it's working as expected. You may see that the text is all jumbled together. Use your knowledge of escape sequences to format some of the print statements to your liking.  

Finally, test your code with different values for `timeSpent` and see the different outcomes for the random games. 

If you’re up for a challenge, check out these additional tasks:

- A chimp's average body temperature is `32.7` degrees Celsius. Anything higher than that should be notified to the vet. Add this logic to the program. 

- Optimize parts of your program as you see fit. For example, how can we improve upon and avoid the repetitive use of `responsibilities.size`? 

- Add an additional responsibility to the list and adjust the project as needed. 

Sample solution: 

- [**Sanctuary.kt**](https://github.com/Codecademy/learn-kotlin/blob/master/4-collections/Sanctuary.kt)

If you make something cool, share it with us!

Animal Sanctuary

ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)
