Repository: exercism/python
Pull request #2500 (2021-08-29 17:41:24)

Lists & List-Methods (Card Games & Chiatanas Colossal Coaster) Typos and Revisions
Went through the docs for  the `lists` & `list-methods` concepts and the corresponding `Card Games` & `Chiatanas Colossal Coaster` concept exercises, editing for the following:

- [x] Spelling
- [x] Language
- [x] Readability & concept coverage
- [x] Accurate code examples, syntax, and PEP-8

Also added more formal docstrings to the stub files for each exercise. 


Patch:
diff --git a/concepts/list-methods/about.md b/concepts/list-methods/about.md
index 7d8545f1..0f4e2922 100644
--- a/concepts/list-methods/about.md
+++ b/concepts/list-methods/about.md
@@ -1,16 +1,18 @@
 # About
 
-A [`list`][list] is a mutable collection of items in _sequence_. Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold references to any (or multiple) data type(s) - including other lists.
-They're considered a [sequence][sequence type] in Python, and can be copied in whole or in part via [slice notation][slice notation].
+A [`list`][list] is a mutable collection of items in _sequence_.
+ Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold references to any (or multiple) data type(s) - including other lists.
+ They're considered a [sequence][sequence type] in Python, and can be copied in whole or in part via [slice notation][slice notation].
 Like any sequence, elements within `lists` can be referenced by `0-based index` number from the left, or `-1-based index` number from the right.
 
-Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence opterations like `min(<list>)`/`max(<list>)`, `<list>.index()`, `<list>.append()` and `<list>.reverse()`.
-Items can be iterated over using the `for item in <list>` construct, and `for index, item in enumerate(<list>)` can be used when both the element and element index are needed.
+Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations such as `min(<list>)`/`max(<list>)`, `<list>.index()`, `<list>.append()` and `<list>.reverse()`.
+ Items can be iterated over using the `for item in <list>` construct, and `for index, item in enumerate(<list>)` when both the element and element index are needed.
 
 Python provides many useful [methods][list-methods] for working with lists.
 
-Because `lists` are mutable, list-methods **alter the original list object** passed into the method.
-If mutation is undesirable, the original `list` needs to at least be copied via `shallow copy` via `slice` or `<list>.copy()`.
+ Because lists are mutable, list-methods **alter the original list object** passed into the method.
+If mutation is undesirable, a `shallow copy` (_at minimum__) of the original `list` needs to be made via `slice` or `<list>.copy()`.
+
 
 ## Adding Items
 
@@ -19,6 +21,7 @@ Adding items to the end of an existing list can be done via `<list>.append(<item
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.append(9)
+
 >>> numbers
 [1, 2, 3, 9]
 ```
@@ -33,10 +36,12 @@ If `<index>` is greater than the final index on the list, the item will be added
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.insert(0, -2)
+
 >>> numbers
 [-2, 1, 2, 3]
 
 >>> numbers.insert(1, 0)
+
 >>> numbers
 [-2, 0, 1, 2, 3]
 ```
@@ -44,29 +49,33 @@ If `<index>` is greater than the final index on the list, the item will be added
 An `iterable` can be _combined_ with an existing list (concatenating the two) via `<list>.extend(<iterable>)`.
 `<list>.extend(<iterable>)` will _unpack_ the supplied iterable, adding its elements in the same order to the end of the target list (_using `<list>.append(<item>)` in this circumstance would add the entire iterable as a **single item**._).
 
+
 ```python
 >>> numbers = [1, 2, 3]
 >>> other_numbers = [5, 6, 7]
 
 >>> numbers.extend(other_numbers)
+
 >>> numbers
 [1, 2, 3, 5, 6, 7]
 
 >>> numbers.extend([8, 9])
+
 >>> numbers
 [1, 2, 3, 5, 6, 7, 8, 9]
 ```
 
-<br>
 
 ## Removing Items
 
 `<list>.remove(<item>)` can be used to remove an element from the list.
-`<list>.remove(<item>)` will throw a `ValueError` if the element is not present in the list.
+ `<list>.remove(<item>)` will throw a `ValueError` if the element is not present in the list.
+
 
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.remove(2)
+
 >>> numbers
 [1, 3]
 
@@ -81,10 +90,12 @@ Alternatively, using `<list>.pop(<item>)` method will both remove **and** `retur
 If the optional `<index>` argument is not specified, the last element of the list will be removed and returned.
 If `<index>` is a higher number than the final index of the list, an `IndexError` will be thrown.
 
+
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.pop(0)
 1
+
 >>> numbers
 [2, 3]
 >>> numbers.pop()
@@ -102,128 +113,148 @@ IndexError: pop index out of range
 
 All items can be removed from a `list` via `<list>.clear()`. It does not take any parameters.
 
+
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.clear()
+
 >>> numbers
 []
 ```
 
-<br>
 
 ## Reversing and reordering
 
 The order of list elements can be reversed  _**in place**_ with `<list>.reverse()`. This will mutate the original list.
 
+
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.reverse()
+
 >>> numbers
 [3, 2, 1]
 ```
 
 List elements can be sorted _**in place**_ using `<list>.sort()`.
-Internally, Python uses [`Timsort`][timsort] to arrange the elements.
-The default order is _ascending_.
-The Python docs have [additional tips and techniques for sorting][sorting how to] `lists` effectively.
+ Internally, Python uses [`Timsort`][timsort] to arrange the elements.
+ The default order is _ascending_.
+ The Python docs have [additional tips and techniques for sorting][sorting how to] `lists` effectively.
+
 
 ```python
 >>> names = ["Tony", "Natasha", "Thor", "Bruce"]
 
 # The default sort order is *ascending*.
 >>> names.sort()
+
 >>> names
 ["Bruce", "Natasha", "Thor", "Tony"]
 ```
 
 To sort a list in _descending_ order, pass a `reverse=True` argument to the method:
 
+
 ```python
 >>> names = ["Tony", "Natasha", "Thor", "Bruce"]
 >>> names.sort(reverse=True)
+
 >>> names
 ["Tony", "Thor", "Natasha", "Bruce"]
 ```
 
+
 For cases where mutating the original `list` is undesirable, the built-in functions [`sorted()`][sorted] and [`reversed()`][reversed] can be used.
-`sorted(<list>)` will return a sorted _copy_, and takes the same parameters as `<list>.sort()`.
-`reversed(<list>)` returns an _iterator_ that yields the list's items in reverse order.
-`Iterators` will be covered in detail in another exercise.
+ `sorted(<list>)` will return a sorted _copy_, and takes the same parameters as `<list>.sort()`.
+ `reversed(<list>)` returns an _iterator_ that yields the list's items in reverse order.
+ `Iterators` will be covered in detail in another exercise.
 
-<br>
 
 ## Occurrences of an item in a list
 
 Finding the number of occurrences of an element in a list can be done with the help of `<list>.count(<item>)`.
-It returns the total number of times `<item>` appears as an element in the list.
+ It returns the total number of times `<item>` appears as an element in the list.
+
 
 ```python
 >>> items = [1, 4, 7, 8, 2, 9, 2, 1, 1, 0, 4, 3]
+
 >>> items.count(1)
 3
 ```
 
-<br>
 
 ## Finding the index of items
 
 `<list>.index(<item>)` will return the index number of the _first occurrence_ of an item passed in.
-If there are no occurrences, a `ValueError` is raised.
-Indexing is 0-based from the left, meaning the position of the first item is index `0`.
+ If there are no occurrences, a `ValueError` is raised.
+ Indexing is `0-based` from the left, meaning the position of the first item is index `0`.
+ Indexing from the right is also supported, starting with index `-1`.
+
 
 ```python
 >>> items = [7, 4, 1, 0, 2, 5]
 >>> items.index(4)
 1
+
 >>> items.index(10)
 ValueError: 10 is not in list
 ```
 
 Providing `start` and `end` indices will search within a specific section of the list:
 
+
 ```python
 >>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
 >>> names.index("Tina")
 0
+
 >>> names.index("Tina", 2, 5)
 3
 ```
 
 If the exact position of an element is not needed, the built-in `in` operator is more efficient for verifying membership.
 
+
 ```python
 >>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
+
 >>> "Thomas" in names
 True
 ```
 
-<br>
 
 ## Making Copies
 
-Remember that variables in Python are labels that point to underlying objects and `lists` are _container_ objects that only hold references to their contained items.
+Remember that variables in Python are names that point to underlying objects.
+ Names can be bound or re-bound to different objects over the life of a program.
+ Assigning a `list` object to a new variable _**name**_ does not copy the object or any of its referenced data.
+ The new name and old name will both point at the same `list` object.
+ Additionally, lists are a _container_ type object - to save space, containers only hold _references_ to member items, not the items themselves.
+ This "optimization" can have unintended consequences for the unwary.
 
-Assigning a `list` object to a new variable _name_ does not copy the object or any of its referenced data. Any change made to the items in the `list` using the new variable name will also _impact the original_.
-
-`<list>.copy()` will create a new `list` object, but **will not** create new objects for the referenced list _elements_. This is called a `shallow copy`.
-A `shallow copy` is usually enough when you want to add or remove items from one of the `list` objects without modifying the other.
-But if there is any chance that the _underlying_ elements of a `list` might be accidentally mutated (_thereby mutating all related shallow copies_), [`copy.deepcopy()`][deepcopy] in the `copy` module should be used to create a complete or "deep" copy of **all** references and objects.
+`<list>.copy()` will create a new `list` object, but **will not** create new objects for the referenced list _elements_ -- the copy is "shallow".
+ A `shallow copy` is usually enough when you want to add or remove items from one of the `list` objects without modifying the other.
+ But if there is any chance that the _underlying elements_ of a `list` might be accidentally mutated (_thereby mutating all related shallow copies_), [`copy.deepcopy()`][deepcopy] in the `copy` module should be used to create a complete or "deep" copy of **all** references and objects.
 
 For a detailed explanation of names, values, list, and nested list behavior, take a look at this excellent blog post from [Ned Batchelder][ned batchelder] -- [Names and values: making a game board][names and values].
+ [Shallow vs Deep Copying of Python Objects][shallow vs deep] also offers a good rundown of copy considerations.
+
 
-[list-methods]: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
-[timsort]: https://en.wikipedia.org/wiki/Timsort
-[sorted]: https://docs.python.org/3/library/functions.html#sorted
-[reversed]: https://docs.python.org/3/library/functions.html#reversed
-[sorting how to]: https://docs.python.org/3/howto/sorting.html
-[list]: https://docs.python.org/3/library/stdtypes.html#list
-[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
-[set]: https://docs.python.org/3/library/stdtypes.html#set
-[dict]: https://docs.python.org/3/library/stdtypes.html#dict
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
-[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
-[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
 [deepcopy]: https://docs.python.org/3/library/copy.html
+[dict]: https://docs.python.org/3/library/stdtypes.html#dict
+[list-methods]: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
+[list]: https://docs.python.org/3/library/stdtypes.html#list
 [mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
 [names and values]: https://nedbatchelder.com/blog/201308/names_and_values_making_a_game_board.html
 [ned batchelder]: https://nedbatchelder.com/
+[reversed]: https://docs.python.org/3/library/functions.html#reversed
+[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+[set]: https://docs.python.org/3/library/stdtypes.html#set
+[shallow vs deep]: https://realpython.com/copying-python-objects/
+[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
+[sorted]: https://docs.python.org/3/library/functions.html#sorted
+[sorting how to]: https://docs.python.org/3/howto/sorting.html
+[timsort]: https://en.wikipedia.org/wiki/Timsort
+[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
diff --git a/concepts/list-methods/introduction.md b/concepts/list-methods/introduction.md
index 958a3103..e7054394 100644
--- a/concepts/list-methods/introduction.md
+++ b/concepts/list-methods/introduction.md
@@ -1,15 +1,15 @@
 # Introduction
 
 A [list][list] is a mutable collection of items in _sequence_.
-Lists can hold reference to any (or multiple) data type(s) - including other lists or data structures such as [tuples][tuples], [sets][sets], or [dicts][dicts].
-Content can be iterated over using `for item in <list>` construct.
-If indexes are needed with the content, `for index, item in enumerate(<list>)` can be used.
-Elements within a `list` can be accessed via `0-based index` number from the left, or `-1-based index` number from the right.
-Lists can be copied in whole or in part using  _slice notation_ or `<list>.copy()`.
-Python provides many useful and convenient [methods][list-methods] for working with lists.
+ Lists can hold reference to any (or multiple) data type(s) - including other lists or data structures such as [tuples][tuples], [sets][sets], or [dicts][dicts].
+ Content can be iterated over using `for item in <list>` construct.
+ If indexes are needed with the content, `for index, item in enumerate(<list>)` can be used.
+ Elements within a `list` can be accessed via `0-based index` number from the left, or `-1-based index` number from the right.
+ Lists can be copied in whole or in part using  _slice notation_ or `<list>.copy()`.
+ Python provides many useful and convenient [methods][list-methods] for working with lists.
 
-[tuples]: https://github.com/exercism/python/tree/main/concepts/tuples
 [dicts]: https://github.com/exercism/python/tree/main/concepts/dicts
-[sets]: https://github.com/exercism/python/tree/main/concepts/sets
-[list]: https://docs.python.org/3/library/stdtypes.html#list
 [list-methods]: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
+[list]: https://docs.python.org/3/library/stdtypes.html#list
+[sets]: https://github.com/exercism/python/tree/main/concepts/sets
+[tuples]: https://github.com/exercism/python/tree/main/concepts/tuples
diff --git a/concepts/lists/.meta/config.json b/concepts/lists/.meta/config.json
index 22725f41..afe555a6 100644
--- a/concepts/lists/.meta/config.json
+++ b/concepts/lists/.meta/config.json
@@ -1,5 +1,5 @@
 {
-  "blurb": "A list is a mutable collection of items in a sequence. Like most collections, lists can hold any/multiple data type(s) -- including other lists. Lists support all common sequence operations as well as mutable sequence operations like \".append()\" and \".reverse()\". They can be iterated over using the \"for item in <list>\" syntax.",
+  "blurb": "A \"list\" is a mutable collection of items in sequence. Like most collections, lists can hold any/multiple data type(s) - including other lists. They support all common sequence operations as well as mutable sequence operations, and can be iterated over using the \"for item in <list>\" or \"for index, item in enumerate(<list>)\" syntax.",
   "authors": ["BethanyG"],
   "contributors": []
 }
diff --git a/concepts/lists/about.md b/concepts/lists/about.md
index 085d1f73..41dec62e 100644
--- a/concepts/lists/about.md
+++ b/concepts/lists/about.md
@@ -1,42 +1,52 @@
 # About
 
 A [`list`][list] is a mutable collection of items in _sequence_.
-Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold reference to any (or multiple) data type(s) - including other lists.
-Like any [sequence][sequence type], items can be accessed via `0-based index` number from the left and `-1-base index` from the right.
-Lists can be copied in whole or in part via [slice notation][slice notation] or `<list>.copy()`
+ Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold reference to any (or multiple) data type(s) - including other lists.
+ Like any [sequence][sequence type], items can be accessed via `0-based index` number from the left and `-1-based index` from the right.
+ Lists can be copied in whole or in part via [slice notation][slice notation] or `<list>.copy()`.
+
 
 Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations such as `min()`/`max()`, `<list>.index()`, `.append()` and `.reverse()`.
-List elements can be iterated over using the `for item in <list>` construct. `for index, item in enumerate(<list)` can be used when both the element index and the element value are needed.
+ List elements can be iterated over using the `for item in <list>` construct. `for index, item in enumerate(<list)` can be used when both the element index and the element value are needed.
+
 
 Lists are implemented as [dynamic arrays][dynamic array] -- similar to Java's [`Arraylist`][arraylist] type, and are most often used to store groups of similar data (_strings, numbers, sets etc._) of unknown length (_the number of entries may arbitrarily expand or shrink_).
 
+
 Accessing elements, checking for membership via `in`, or appending items to the "right-hand" side of a list are all very efficient.
-Prepending (_appending to the "left-hand" side_) or inserting into the middle of a list are much _less_ efficient because those operations require shifting elements to keep them in sequence.
-For a similar data structure that supports memory efficient `appends`/`pops` from both sides, see [`collections.deque`][deque], which has approximately the same O(1) performance in either direction.
+ Prepending (_appending to the "left-hand" side_) or inserting into the middle of a list are much _less_ efficient because those operations require shifting elements to keep them in sequence.
+ For a similar data structure that supports memory efficient `appends`/`pops` from both sides, see [`collections.deque`][deque], which has approximately the same O(1) performance in either direction.
+
 
 Because lists are mutable and can contain references to arbitrary objects, they also take up more space in memory than a fixed-size [`array.array`][array.array] type of the same apparent length.
-Despite this, lists are an extremely flexible and useful data structure and many built-in methods and operations in Python produce lists as their output.
+ Despite this, lists are an extremely flexible and useful data structure and many built-in methods and operations in Python produce lists as their output.
+
 
 ## Construction
 
 A `list` can be declared as a _literal_ with square `[]` brackets and commas between elements:
 
+
 ```python
 >>> no_elements = []
+
 >>> no_elements
 []
 
 >>> one_element = ["Guava"]
+
 >>> one_element
 ['Guava']
 
 >>> elements_separated_with_commas = ["Parrot", "Bird", 334782]
+
 >>> elements_separated_with_commas
 ['Parrot', 'Bird', 334782]
 ```
 
 For readability, line breaks can be used when there are many elements or nested data structures within a list:
 
+
 ```python
 >>> lots_of_entries = [
       "Rose",
@@ -48,6 +58,7 @@ For readability, line breaks can be used when there are many elements or nested
       "Cyclamen",
       "Lavender"
    ]
+
 >>> lots_of_entries
 ['Rose', 'Sunflower', 'Poppy', 'Pansy', 'Tulip', 'Fuchsia', 'Cyclamen', 'Lavender']
 
@@ -58,11 +69,14 @@ For readability, line breaks can be used when there are many elements or nested
       ("fish", "mammal", "bird"),
       ['water', 'jungle', 'sky']
    ]
+
 >>> nested_data_structures
 [{'fish': 'gold', 'monkey': 'brown', 'parrot': 'grey'}, ('fish', 'mammal', 'bird'), ['water', 'jungle', 'sky']]
 ```
 
-The `list()` constructor can be used empty or with an _iterable_ as an argument. Elements in the iterable are cycled through by the constructor and added to the list in order:
+The `list()` constructor can be used empty or with an _iterable_ as an argument.
+ Elements in the iterable are cycled through by the constructor and added to the list in order:
+
 
 ```python
 >>> no_elements = list()
@@ -71,11 +85,13 @@ The `list()` constructor can be used empty or with an _iterable_ as an argument.
 
 # The tuple is unpacked and each element is added.
 >>> multiple_elements_from_tuple = list(("Parrot", "Bird", 334782))
+
 >>> multiple_elements_from_tuple
 ['Parrot', 'Bird', 334782]
 
 # The set is unpacked and each element is added.
 >>> multiple_elements_from_set = list({2, 3, 5, 7, 11})
+
 >>> multiple_elements_from_set
 [2, 3, 5, 7, 11]
 ```
@@ -85,11 +101,13 @@ Results when using a list constructor with a string or a dict may be surprising:
 ```python
 # String elements (Unicode code points) are iterated through and added *individually*.
 >>> multiple_elements_string = list("Timbuktu")
+
 >>> multiple_elements_string
 ['T', 'i', 'm', 'b', 'u', 'k', 't', 'u']
 
 # Unicode separators and positioning code points are also added *individually*.
 >>> multiple_code_points_string = list('अभ्यास')
+
 >>> multiple_code_points_string
 ['अ', 'भ', '्', 'य', 'ा', 'स']
 
@@ -110,6 +128,7 @@ TypeError: 'int' object is not iterable
 
 # Tuples *are* iterable, so passing a one-element tuple to the constructor does work, but it's awkward
 >>> one_element_from_iterable = list((16,))
+
 >>> one_element_from_iterable
 [16]
 ```
@@ -163,12 +182,14 @@ A `step` parameter can also be used in the slice (`[start:stop:step]`) to "skip
 
 # If there is no step parameter, the step is assumed to be 1.
 >>> middle_colors = colors[2:6]
+
 >>> middle_colors
 ['Green', 'Yellow', 'Orange', 'Pink']
 
 # If the start or stop parameters are omitted, the slice will
 # start at index zero, and will stop at the end of the list.
 >>> primary_colors = colors[::3]
+
 >>> primary_colors
 ['Red', 'Yellow', 'Blue']
 ```
@@ -190,7 +211,7 @@ Grey
 Blue
 
 
-# Print the same list, but with the indexes of the colors inculded
+# Print the same list, but with the indexes of the colors included
 >>> colors = ["Orange", "Green", "Grey", "Blue"]
 >>> for index, item in enumerate(colors):
 ...     print(item, ":", index)
@@ -218,7 +239,7 @@ One common way to compose a list of values is to use `<list>.append()` within a
 >>> cubes_to_1000 = []
 >>> for number in range(11):
 ...    cubes_to_1000.append(number**3)
-...
+
 >>> cubes_to_1000
 [0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
 ```
@@ -228,12 +249,14 @@ Lists can also be combined via various techniques:
 ```python
 # Using the plus + operator unpacks each list and creates a new list, but it is not efficient.
 >>> new_via_concatenate = ["George", 5] + ["cat", "Tabby"]
+
 >>> new_via_concatenate
 ['George', 5, 'cat', 'Tabby']
 
 # Likewise, using the multiplication operator * is the equivalent of using + n times.
 >>> first_group = ["cat", "dog", "elephant"]
 >>> multiplied_group = first_group * 3
+
 >>> multiplied_group
 ['cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant']
 
@@ -242,36 +265,42 @@ Lists can also be combined via various techniques:
 >>> first_one = ["cat", "Tabby"]
 >>> second_one = ["George", 5]
 >>> first_one[0:0] = second_one
+
 >>> first_one
 ['George', 5, 'cat', 'Tabby']
 
 # This loops through the first list and appends it's items to the end of the second list.
 >>> first_one = ["cat", "Tabby"]
 >>> second_one = ["George", 5]
+
 >>> for item in first_one:
->>>      second_one.append(item)
-...
+...      second_one.append(item)
+
 >>> second_one
 ['George', 5, 'cat', 'Tabby']
 ```
 
+
 ## Some cautions
 
 Recall that variables in Python are _labels_ that point to _underlying objects_.
 `lists` add one more layer as  _container objects_ -- they hold object references for their collected items.
 This can lead to multiple potential issues when working with lists, if not handled properly.
 
+
 ### Assigning more than one variable name
 Assigning a `list` object to a new variable _name_ **does not copy the `list` object nor its elements**.
 Any change made to the elements in the `list` under the _new_ name _impact the original_.
 
+
 Making a `shallow_copy` via `list.copy()` or slice will avoid this first-leve referencing complication.
 A `shallow_copy` will create a new `list` object, but **will not** create new objects for the contained list _elements_. This type of copy will usually be enough for you to add or remove items from the two `list` objects independently, and effectively have two "separate" lists.
 
+
 ```python
 >>> actual_names = ["Tony", "Natasha", "Thor", "Bruce"]
 
-# Assinging a new variable name does not make a copy of the container or its data.
+# Assigning a new variable name does not make a copy of the container or its data.
 >>> same_list = actual_names
 
 #  Altering the list via the new name is the same as altering the list via the old name.
@@ -281,12 +310,12 @@ A `shallow_copy` will create a new `list` object, but **will not** create new ob
 >>> actual_names
 ["Tony", "Natasha", "Thor", "Bruce", "Clarke"]
 
-#  Likewise, altering the data in the list via the original nane will also alter the data under the new name.
+#  Likewise, altering the data in the list via the original name will also alter the data under the new name.
 >>> actual_names[0] = "Wanda"
 >>> same_list
 ['Wanda', 'Natasha', 'Thor', 'Bruce', 'Clarke']
 
-# If you copy the list, there will be two seperate list objects which can be changed independantly.
+# If you copy the list, there will be two separate list objects which can be changed independently.
 >>> copied_list = actual_names.copy()
 >>> copied_list[0] = "Tony"
 >>> actual_names
@@ -407,23 +436,23 @@ The [collections][collections] module offers a [deque][deque] variant optimized
 Nested lists are also used to model small _matrices_ -- although the [Numpy][numpy] and [Pandas][pandas] libraries are much more robust for efficient matrix and tabular data manipulation.
 The collections module also provides a `UserList` type that can be customized to fit specialized list needs.
 
-[list]: https://docs.python.org/3/library/stdtypes.html#list
-[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
-[dict]: https://docs.python.org/3/library/stdtypes.html#dict
-[set]: https://docs.python.org/3/library/stdtypes.html#set
-[string]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[iterator]: https://docs.python.org/3/glossary.html#term-iterator
-[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
-[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
-[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
-[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
-[dynamic array]: https://en.wikipedia.org/wiki/Dynamic_array
+[array.array]: https://docs.python.org/3/library/array.html
 [arraylist]: https://beginnersbook.com/2013/12/java-arraylist/
-[doubly linked list]: https://en.wikipedia.org/wiki/Doubly_linked_list
 [collections]: https://docs.python.org/3/library/collections.html
+[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
 [deque]: https://docs.python.org/3/library/collections.html#collections.deque
-[numpy]: https://numpy.org/
-[pandas]: https://pandas.pydata.org/
+[dict]: https://docs.python.org/3/library/stdtypes.html#dict
+[doubly linked list]: https://en.wikipedia.org/wiki/Doubly_linked_list
+[dynamic array]: https://en.wikipedia.org/wiki/Dynamic_array
+[iterator]: https://docs.python.org/3/glossary.html#term-iterator
+[list]: https://docs.python.org/3/library/stdtypes.html#list
+[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
 [names and values]: https://nedbatchelder.com/blog/201308/names_and_values_making_a_game_board.html
 [ned batchelder]: https://nedbatchelder.com/
-[array.array]: https://docs.python.org/3/library/array.html
\ No newline at end of file
+[numpy]: https://numpy.org/
+[pandas]: https://pandas.pydata.org/
+[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+[set]: https://docs.python.org/3/library/stdtypes.html#set
+[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
+[string]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
\ No newline at end of file
diff --git a/concepts/lists/introduction.md b/concepts/lists/introduction.md
index f1f1ac0e..bd68b9a9 100644
--- a/concepts/lists/introduction.md
+++ b/concepts/lists/introduction.md
@@ -1,14 +1,14 @@
 # Introduction
 
 A [list][list] is a mutable collection of items in _sequence_.
-They're an extremely flexible and useful data structure that many built-in methods and operations in Python produce as output.
-Lists can hold reference to any (or multiple) data type(s) - including other lists or data structures such as [tuples][tuples], [sets][sets], or [dicts][dicts].
-Content can be iterated over using `for item in <list>` construct.
-If indexes are needed with the content, `for index, item in enumerate(<list>)` can be used.
-Elements within a `list` can be accessed via `0-based index` number from the left, or `-1-based index` number from the right.
-Lists can be copied in whole or in part using  _slice notation_ or `<list>.copy()`.
+ They are an extremely flexible and useful data structure that many `built-in` methods and operations in Python produce as output.
+ Lists can hold reference to any (or multiple) data type(s) - including other lists or data structures such as [tuples][tuples], [sets][sets], or [dicts][dicts].
+ Content can be iterated over using `for item in <list>` construct.
+ If indexes are needed with the content, `for index, item in enumerate(<list>)` can be used.
+ Elements within a `list` can be accessed via `0-based index` number from the left, or `-1-based index` number from the right.
+ Lists can be copied in whole or in part using  _slice notation_ or `<list>.copy()`.
 
-[tuples]: https://github.com/exercism/python/tree/main/concepts/tuples
 [dicts]: https://github.com/exercism/python/tree/main/concepts/dicts
-[sets]: https://github.com/exercism/python/tree/main/concepts/sets
 [list]: https://docs.python.org/3/library/stdtypes.html#list
+[sets]: https://github.com/exercism/python/tree/main/concepts/sets
+[tuples]: https://github.com/exercism/python/tree/main/concepts/tuples
diff --git a/exercises/concept/card-games/.docs/hints.md b/exercises/concept/card-games/.docs/hints.md
index 0920ce9a..e923673b 100644
--- a/exercises/concept/card-games/.docs/hints.md
+++ b/exercises/concept/card-games/.docs/hints.md
@@ -4,40 +4,46 @@
 
 ## 1. Tracking Poker Rounds
 
-- `Lists` in python may be [constructed](https://docs.python.org/3/library/stdtypes.html#list) in several ways.
-- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list`.
+- Lists in Python may be [constructed][constructed] in several ways.
+- This function should [return][return] a `list`.
 
 ## 2. Keeping all Rounds in the Same Place
 
-- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
-- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list`.
+- Sequence types such as `list` already support [common operations][common sequence operations].
+- This function should [return][return] a `list`.
 
 ## 3. Finding Prior Rounds
 
-- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
-- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `boolean`.
+- Sequence types such as `list` already support a few [common operations][common sequence operations].
+- This function should [return][return] a `bool`.
 
 ## 4. Averaging Card Values
 
-- There are a few techniques to [iterate over a `list` in python](https://www.geeksforgeeks.org/iterate-over-a-list-in-python/).
-- To get the average, this function should count how many items are in the list and sum up their values. Then, return sum divided by count.
+- There are a few techniques for [iterating over a `list`][iterate over a list in python] in Python.
+- To get the average, this function should count how many items are in the `list` and sum up their values. Then, return sum/count.
 
 ## 5. Alternate Averages
 
-- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
-- To access an element use the square brackets notation.
-- Remember that the first element of the `list` is at index 0
-- In python, negative indexing starts the count from the end. This mean that you can find the last element of the `list` at index -1.
-- Think about reusing the code from the functions that you just implemented.
+- Sequence types such as `list` already support a few [common operations][common sequence operations].
+- To access an element use the square brackets (`<list>[]`) notation.
+- Remember that the first element of the `list` is at index 0 from the left.
+- In Python, negative indexing starts the count from the right-hand side. This mean that you can find the last element of a `list` at `index -1`.
+- Think about how you could reuse the code from the functions that you have already implemented.
 
 ## 6. More Averaging Techniques
 
-- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
+- Sequence types such as `list` already support a few [common operations][common sequence operations].
 - Think about reusing the code from the functions that you just implemented.
 - The slice syntax supports a step value.
 
 ## 7. Bonus Round Rules
 
-- `Lists` in python are mutable, this means that once a `list` is created, you can modify, delete or add any element as you wish.
-- Python provides a wide range of [ways to modify `lists`](https://realpython.com/python-lists-tuples/#lists-are-mutable).
-- This function should not [return](https://www.w3schools.com/python/ref_keyword_return.asp) anything so you should end it with just the statement `return`.
+- Lists are mutable. Once a `list` is created, you can modify, delete or add any type of element you wish.
+- Python provides a wide range of [ways to modify `lists`][ways to modify `lists`].
+
+
+[common sequence operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
+[constructed](https://docs.python.org/3/library/stdtypes.html#list)
+[iterate over a list in python](https://www.geeksforgeeks.org/iterate-over-a-list-in-python/)
+[return](https://www.w3schools.com/python/ref_keyword_return.asp)
+[ways to modify `lists`](https://realpython.com/python-lists-tuples/#lists-are-mutable)
diff --git a/exercises/concept/card-games/.docs/instructions.md b/exercises/concept/card-games/.docs/instructions.md
index b72721a5..edc19c68 100644
--- a/exercises/concept/card-games/.docs/instructions.md
+++ b/exercises/concept/card-games/.docs/instructions.md
@@ -2,35 +2,50 @@
 
 ## Instructions
 
-Elyse is really looking forward to playing some poker (and other card games) during her upcoming trip to Vegas. Being a big fan of "self-tracking" she wants to put together some small functions that will help her with tracking tasks and has asked for your help thinking them through.
+Elyse is really looking forward to playing some poker (and other card games) during her upcoming trip to Vegas.
+ Being a big fan of "self-tracking" she wants to put together some small functions that will help her with tracking tasks and has asked for your help thinking them through.
+
 
 ## 1. Tracking Poker Rounds
 
-Elyse is especially fond of poker, and wants to track how many rounds she plays - and _which rounds_ those are. Every round has its own number, and every table shows the round number currently being played. Elyse chooses a table and sits down to play her first round. She plans on playing three rounds.
+Elyse is especially fond of poker, and wants to track how many rounds she plays - and _which rounds_ those are.
+ Every round has its own number, and every table shows the round number currently being played.
+ Elyse chooses a table and sits down to play her first round. She plans on playing three rounds.
+
+
+Implement a function `get_rounds(<round_number>)` that takes the current round number and returns a single `list` with that round and the _next two_ that are coming up:
 
-Implement a function `get_rounds` that takes the current round number and returns a single list with that round and the _next two_ that are coming up:
 
 ```python
 >>> get_rounds(27)
 [27, 28, 29]
 ```
 
+
 ## 2. Keeping all Rounds in the Same Place
 
-Elyse played a few rounds at the first table, then took a break and played some more rounds at a second table ... but ended up with a different list for each table! She wants to put the two lists together, so she can track all of the poker rounds in the same place.
+Elyse played a few rounds at the first table, then took a break and played some more rounds at a second table ... but ended up with a different list for each table!
+ She wants to put the two lists together, so she can track all of the poker rounds in the same place.
+
+
+Implement a function `concatenate_rounds(<rounds_1>, <rounds_2>)` that takes two lists and returns a single `list` consisting of all the rounds in the first `list`, followed by all the rounds in the second `list`:
 
-Implement a function `concatenate_rounds` that takes two lists and returns a single list consisting of all the rounds in the first list, followed by all the rounds in the second list:
 
 ```python
 >>> concatenate_rounds([27, 28, 29], [35, 36])
 [27, 28, 29, 35, 36]
 ```
 
+
 ## 3. Finding Prior Rounds
 
-Talking about some of the prior Poker rounds, another player remarks how similarly two of them played out. Elyse is not sure if she played those rounds or not.
+Talking about some of the prior Poker rounds, another player remarks how similarly two of them played out.
+ Elyse is not sure if she played those rounds or not.
+
+
+Implement a function `list_contains_round(<rounds>, <round_number>)` that takes two arguments, a list of rounds played and a round number.
+ The function will return `True` if the round is in the list of rounds played, `False` if not:
 
-Implement a function `list_contains_round` that takes two arguments, a list of rounds played and a round number. The function will return `True` if the round is in the list of rounds played, `False` if not:
 
 ```python
 >>> list_contains_round([27, 28, 29, 35, 36], 29)
@@ -42,9 +57,12 @@ False
 
 ## 4. Averaging Card Values
 
-Elyse wants to try out a new game called Black Joe. It's similar to Black Jack - where your goal is to have the cards in your hand add up to a target value - but in Black Joe the goal is to get the _average_ of the card values to be 7. The average can be found by summing up all the card values and then dividing that sum by the number of cards in the hand.
+Elyse wants to try out a new game called Black Joe.
+ It's similar to Black Jack - where your goal is to have the cards in your hand add up to a target value - but in Black Joe the goal is to get the _average_ of the card values to be 7.
+ The average can be found by summing up all the card values and then dividing that sum by the number of cards in the hand.
 
-Implement a function `card_average` that will return the average value of a hand of Black Joe.
+
+Implement a function `card_average(<hand>)` that will return the average value of a hand of Black Joe.
 
 ```python
 >>> card_average([5, 6, 7])
@@ -53,9 +71,13 @@ Implement a function `card_average` that will return the average value of a hand
 
 ## 5. Alternate Averages
 
-In Black Joe, speed is important. Elyse thinks she can "shortcut" the traditional calculation to get an _average-like_ number by taking the average of the first and last card values in the hand - or by using the "middle" card value (the median) of the hand. She's hoping one of these calculations might come close to the average, but be quicker to calculate during game play. She'd like you to create a function to test her theory out.
+In Black Joe, speed is important.
+ Elyse thinks she can "shortcut" the traditional calculation to get an _average-like_ number by taking the average of the first and last card values in the hand - or by using the "middle" card value (the median) of the hand.
+  She is hoping one of these calculations might come close to the average, but be quicker to calculate during game play. She'd like you to create a function to test her theory out.
+
+
+Implement a function `approx_average_is_average(<hand>)` that returns a boolean, indicating if either of Elyse's approximation formulas is the same as calculating the "full" average of a hand. For the sake of a simple median, we are going to assume the hand always has an odd number of card values.
 
-Implement a function `approx_average_is_average` that returns a boolean, indicating if either of Elyse's approximation formulas is the same as calculating the "full" average of a hand. For the sake of a simple median, we are going to assume the hand always has an odd number of card values.
 
 ```python
 >>> approx_average_is_average([1, 2, 3])
@@ -70,9 +92,11 @@ False
 
 ## 6. More Averaging Techniques
 
-Intrigued by the results of her averaging experiment, Elyse is wondering if taking the average of _even_ values versus the average of _odd_ values would give the same results. Time for another test function!
+Intrigued by the results of her averaging experiment, Elyse is wondering if taking the average of _even_ values versus the average of _odd_ values would give the same results.
+ Time for another test function!
+
+Implement a function `average_even_is_average_odd(<hand>)` that returns a boolean indicating if the average of the even valued cards is the same as the average of the odd valued cards.
 
-Implement a function `average_even_is_average_odd` that returns a boolean indicating of the average of the even valued cards is the same as the average of the odd valued cards.
 
 ```python
 >>> average_even_is_average_odd([1, 2, 3])
@@ -82,20 +106,26 @@ True
 False
 ```
 
+
 ## 7. Bonus Round Rules
 
 Every 11th hand in Black Joe is a bonus hand with a bonus rule: if the last card you draw is a Jack, you double its value.
 
-Implement a function `maybe_double_last` that takes a hand and checks if the last card is a Jack (11). If the the last card is a Jack (11), double its value.
+
+Implement a function `maybe_double_last(<hand>)` that takes a hand and checks if the last card is a Jack (11).
+ If the the last card **is** a Jack (11), double its value before returning the hand.
+
 
 ```python
 >>> hand = [5, 9, 11]
 >>> maybe_double_last(hand)
+
 >>> hand
 [5, 9, 22]
 
 >>> hand = [5, 9, 10]
 >>> maybe_double_last(hand)
+
 >>> hand
 [5, 9, 10]
 ```
diff --git a/exercises/concept/card-games/.docs/introduction.md b/exercises/concept/card-games/.docs/introduction.md
index 6e5961fd..03801da3 100644
--- a/exercises/concept/card-games/.docs/introduction.md
+++ b/exercises/concept/card-games/.docs/introduction.md
@@ -5,32 +5,38 @@ Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [
 Like any [sequence][sequence type], items can be accessed via `0-based index` number from the left and `-1-base index` from the right.
 Lists can be copied in whole or in part via [slice notation][slice notation] or `<list>.copy()`
 
-Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations such as `min()`/`max()`, `<list>.index()`, `.append()` and `.reverse()`.
-List elements can be iterated over using the `for item in <list>` construct. `for index, item in enumerate(<list)` can be used when both the element index and the element value are needed.
+Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations such as `min()`/`max()`, `<list>.index()`, `<list>.append()` and `<list>.reverse()`.
+List elements can be iterated over using the `for item in <list>` construct.
+ `for index, item in enumerate(<list)` can be used when both the element index and the element value are needed.
 
-Under the hood, `lists` are implemented as [dynamic arrays][dynamic array] -- similar to Java's [`Arraylist`][arraylist] type.
-Lists are most often used to store groups of similar data (_strings, numbers, sets etc._) of unknown length.
+Under the hood, `lists` are implemented as [dynamic arrays][dynamic array] -- similar to Java's [`Arraylist`][arraylist] type, and are most often used to store groups of similar data (_strings, numbers, sets etc._) of unknown length.
 Lists are an extremely flexible and useful data structure and many built-in methods and operations in Python produce lists as their output.
 
+
 ## Construction
 
-A list can be declared as a _literal_ with square `[]` brackets and commas between elements:
+A `list` can be declared as a _literal_ with square `[]` brackets and commas between elements:
+
 
 ```python
 >>> no_elements = []
+
 >>> no_elements
 []
 
 >>> one_element = ["Guava"]
+
 >>> one_element
 ['Guava']
 
 >>> elements_separated_with_commas = ["Parrot", "Bird", 334782]
+
 >>> elements_separated_with_commas
 ['Parrot', 'Bird', 334782]
 ```
 
-For readability, line breaks can be used when there are many elements or nested data structures within a list:
+For readability, line breaks can be used when there are many elements or nested data structures within a `list`:
+
 
 ```python
 >>> lots_of_entries = [
@@ -43,6 +49,7 @@ For readability, line breaks can be used when there are many elements or nested
       "Cyclamen",
       "Lavender"
    ]
+   
 >>> lots_of_entries
 ['Rose', 'Sunflower', 'Poppy', 'Pansy', 'Tulip', 'Fuchsia', 'Cyclamen', 'Lavender']
 
@@ -52,48 +59,59 @@ For readability, line breaks can be used when there are many elements or nested
       ("fish", "mammal", "bird"),
       ['water', 'jungle', 'sky']
    ]
+   
 >>> nested_data_structures
 [{'fish': 'gold', 'monkey': 'brown', 'parrot': 'grey'}, ('fish', 'mammal', 'bird'), ['water', 'jungle', 'sky']]
 ```
 
-The `list()` constructor can be used empty or with an _iterable_ as an argument. Elements in the iterable are cycled through by the constructor and added to the list in order:
+The `list()` constructor can be used empty or with an _iterable_ as an argument.
+ Elements in the iterable are cycled through by the constructor and added to the `list` in order:
+
 
 ```python
 >>> no_elements = list()
+
 >>> no_elements
 []
 
 # The tuple is unpacked and each element is added.
 >>> multiple_elements_from_tuple = list(("Parrot", "Bird", 334782))
+
 >>> multiple_elements_from_tuple
 ['Parrot', 'Bird', 334782]
 
 # The set is unpacked and each element is added.
 >>> multiple_elements_from_set = list({2, 3, 5, 7, 11})
+
 >>> multiple_elements_from_set
 [2, 3, 5, 7, 11]
 ```
 
-Results when using a list constructor with a string or a dict may be surprising:
+Results when using a `list` constructor with a `string` or a `dict` may be surprising:
+
 
 ```python
 # String elements (Unicode code points) are iterated through and added *individually*.
 >>> multiple_elements_string = list("Timbuktu")
+
 >>> multiple_elements_string
 ['T', 'i', 'm', 'b', 'u', 'k', 't', 'u']
 
 # Unicode separators and positioning code points are also added *individually*.
 >>> multiple_code_points_string = list('अभ्यास')
+
 >>> multiple_code_points_string
 ['अ', 'भ', '्', 'य', 'ा', 'स']
 
 # The iteration default for dictionaries is over the keys, so only key data is inserted into the list.
 >>> source_data = {"fish": "gold", "monkey": "brown"}
+
 >>> multiple_elements_dict_1 = list(source_data)
 ['fish', 'monkey']
 ```
 
-Because the `list` constructor will only take _iterables_ (or nothing) as arguments, objects that are _not_ iterable will throw a type error. Consequently, it is much easier to create a one-item list via the literal method.
+Because the `list` constructor will only take _iterables_ (or nothing) as arguments, objects that are _not_ iterable will throw a type error.
+ Consequently, it is much easier to create a one-item `list` via the literal method.
 
 ```python
 # Numbers are not iterable, and so attempting to create a list with a number passed to the constructor fails.
@@ -104,13 +122,15 @@ TypeError: 'int' object is not iterable
 
 # Tuples *are* iterable, so passing a one-element tuple to the constructor does work, but it's awkward
 >>> one_element_from_iterable = list((16,))
+
 >>> one_element_from_iterable
 [16]
 ```
 
 ## Accessing elements
 
-Items inside lists (_as well as items in other sequence types `string` & `tuple`_) can be accessed via 0-based index and _bracket notation_. Indexes can be from **`left`** --> **`right`** (_starting at zero_) or **`right`** --> **`left`** (_starting at -1_).
+Items inside lists (_as well as items in other sequence types `str` & `tuple`_) can be accessed via `0-based index` and _bracket notation_.
+ Indexes can be from **`left`** --> **`right`** (_starting at zero_) or **`right`** --> **`left`** (_starting at -1_).
 
 
 <table>
@@ -148,21 +168,27 @@ Items inside lists (_as well as items in other sequence types `string` & `tuple`
 'Toast'
 ```
 
-A section of the elements inside a list can be accessed via _slice notation_ (`<list>[start:stop]`). A _slice_ is defined as an element sequence at position `index`, such that `start <= index < stop`. _Slicing_ returns a copy of the "sliced" items and does not modify the original `list`.
+A section of the elements inside a `list` can be accessed via _slice notation_ (`<list>[start:stop]`).
+ A _slice_ is defined as an element sequence at position `index`, such that `start <= index < stop`.
+ _Slicing_ returns a copy of the "sliced" items and does not modify the original `list`.
+
+
+A `step` parameter can also be used `[start:stop:step]` to "skip over" or filter the `list` elements (_for example, a `step` of 2 will select every other element in the range_):
 
-A `step` parameter can also be used `[start:stop:step]` to "skip over" or filter the list elements (_for example, a `step` of 2 will select every other element in the range_):
 
 ```python
 >>> colors = ["Red", "Purple", "Green", "Yellow", "Orange", "Pink", "Blue", "Grey"]
 
 # If there is no step parameter, the step is assumed to be 1.
 >>> middle_colors = colors[2:6]
+
 >>> middle_colors
 ['Green', 'Yellow', 'Orange', 'Pink']
 
 # If the start or stop parameters are omitted, the slice will
 # start at index zero, and will stop at the end of the list.
 >>> primary_colors = colors[::3]
+
 >>> primary_colors
 ['Red', 'Yellow', 'Blue']
 ```
@@ -171,9 +197,11 @@ A `step` parameter can also be used `[start:stop:step]` to "skip over" or filter
 
 Lists supply an _iterator_, and can be looped through/over in the same manner as other _sequence types_:
 
+
 ```python
 #  Looping through the list and printing out each element.
 >>> colors = ["Orange", "Green", "Grey", "Blue"]
+
 >>> for item in colors:
 ...     print(item)
 ...
@@ -184,6 +212,7 @@ Blue
 
 # Looping through the list and printing out the cube of each element.
 >>> numbers_to_cube = [5, 13, 12, 16]
+
 >>> for number in numbers_to_cube:
 ...     print(number*3)
 ...
@@ -198,18 +227,21 @@ Lists can also be combined via various techniques:
 ```python
 # Using the plus + operator unpacks each list and creates a new list, but it is not efficient.
 >>> new_via_concatenate = ["George", 5] + ["cat", "Tabby"]
+
 >>> new_via_concatenate
 ['George', 5, 'cat', 'Tabby']
 
 # Likewise, using the multiplication operator * is the equivalent of using + n times.
 >>> first_group = ["cat", "dog", "elephant"]
 >>> multiplied_group = first_group * 3
+
 >>> multiplied_group
 ['cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant']
 
 # This loops through the first list and appends it's items to the end of the second list.
 >>> first_one = ["cat", "Tabby"]
 >>> second_one = ["George", 5]
+
 >>> for item in first_one:
 >>>      second_one.append(item)
 ...
@@ -218,14 +250,13 @@ Lists can also be combined via various techniques:
 ```
 
 
-[list]: https://docs.python.org/3/library/stdtypes.html#list
-[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
-[dict]: https://docs.python.org/3/library/stdtypes.html#dict
-[set]: https://docs.python.org/3/library/stdtypes.html#set
-[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+[arraylist]: https://beginnersbook.com/2013/12/java-arraylist/
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
-[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
+[dict]: https://docs.python.org/3/library/stdtypes.html#dict
 [dynamic array]: https://en.wikipedia.org/wiki/Dynamic_array
-[arraylist]: https://beginnersbook.com/2013/12/java-arraylist/
-
+[list]: https://docs.python.org/3/library/stdtypes.html#list
+[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
+[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+[set]: https://docs.python.org/3/library/stdtypes.html#set
 [slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
+[tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
diff --git a/exercises/concept/card-games/.meta/exemplar.py b/exercises/concept/card-games/.meta/exemplar.py
index 4fefdc85..dc2fccd5 100644
--- a/exercises/concept/card-games/.meta/exemplar.py
+++ b/exercises/concept/card-games/.meta/exemplar.py
@@ -1,20 +1,42 @@
 def get_rounds(number):
-    """Return a list of rounds that includes `number` and the next two."""
+    '''
+
+     :param number: int - current round number.
+     :return: list - current round and the two that follow.
+    '''
+
     return [number, number + 1, number + 2]
 
 
-def concatenate_rounds(rounds1, rounds2):
-    """Return a list of rounds that combines `rounds1` and `rounds2`."""
-    return rounds1 + rounds2
+def concatenate_rounds(rounds_1, rounds_2):
+    '''
+
+    :param rounds_1: list - first rounds played.
+    :param rounds_2: list - second set of rounds played.
+    :return: list - all rounds played.
+    '''
+
+    return rounds_1 + rounds_2
 
 
 def list_contains_round(rounds, number):
-    """Return whether `rounds` includes the `number` round."""
+    '''
+
+    :param rounds: list - rounds played.
+    :param number: int - round number.
+    :return:  bool - was the round played?
+    '''
+
     return number in rounds
 
 
 def card_average(hand):
-    """Return the average of the hand."""
+    '''
+
+    :param hand: list - cards in hand.
+    :return:  int - average value of the cards in the hand.
+    '''
+
     total = 0
     count = 0
     for card in hand:
@@ -24,16 +46,33 @@ def card_average(hand):
 
 
 def approx_average_is_average(hand):
-    """Return whether the average of the first and last card is the average."""
+    '''
+
+    :param hand: list - cards in hand.
+    :return: int - approximate average value of the cards in the hand.
+    '''
+
     return card_average([hand[0], hand[-1]]) == card_average(hand)
 
 
 def average_even_is_average_odd(hand):
-    """Return whether the average of the even cards is the same as that odd cards."""
+    '''
+
+    :param hand: list - cards in hand.
+    :return: int - approximate average value of the cards in the hand.
+    '''
+
     return card_average(hand[::2]) == card_average(hand[1::2])
 
 
 def maybe_double_last(hand):
-    """Double the value of the last card if it is a Jack (11)."""
+    '''
+
+    :param hand: list - cards in hand.
+    :return: list - hand with Jacks (if present) value doubled.
+    '''
+
     if hand[-1] == 11:
       hand[-1] *= 2
+    return hand
+
diff --git a/exercises/concept/card-games/lists.py b/exercises/concept/card-games/lists.py
index 62acfba5..59215b14 100644
--- a/exercises/concept/card-games/lists.py
+++ b/exercises/concept/card-games/lists.py
@@ -1,33 +1,69 @@
 def get_rounds(number):
-    """Return a list of rounds that includes `number` and the next two."""
+    '''
+
+     :param number: int - current round number.
+     :return: list - current round and the two that follow.
+    '''
+
     pass
 
 
-def concatenate_rounds(rounds1, rounds2):
-    """Return a list of rounds that combines `rounds1` and `rounds2`."""
+def concatenate_rounds(rounds_1, rounds_2):
+    '''
+
+    :param rounds_1: list - first rounds played.
+    :param rounds_2: list - second set of rounds played.
+    :return: list - all rounds played.
+    '''
+
     pass
 
 
 def list_contains_round(rounds, number):
-    """Return whether `rounds` includes the `number` round."""
+    '''
+
+    :param rounds: list - rounds played.
+    :param number: int - round number.
+    :return:  bool - was the round played?
+    '''
+
     pass
 
 
 def card_average(hand):
-    """Return the average of the hand."""
+    '''
+
+    :param hand: list - cards in hand.
+    :return:  int - average value of the cards in the hand.
+    '''
+
     pass
 
 
 def approx_average_is_average(hand):
-    """Return whether the average of the first and last card is the average."""
-    pass
+    '''
 
+    :param hand: list - cards in hand.
+    :return: int - approximate average value of the cards in the hand.
+    '''
 
-def average_even_is_average_odd(hand):
-    """Return whether the average of the even cards is the same as that odd cards."""
     pass
 
+def average_even_is_average_odd(hand):
+    '''
+
+    :param hand: list - cards in hand.
+    :return: int - approximate average value of the cards in the hand.
+    '''
+
+    pass
 
 def maybe_double_last(hand):
-    """Double the value of the last card if it is a Jack (11)."""
+    '''
+
+    :param hand: list - cards in hand.
+    :return: list - hand with Jacks (if present) value doubled.
+    '''
+
     pass
+
diff --git a/exercises/concept/chaitanas-colossal-coaster/.docs/hints.md b/exercises/concept/chaitanas-colossal-coaster/.docs/hints.md
index 43ce3df4..2ed77957 100644
--- a/exercises/concept/chaitanas-colossal-coaster/.docs/hints.md
+++ b/exercises/concept/chaitanas-colossal-coaster/.docs/hints.md
@@ -1,33 +1,35 @@
 # General
 
-Make sure you have a good understanding of how to create and manipulate lists.
+Make sure you have a good understanding of how to create and update lists.
 
 ## 1. Add Me to the queue
 
 - You need to find the ticket type with an `if-else` statement.
-- You can `append` the person to the queue based on the ticket type.
+- You can `append()` the person to the queue based on the ticket type.
 
 ## 2. Where are my friends
 
-- You need to find the `index` of the friend name from the queue.
+- You need to find the `index()` of the friend name from the queue.
 
 ## 3. Can I please join them?
 
-- Since you know the `index`, you need to `insert` the friend to the index in the queue.
+- Since you know the `index()`, you can `insert()` the friend into the queue at that point.
 
 ## 4. Mean person in the queue
 
-- You know the mean person name, you have to `remove` them from the queue.
+- You know the mean persons name, so you can `remove()` them from the queue.
 
 # 5. Namefellows
 
-- All you need is to `count` the occurrences of the name in the queue.
+-  `count()`-ing the occurrences of the `name` in the queue could be a good strategy here.
 
 ## 6. Remove the last person
 
-- Since you know that you need to remove the last person in the queue, you need to `pop` him/her out.
+- Although you could `remove()` the person by name, `pop()`-ing them out might be quicker.
 
 ## 7. Sort the Queue List
 
-- You need to `copy` the queue, `sort` it, and return the sorted copy.
-- The order is alphabetical, hence it should be sorted in ascending order.
+- Don't forget that You need to make a `copy()` of the queue to avoid mutating it and losing the original order.
+- Once you have a `copy()`, `sort()`-ing should be straightforward.
+- Order is alphabetical or _ascending_ sort.
+
diff --git a/exercises/concept/chaitanas-colossal-coaster/.docs/instructions.md b/exercises/concept/chaitanas-colossal-coaster/.docs/instructions.md
index 94b67628..4c58d1d7 100644
--- a/exercises/concept/chaitanas-colossal-coaster/.docs/instructions.md
+++ b/exercises/concept/chaitanas-colossal-coaster/.docs/instructions.md
@@ -1,109 +1,143 @@
 # Instructions
 
-Chaitana owns a very popular theme park. She only has one ride in the very center of beautifully landscaped grounds: The Biggest Roller Coaster in the World(TM). Although there is only this one attraction, people travel from all over the world and stand in line for hours for the opportunity to ride Chaitana's hypercoaster.
+Chaitana owns a very popular theme park.
+ She only has one ride in the very center of beautifully landscaped grounds: The Biggest Roller Coaster in the World(TM).
+ Although there is only this one attraction, people travel from all over the world and stand in line for hours for the opportunity to ride Chaitana's hypercoaster.
 
-There are two queues for this ride, represented as `list`s:
+There are two queues for this ride, each represented as a `list`:
 
 1. Normal Queue
-2. Express Queue (Also known as the Fast-track) - where people pay extra for priority access.
+2. Express Queue (_also known as the Fast-track_) - where people pay extra for priority access.
+
+
+You have been asked to write some code to better manage the guests at the park.
+ You need to implement the following functions as soon as possible before the guests (and your boss, Chaitana!) get cranky.
 
-You've been asked to write some code to better manage the guests at the park. You need to implement the following functions as soon as possible before the guests (and your boss, Chaitana!) get cranky.
 
 ## 1. Add me to the queue
 
-Define the `add_me_to_the_queue()` function that takes 4 parameters `express_queue, normal_queue, ticket_type, person_name` and returns the queue with the person's name added.
+Define the `add_me_to_the_queue()` function that takes 4 parameters `<express_queue>, <normal_queue>, <ticket_type>, <person_name>` and returns the appropriate queue updated with the person's name.
 
 
-1. ticket_type is an `int` with 1 == express_queue and 0 == normal_queue.
-2. person_name is the name (as a `str`) of the person to be added to the respective queue.
+1. `<ticket_type>` is an `int` with 1 == express_queue and 0 == normal_queue.
+2. `<person_name>` is the name (as a `str`) of the person to be added to the respective queue.
 
-Once you have added the name to the appropriate queue, return the queue that includes the new person.
 
 ```python
 >>> add_me_to_the_queue(express_queue=["Tony", "Bruce"], normal_queue=["RobotGuy", "WW"], ticket_type=1, person_name="RichieRich")
+...
 ["Tony", "Bruce", "RichieRich"]
 
 >>> add_me_to_the_queue(express_queue=["Tony", "Bruce"], normal_queue=["RobotGuy", "WW"], ticket_type=0, person_name="HawkEye")
+....
 ["RobotGuy", "WW", "HawkEye"]
 ```
 
-## 2. Where are my friends
+## 2. Where are my friends?
+
+One person arrived late at the park but wants to join the queue where their friends are waiting.
+ But they have no idea where their friends are standing and there isn't any phone reception to call them.
 
-One person arrived late at the park but wants to join the queue with his friends. He has no idea where they're standing, and he can't get any reception to call them.
+Define the `find_my_friend()` function that takes 2 parameters `queue` and  `friend_name`.
 
-Define the `find_my_friend()` function that takes 2 parameters `queue, friend_name`.
 
-1. queue is the list of people standing in the queue.
-2. friend_name is the name of the friend whose index you need to find.
+1. `<queue>` is the `list` of people standing in the queue.
+2. `<friend_name>` is the name of the friend whose index (place in the queue) you need to find.
+
+Remember:  Indexing starts at 0 from the left, and -1 from the right.
 
-Indexing starts at 0.
 
 ```python
->>> find_my_friend(queue=["Natasha", "Steve", "Tchalla", "Wanda", "Rocket"], friend_name="Steve")
+>>> find_my_friend(queue=["Natasha", "Steve", "T'challa", "Wanda", "Rocket"], friend_name="Steve")
+...
 1
 ```
 
+
 ## 3. Can I please join them?
 
-Define the `add_me_with_my_friends()` function that takes 3 parameters `queue, index, person_name`.
+Now that their friends have been found (in task #2 above), the late arriver would like to join them at their place in the queue.
+Define the `add_me_with_my_friends()` function that takes 3 parameters `queue`, `index`, and  `person_name`.
+
+
+1. `<queue>` is the `lis`t of people standing in the queue.
+2. `<index>` is the position at which the new person should be added.
+3. `<person_name>` is the name of the person to add at the index position.
+
+Return the queue updated with the late arrivals name.
 
-1. queue is the list of people standing in the queue.
-2. index is the position at which the person should be added.
-3. person_name is the name of the person to add at this position.
 
 ```python
->>> add_me_with_my_friends(queue=["Natasha", "Steve", "Tchalla", "Wanda", "Rocket"], index=1, person_name="Bucky")
-["Natasha", "Bucky", "Steve", "Tchalla", "Wanda", "Rocket"]
+>>> add_me_with_my_friends(queue=["Natasha", "Steve", "T'challa", "Wanda", "Rocket"], index=1, person_name="Bucky")
+...
+["Natasha", "Bucky", "Steve", "T'challa", "Wanda", "Rocket"]
 ```
 
 ## 4. Mean person in the queue
 
-You just heard from the queue that there is a really mean person shoving, shouting, and making trouble. You need to throw that miscreant out for bad behavior.
+You just heard from the queue that there is a really mean person shoving, shouting, and making trouble.
+ You need to throw that miscreant out for bad behavior!
+
 
-Define the `remove_the_mean_person()` function that takes 2 parameters `queue, person_name`.
+Define the `remove_the_mean_person()` function that takes 2 parameters `queue` and `person_name`.
+
+
+1. `<queue>` is the `list` of people standing in the queue.
+2. `<person_name>` is the name of the person that needs to be kicked out.
 
-1. queue is the list of people standing in the queue.
-2. person_name is the name of the person whom we need to kick out.
 
 ```python
 >>> remove_the_mean_person(queue=["Natasha", "Steve", "Eltran", "Wanda", "Rocket"], person_name="Eltran")
+...
 ["Natasha", "Steve", "Wanda", "Rocket"]
 ```
 
+
 # 5. Namefellows
 
-You may not have seen two unrelated people who look exactly the same, but you've _definitely_ seen unrelated people with the same exact name (_namefellows or doppelgängers_)! It looks like today there are a lot of them. You want to know how many times a particular name occurs in the queue.
+You may not have seen two unrelated people who look exactly the same, but you have _definitely_ seen unrelated people with the exact same name (_namefellows_)!
+ Today, it looks like there are a lot of them in attendance.
+  You want to know how many times a particular name occurs in the queue.
+
+Define the `how_many_namefellows()` function that takes 2 parameters `queue` and  `person_name`.
 
-Define the `how_many_namefellows()` function that takes 2 parameters `queue, person_name`.
+1. `<queue>` is the `list` of people standing in the queue.
+2. `<person_name>` is the name you think might occur more than once in the queue.
 
-1. queue is the list of people standing in the queue.
-2. person_name is the name you think might occur more than once in the queue.
 
-Return the number of occurrences of person_name, as an `int`.
+Return the number of occurrences of `person_name`, as an `int`.
+
 
 ```python
 >>> how_many_namefellows(queue=["Natasha", "Steve", "Eltran", "Natasha", "Rocket"], person_name="Natasha")
+...
 2
 ```
 
 ## 6. Remove the last person
 
-Sadly, it's overcrowded in the queue today and you need to remove the last person in line (_you'll give them a voucher to come back in the fast track another time_). You'll have to define the function `remove_the_last_person()` that takes 1 parameter `queue`, which is the list of people standing in the queue.
+Sadly, it's overcrowded at the park today and you need to remove the last person in the normal line (_you will give them a voucher to come back in the fast-track on another day_).
+ You will have to define the function `remove_the_last_person()` that takes 1 parameter `queue`, which is the list of people standing in the queue.
+
+You should update the `list` and also `return` the name of the person who was removed, so you can write them a voucher.
 
-You should also return the name of the person who was removed, so you can write them a voucher.
 
 ```python
 >>> remove_the_last_person(queue=["Natasha", "Steve", "Eltran", "Natasha", "Rocket"])
+...
 'Rocket'
 ```
 
 ## 7. Sort the Queue List
 
-For administrative purposes, you need to get the names in alphabetical order.
+For administrative purposes, you need to get all the names in a given queue in alphabetical order.
+
+
+Define the `sorted_names()` function that takes 1 argument,  `queue`, (the `list` of people standing in the queue), and returns a `sorted` copy of the `list`.
 
-Define the `sorted_names()` function that takes 1 argument: `queue`, which is the list of people standing in the queue, and returns a sorted copy of the list.
 
 ```python
 >>> sorted_names(queue=["Natasha", "Steve", "Eltran", "Natasha", "Rocket"])
+...
 ['Eltran', 'Natasha', 'Natasha', 'Rocket', 'Steve']
 ```
diff --git a/exercises/concept/chaitanas-colossal-coaster/.docs/introduction.md b/exercises/concept/chaitanas-colossal-coaster/.docs/introduction.md
index 0eaf1c1d..023b6147 100644
--- a/exercises/concept/chaitanas-colossal-coaster/.docs/introduction.md
+++ b/exercises/concept/chaitanas-colossal-coaster/.docs/introduction.md
@@ -1,22 +1,30 @@
 # Introduction
 
-A [`list`][list] is a mutable collection of items in _sequence_. Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold reference to any (or multiple) data type(s) - including other lists.  They can be copied in whole or in part via [slice notation][slice notation]. Like any [sequence][sequence type], elements within `lists` are referenced by `0-based index` number from the left, or `-1-based index` number from the right.
+A [`list`][list] is a mutable collection of items in _sequence_.
+ Like most collections (_see the built-ins [`tuple`][tuple], [`dict`][dict] and [`set`][set]_), lists can hold reference to any (or multiple) data type(s) - including other lists.
+ Lists can be copied in whole or in part via [slice notation][slice notation] or through the use of `<list>.copy()`.
+ Like any [sequence][sequence type], elements within `lists` are referenced by `0-based index` number from the left, or `-1-based index` number from the right.
 
-Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations like `min(<list>)`/`max(<list>)`, `<list>.index()`, `<list>.append()` and `<list>.reverse()`.
-Elements inside a `list`  can be iterated over using the `for item in <list>` construct.
-`for index, item in enumerate(<list>)` can be used when both the element index and element value are needed.
+Lists support both [common][common sequence operations] and [mutable][mutable sequence operations] sequence operations such as `min(<list>)`/`max(<list>)`, `<list>.index()`, `<list>.append()` and `<list>.reverse()`.
+ Elements inside a `list`  can be iterated over using the `for item in <list>` construct.
+ `for index, item in enumerate(<list>)` can be used when both the element index and element value are needed.
 
-Python provides many useful [methods][list-methods] for working with lists. Let's take a look at some of them.
+Python also provides many useful [list-methods][list-methods] for working with lists.
+ A selection of these `list methods` is covered below.
+
+
+Note that when you manipulate a `list` with a `list-method`, **you alter the list** object that has been passed.
+ If you do not wish to mutate the original `list`, you will need to at least make a `shallow copy` of it via slice or `<list>.copy()`.
 
-But keep in mind that when you manipulate a `list` with a list-method, **you alter the list** object that has been passed. If you do not wish to mutate your original `list`, you will need to at least make a `shallow copy` of it via slice or `<list>.copy()`.
 
 ## Adding Items
 
-To add an item to the end or "right-hand side" of an existing list, use `<list>.append()`:
+To add an item to the end or "right-hand side" of an existing list, use `<list>.append(<item>)`:
 
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.append(9)
+
 >>> numbers
 [1, 2, 3, 9]
 ```
@@ -24,47 +32,62 @@ To add an item to the end or "right-hand side" of an existing list, use `<list>.
 Rather than _appending_, `<list>.insert()` gives you the ability to add the item to a _specific index_ in the list.
 It takes 2 parameters:
 
-1. the index at which you want the item to be inserted
-2. the item to be inserted
+1. the `<index>` at which you want the item to be inserted.
+2. the `<item>` to be inserted.
+
+**Note**: If the given `index` is 0, the item will be added to the start ("left-hand side") of the `list`.
+ If the supplied `index` is greater than the final `index` on the `list`, the item will be added in the final position -- the equivalent of using `<list>.append(<item>)`.
 
-**Note**: If the given index is 0, the item will be added to the start ("left-hand side") of the list. If the supplied index is greater than the final index on the list, the item will be added in the final position -- the equivalent of using `<list>.append()`.
 
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.insert(0, -2)
+
 >>> numbers
 [-2, 1, 2, 3]
+
 >>> numbers.insert(1, 0)
+
 >>> numbers
 [-2, 0, 1, 2, 3]
 ```
 
-`<list>.extend()` can be used to combine an existing list with the elements from another iterable (for example, a `set`, `tuple`, `str`, or `list`).  The iterable is _unpacked_ and elements are appended in order. (_Using `<list>.append()` in this circumstance would add the entire iterable as a **single item**._).
+
+`<list>.extend(<item>)` can be used to combine an existing list with the elements from another iterable (for example, a `set`, `tuple`, `str`, or `list`).
+  The iterable is _unpacked_ and elements are appended in order (_Using `<list>.append(<item>)` in this circumstance would add the entire iterable as a **single item**._).
+
 
 ```python
 >>> numbers = [1, 2, 3]
 >>> other_numbers = [5, 6, 7]
 
 >>> numbers.extend(other_numbers)
+
 >>> numbers
 [1, 2, 3, 5, 6, 7]
 
 >>> numbers.extend([8, 9])
+
 >>> numbers
 [1, 2, 3, 5, 6, 7, 8, 9]
 
 >>> numbers.append([8,9])
+
 >>> numbers
 [1, 2, 3, 5, 6, 7, 8, 9, [8, 9]]
 ```
 
+
 ## Removing Items
 
-To delete an item from a list use `<list>.remove()`, passing the item to be removed as an argument. `list.remove()` will throw a `ValueError` if the item is not present in the list.
+To delete an item from a list use `<list>.remove(<item>)`, passing the item to be removed as an argument.
+ `<list>.remove(<item>)` will throw a `ValueError` if the item is not present in the `list`.
+
 
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.remove(2)
+
 >>> numbers
 [1, 3]
 
@@ -73,20 +96,30 @@ To delete an item from a list use `<list>.remove()`, passing the item to be remo
 ValueError: list.remove(x): x not in list
 ```
 
-Alternatively, using the `list.pop()` method will both remove **and** `return` an element for use.
 
-`list.pop()` takes one optional parameter: the index of the item to be removed and returned. If the (optional) index argument is not specified, the last element of the list will be removed and returned. If the index specified is higher than the final item index, an `IndexError` is raised.
+Alternatively, using the `<list>.pop(<item>)` method will both remove **and** `return` an element for use.
+
+
+`<list>.pop(<item>)` takes one optional parameter: the `index` of the item to be removed and returned.
+ If the (optional) `index` argument is not specified, the final element of the `list` will be removed and returned.
+ If the `index` specified is higher than the final item `index`, an `IndexError` is raised.
+
 
 ```python
 >>> numbers = [1, 2, 3]
+
 >>> numbers.pop(0)
 1
+
 >>> numbers
 [2, 3]
+
 >>> numbers.pop()
 3
+
 >>> numbers
 [2]
+
 >>> numbers.pop(1)
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
@@ -98,28 +131,37 @@ All elements can be removed from a `list` with `list.clear()`. It doesn't take a
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.clear()
+
 >>> numbers
 []
 ```
 
 ## Reversing and reordering
 
-The `<list>.reverse()` method will reverse the order of elements in-place.
+The `<list>.reverse()` method will reverse the order of elements **in-place**.
+
 
 ```python
 >>> numbers = [1, 2, 3]
 >>> numbers.reverse()
+
 >>> numbers
 [3, 2, 1]
 ```
 
-A list can be re-ordered _**in place**_ with the help of `<list>.sort()`. Internally, Python uses [`Timsort`][timsort] to arrange the list. The default order will be _ascending_. Take a look at the Python docs for some [additional tips and techniques for sorting][sorting how to] lists effectively.
+
+A list can be re-ordered _**in place**_ with the help of `<list>.sort()`.
+ Internally, Python uses [`Timsort`][timsort] to arrange the list.
+ Default order is _ascending_ from the left.
+ The Python docs offer [additional tips and techniques for sorting][sorting how to] lists effectively.
+
 
 ```python
 >>> names = ["Tony", "Natasha", "Thor", "Bruce"]
 
 # The default sort order is *ascending*.
 >>> names.sort()
+
 >>> names
 ["Bruce", "Natasha", "Thor", "Tony"]
 ```
@@ -129,62 +171,78 @@ If a _descending_ order is desired, pass the `reverse=True` argument:
 ```python
 >>> names = ["Tony", "Natasha", "Thor", "Bruce"]
 >>> names.sort(reverse=True)
+
 >>> names
 ["Tony", "Thor", "Natasha", "Bruce"]
 ```
 
-For cases where mutating the original list is undesirable, the built-in [`sorted()`][sorted] function can be used to return a sorted copy.
+For cases where mutating the original list is undesirable, the built-in [`sorted(<iterable>)`][sorted] function can be used to return a sorted **copy**.
+
 
 ```python
 >>> names = ["Tony", "Natasha", "Thor", "Bruce"]
+
 >>> sorted(names)
 ['Bruce', 'Natasha', 'Thor', 'Tony']
 ```
 
+
 ## Occurrences of an item in a list
 
-The number of occurrences of an element in a list can be calculated with the help of `list.count()`. It takes the item to be counted as its argument and returns the total number of times the element appears in the list.
+The number of occurrences of an element in a list can be calculated with the help of `list.count(<item>)`.
+ It takes the `item` to be counted as its argument and returns the total number of times that element appears in the `list`.
+
 
 ```python
 >>> items = [1, 4, 7, 8, 2, 9, 2, 1, 1, 0, 4, 3]
+
 >>> items.count(1)
 3
 ```
 
 ## Finding the index of items
 
-`<list>.index(<item>)` will return the index number of the _first occurrence_ of an item passed in. If there are no occurrences, a `ValueError` is raised. If the exact position of an item isn't needed, the built-in `in` operator is more efficient for checking if a list contains a given value.
+`<list>.index(<item>)` will return the `index` number of the _first occurrence_ of an item passed in.
+ If there are no occurrences, a `ValueError` is raised.
+ If the exact position of an item isn't needed, the built-in `in` operator is more efficient for checking if a list contains a given value.
+
+
+Indexing is zero-based from the left, so the position of the "first" item is `0`.
+Indexing will also work from the right, beginning with `-1`.
 
-Indexing is zero-based, so the position of the first item is `0`.
 
 ```python
 >>> items = [7, 4, 1, 0, 2, 5]
+
 >>> items.index(4)
 1
+
 >>> items.index(10)
 ValueError: 10 is not in list
 ```
 
-`start` and `end` indices can also be provided to narrow the search to a specific section of the list:
+`start` and `end` indices can also be provided to narrow the search to a specific section of the `list`:
 
 ```python
 >>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
+
 >>> names.index("Tina")
 0
+
 >>> names.index("Tina", 2, 5)
 3
 ```
 
 
+[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
+[dict]: https://docs.python.org/3/library/stdtypes.html#dict
 [list-methods]: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
-[timsort]: https://en.wikipedia.org/wiki/Timsort
+[list]: https://docs.python.org/3/library/stdtypes.html#list
+[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
+[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+[set]: https://docs.python.org/3/library/stdtypes.html#set
+[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
 [sorted]: https://docs.python.org/3/library/functions.html#sorted
 [sorting how to]: https://docs.python.org/3/howto/sorting.html
-[sequence type]: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
-[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
-[mutable sequence operations]: https://docs.python.org/3/library/stdtypes.html#typesseq-mutable
+[timsort]: https://en.wikipedia.org/wiki/Timsort
 [tuple]: https://docs.python.org/3/library/stdtypes.html#tuple
-[slice notation]: https://docs.python.org/3/reference/expressions.html#slicings
-[set]: https://docs.python.org/3/library/stdtypes.html#set
-[dict]: https://docs.python.org/3/library/stdtypes.html#dict
-[list]: https://docs.python.org/3/library/stdtypes.html#list
diff --git a/exercises/concept/chaitanas-colossal-coaster/.meta/config.json b/exercises/concept/chaitanas-colossal-coaster/.meta/config.json
index c6718b40..28c9d143 100644
--- a/exercises/concept/chaitanas-colossal-coaster/.meta/config.json
+++ b/exercises/concept/chaitanas-colossal-coaster/.meta/config.json
@@ -1,5 +1,5 @@
 {
-  "blurb": "Learn useful list methods helping Chaitana manage the lines for her colossal rollercoaster.",
+  "blurb": "Learn useful list methods helping Chaitana manage the lines for her colossal roller coaster.",
   "icon": "spiral-matrix",
   "contributors": ["valentin-p"],
   "authors": ["mohanrajanr", "BethanyG"],
diff --git a/exercises/concept/chaitanas-colossal-coaster/.meta/design.md b/exercises/concept/chaitanas-colossal-coaster/.meta/design.md
index 76f86a85..fc4c1de4 100644
--- a/exercises/concept/chaitanas-colossal-coaster/.meta/design.md
+++ b/exercises/concept/chaitanas-colossal-coaster/.meta/design.md
@@ -2,25 +2,25 @@
 
 ## Goal
 
-This concept exercise should make the student aware of the existence of some list methods that allow us to work with lists, and how to use them to modify lists and operate with them.
+This concept exercise should make the student aware of a selection of `list methods` for modifying and manipulating `lists`.
 
 ## Learning objectives
 
-- Understand when it is appropriate to use methods of a list to operate with it
-- Understand that a method of a list mutates the list and does not return a new altered list
+- Understand when it is appropriate to use `list methods`
+- Understand that most `list methods` mutate the original `list` and **do not** return a new or copied list.
 - Use one or more of the below methods to alter a list:
-    - Add a single item to the end of a list with the append() method
-    - Remove all items from a list with the clear() method
-    - Insert an item in a list with the insert() method
-    - Remove the item at the given index with the pop() method
-    - Remove an item from a list with the remove() method
-    - Reverse a list with the reverse() method
-    - Sort items of a list with the sort() method
-    - Return a shallow copy of a list with the copy() method
-    - Return the number of times an item occurs in a list with the count() method
-    - Add all items from another iterable to the end of a list with the extend() method
-    - Return the index of an item in a list with the index() method
-- Understand which data in a list can be sorted and/or compared
+    - Add a single item to the end of a list with the `append()`
+    - Remove all items from a list with the `clear()` method
+    - Insert an item in a list with the `insert()` method
+    - Remove the item at the given index with the `pop()` method
+    - Remove an item from a list with the `remove()` method
+    - Reverse a list with the `reverse()` method
+    - Sort items of a list with the `sort()` method
+    - Return a shallow copy of a list with the `copy()` method
+    - Return the number of times an item occurs in a `list` with the `count()` method
+    - Add all items from another iterable to the end of a list with the `extend()` method
+    - Return the index of an item in a list with the `index()` method
+- Understand which data in a `list` can be sorted and/or compared
 
 ## Out of scope
 
@@ -30,18 +30,7 @@ This concept exercise should make the student aware of the existence of some lis
 
 - iterables
 - lists
-- methods of a list
-- append() list method
-- clear() list method
-- insert() list method
-- pop() list method
-- remove() list method
-- reverse() list method
-- sort() list method
-- copy() list method
-- count() list method
-- extend() list method
-- index() list method
+- list methods
 
 ## Prerequisites
 
diff --git a/exercises/concept/chaitanas-colossal-coaster/.meta/exemplar.py b/exercises/concept/chaitanas-colossal-coaster/.meta/exemplar.py
index ce37ce5d..081d736a 100644
--- a/exercises/concept/chaitanas-colossal-coaster/.meta/exemplar.py
+++ b/exercises/concept/chaitanas-colossal-coaster/.meta/exemplar.py
@@ -30,5 +30,6 @@ def remove_the_last_person(queue):
 
 
 def sorted_names(queue):
-    queue.sort()
-    return queue
+    new_queue = queue[:]
+    new_queue.sort()
+    return new_queue
diff --git a/exercises/concept/chaitanas-colossal-coaster/list_methods.py b/exercises/concept/chaitanas-colossal-coaster/list_methods.py
index 6f37a88a..53ed061d 100644
--- a/exercises/concept/chaitanas-colossal-coaster/list_methods.py
+++ b/exercises/concept/chaitanas-colossal-coaster/list_methods.py
@@ -1,26 +1,69 @@
 def add_me_to_the_queue(express_queue, normal_queue, ticket_type, person_name):
+    '''
+
+    :param express_queue: list - names in the Fast-track queue.
+    :param normal_queue:  list - names in the normal queue.
+    :param ticket_type:  int - type of ticket. 1 = express, 0 = normal.
+    :param person_name: str - name of person to add to a queue.
+    :return: list - the (updated) queue the name was added to.
+    '''
     pass
 
 
 def find_my_friend(queue, friend_name):
+    '''
+
+    :param queue: list - names in the queue.
+    :param friend_name: str - name of friend to find.
+    :return: int - index at which the friends name was found.
+    '''
     pass
 
 
 def add_me_with_my_friends(queue, index, person_name):
+    '''
+
+    :param queue: list - names in the queue.
+    :param index: int - the index at which to add the new name.
+    :param person_name: str - the name to add.
+    :return: list - queue updated with new name.
+    '''
     pass
 
 
 def remove_the_mean_person(queue, person_name):
+    '''
+
+    :param queue: list - names in the queue.
+    :param person_name: str - name of mean person.
+    :return:  list - queue update with the mean persons name removed.
+    '''
     pass
 
 
 def how_many_namefellows(queue, person_name):
+    '''
+
+    :param queue: list - names in the queue.
+    :param person_name: str - name you wish to count or track.
+    :return:  int - the number of times the name appears in the queue.
+    '''
     pass
 
 
 def remove_the_last_person(queue):
+    '''
+
+    :param queue: list - names in the queue.
+    :return: str - name that has been removed from the end of the queue.
+    '''
     pass
 
 
 def sorted_names(queue):
-    pass
+    '''
+
+    :param queue: list - names in the queue.
+    :return: list - copy of the queue in alphabetical order.
+    '''
+    pass
\ No newline at end of file
diff --git a/exercises/concept/currency-exchange/.docs/hints.md b/exercises/concept/currency-exchange/.docs/hints.md
index a5ca8cd7..f4f20cf0 100644
--- a/exercises/concept/currency-exchange/.docs/hints.md
+++ b/exercises/concept/currency-exchange/.docs/hints.md
@@ -17,7 +17,7 @@
 ## 4. Calculate number of bills
 
 - You need to divide `budget` into `denomination`.
-- You need to use type casting _int_ to get exact number of bill.
+- You need to use type casting to _int_ to get the exact number of bills.
 - To remove decimal places from a `float`, you can convert it to `int`.
 
   **Note:** The `//` operator also does floor division. But, if the operand has `float`, the result is still `float`.
@@ -25,5 +25,5 @@
 ## 5. Calculate exchangeable value
 
 - You need to calculate `spread` percent of `exchange_rate` using multiplication operator and add it to `exchange_rate` to get the exchanged currency.
-- Actual rate need to be computed! add exchange rate and exchange fee.
+- The actual rate needs to be computed. Remember to add exchange rate and exchange fee.
 - You can get exchanged money affected by commission by using divide operation and type casting _int_.
diff --git a/exercises/concept/meltdown-mitigation/.docs/hints.md b/exercises/concept/meltdown-mitigation/.docs/hints.md
index fb2be75c..510b8bd4 100644
--- a/exercises/concept/meltdown-mitigation/.docs/hints.md
+++ b/exercises/concept/meltdown-mitigation/.docs/hints.md
@@ -10,7 +10,7 @@
 
 - Comparison operators and boolean operations can be combined and used with conditionals.
 - Conditional expressions must evaluate to `True` or `False`.
-- `else` can be used for a code block that will execute when a conditional test returns `False`.
+- `else` can be used for a code block that will execute when all conditional tests return `False`.
 
   ```python
      >>> item = 'blue'
diff --git a/exercises/concept/meltdown-mitigation/.docs/instructions.md b/exercises/concept/meltdown-mitigation/.docs/instructions.md
index 809b93a5..9e4feb45 100644
--- a/exercises/concept/meltdown-mitigation/.docs/instructions.md
+++ b/exercises/concept/meltdown-mitigation/.docs/instructions.md
@@ -5,7 +5,7 @@ In this exercise, we'll develop a simple control system for a nuclear reactor.
 For a reactor to produce the power it must be in a state of _criticality_.
 If the reactor is in a state less than criticality, it can become damaged.
 If the reactor state goes beyond criticality, it can overload and result in a meltdown.
-We want to mitigte the chances of meltdown and correctly manage reactor state.
+We want to mitigate the chances of meltdown and correctly manage reactor state.
 
 The following three tasks are all related to writing code for maintaining ideal reactor state.
 
@@ -14,9 +14,9 @@ The following three tasks are all related to writing code for maintaining ideal
 The first thing a control system has to do is check if the reactor is balanced in criticality.
 A reactor is said to be critical if it satisfies the following conditions:
 
-- The temperature less than 800.
-- The number of neutrons emitted per second greater than 500.
-- The product of temperature and neutrons emitted per second less than 500000.
+- The temperature is less than 800.
+- The number of neutrons emitted per second is greater than 500.
+- The product of temperature and neutrons emitted per second is less than 500000.
 
 Implement the function `is_criticality_balanced()` that takes `temperature` and `neutrons_emitted` as parameters, and returns `True` if the criticality conditions are met, `False` if not.
 
@@ -35,8 +35,8 @@ Efficiency can be grouped into 4 bands:
 3. red -> 30-59% efficiency
 4. black -> <30% efficient
 
-These percentage ranges are calculated as `(generated_power/ theoretical_max_power)*100`
-where generated `power = voltage * current`
+These percentage ranges are calculated as `(generated_power/theoretical_max_power)*100`
+where `generated_power = voltage * current`
 
 Implement the function `reactor_efficency()`, with three parameters: `voltage`,
 `current`, and `theoretical_max_power`.
@@ -56,7 +56,7 @@ Criticality can then be increased, decreased, or stopped by inserting (or removi
 Implement the function called `fail_safe()`, which takes 3 parameters: `temperature`,
 `neutrons_produced_per_second`, and `threshold`, and outputs a status code for the reactor.
 
-- If `temperature * neutrons_per_second` < 40% of threshold, output a status code of 'LOW'
+- If `temperature * neutrons_per_second` < 40% of `threshold`, output a status code of 'LOW'
   indicating that control rods must be removed to produce power.
 
 - If `temperature * neutrons_per_second` are within plus or minus 10% of the `threshold`
diff --git a/exercises/concept/meltdown-mitigation/.docs/introduction.md b/exercises/concept/meltdown-mitigation/.docs/introduction.md
index 16aceb4d..f3cffc96 100644
--- a/exercises/concept/meltdown-mitigation/.docs/introduction.md
+++ b/exercises/concept/meltdown-mitigation/.docs/introduction.md
@@ -25,7 +25,7 @@ When paired with `if`, an optional `else` code block will execute when the origi
 x = 5
 y = 10
 
-# The comparison '>' here returns the bool False,
+# The comparison '>' here returns the bool 'False',
 # so the 'else' block is executed instead of the 'if' block.
 if x > y:
     print("x is greater than y")
@@ -42,7 +42,7 @@ x = 5
 y = 10
 z = 20
 
-# The elif statement allows for the checking of more conditions.
+# The 'elif' statement allows for the checking of more conditions.
 if x > y:
     print("x is greater than y and z")
 elif y > z:
@@ -53,7 +53,7 @@ else:
 >>> z is great than x and y
 ```
 
-[Boolen operations][boolean operations] and [comparisons][comparisons] can be combined with conditionals for more complex testing:
+[Boolean operations][boolean operations] and [comparisons][comparisons] can be combined with conditionals for more complex testing:
 
 ```python
 
diff --git a/exercises/concept/meltdown-mitigation/.meta/exemplar.py b/exercises/concept/meltdown-mitigation/.meta/exemplar.py
index e001afce..96c2833f 100644
--- a/exercises/concept/meltdown-mitigation/.meta/exemplar.py
+++ b/exercises/concept/meltdown-mitigation/.meta/exemplar.py
@@ -1,18 +1,18 @@
-def is_criticality_balanced(temprature, neutrons_emitted):
+def is_criticality_balanced(temperature, neutrons_emitted):
     '''
 
-    :param temprature: int
+    :param temperature: int
     :param neutrons_emitted: int
-    :return:  boolen True if conditions met, False if not
+    :return:  boolean True if conditions met, False if not
 
     A reactor is said to be critical if it satisfies the following conditions:
     - The temperature less than 800.
     - The number of neutrons emitted per second greater than 500.
     - The product of temperature and neutrons emitted per second less than 500000.
     '''
-    output = temprature * neutrons_emitted
+    output = temperature * neutrons_emitted
 
-    if (temprature < 800 and neutrons_emitted > 500) and output < 500000:
+    if (temperature < 800 and neutrons_emitted > 500) and output < 500000:
         return True
     else:
         return False
@@ -57,7 +57,7 @@ def fail_safe(temperature, neutrons_produced_per_second, threshold):
     :param threshold:
     :return: str one of: 'LOW', 'NORMAL', 'DANGER'
 
-    - `temperature * neutrons per second` < 40% of threshold == 'LOW'
+    - `temperature * neutrons per second` < 40% of `threshold` == 'LOW'
     - `temperature * neutrons per second` +/- 10% of `threshold` == 'NORMAL'
     - `temperature * neutron per second` is not in the above-stated ranges ==  'DANGER'
     '''
diff --git a/exercises/concept/meltdown-mitigation/conditionals.py b/exercises/concept/meltdown-mitigation/conditionals.py
index 238b4e87..3ee8f789 100644
--- a/exercises/concept/meltdown-mitigation/conditionals.py
+++ b/exercises/concept/meltdown-mitigation/conditionals.py
@@ -1,14 +1,14 @@
-def is_criticality_balanced(temprature, neutrons_emitted):
+def is_criticality_balanced(temperature, neutrons_emitted):
     '''
 
-    :param temprature: int
+    :param temperature: int
     :param neutrons_emitted: int
-    :return:  boolen True if conditions met, False if not
+    :return:  boolean True if conditions met, False if not
 
     A reactor is said to be critical if it satisfies the following conditions:
-    - The temperature less than 800.
-    - The number of neutrons emitted per second greater than 500.
-    - The product of temperature and neutrons emitted per second less than 500000.
+    - The temperature is less than 800.
+    - The number of neutrons emitted per second is greater than 500.
+    - The product of temperature and neutrons emitted per second is less than 500000.
     '''
     pass
 


Test patch:
diff --git a/exercises/concept/card-games/lists_test.py b/exercises/concept/card-games/lists_test.py
index dc19ccee..49b52e7e 100644
--- a/exercises/concept/card-games/lists_test.py
+++ b/exercises/concept/card-games/lists_test.py
@@ -54,44 +54,27 @@ class TestToRounds(unittest.TestCase):
 
 class TestConcatenateRounds(unittest.TestCase):
 
-    @pytest.mark.task(taskno=2)
-    def test_instructions_example(self):
-        rounds1 = [27, 28, 29]
-        rounds2 = [35, 36]
-        want = [27, 28, 29, 35, 36]
-        got = concatenate_rounds(rounds1, rounds2)
-
-        self.assertEqual(
-            want,
-            got,
-            msg=f'Expected {want} but got an incorrect result: {got!r}'
-        )
-
     @pytest.mark.task(taskno=2)
     def test_empty(self):
-        rounds1 = []
-        rounds2 = []
+        rounds_1 = []
+        rounds_2 = []
         want = []
-        got = concatenate_rounds(rounds1, rounds2)
 
-        self.assertEqual(
+        self.assertEqual(concatenate_rounds(rounds_1, rounds_2),
             want,
-            got,
-            msg=f'Expected {want} but got an incorrect result: {got!r}'
+            msg=f'Expected {want} but got an incorrect result.'
         )
 
     @pytest.mark.task(taskno=2)
     def test_other(self):
-        rounds1 = [1, 2, 3]
-        rounds2 = [4, 5, 6]
+        rounds_1 = [1, 2, 3]
+        rounds_2 = [4, 5, 6]
         want = [1, 2, 3, 4, 5, 6]
-        got = concatenate_rounds(rounds1, rounds2)
 
-        self.assertEqual(
-            want,
-            got,
-            msg=f'Expected {want} but got an incorrect result: {got!r}'
-        )
+        self.assertEqual(concatenate_rounds(rounds_1, rounds_2),
+                         want,
+                         msg=f'Expected {want} but got an incorrect result.'
+                         )
 
 
 class TestListContainsRound(unittest.TestCase):
@@ -242,7 +225,7 @@ class TestApproxAverageIsAverage(unittest.TestCase):
 
     @pytest.mark.task(taskno=5)
     def test_other_false(self):
-        hand = [2, 3, 4, 7]
+        hand = [2, 3, 4, 7, 8]
         want = False
         got = approx_average_is_average(hand)
 
diff --git a/exercises/concept/meltdown-mitigation/conditionals_test.py b/exercises/concept/meltdown-mitigation/conditionals_test.py
index 9005e72f..cc5bc567 100644
--- a/exercises/concept/meltdown-mitigation/conditionals_test.py
+++ b/exercises/concept/meltdown-mitigation/conditionals_test.py
@@ -16,26 +16,26 @@ class TestConditionals(unittest.TestCase):
     def test_is_criticality_balanced_set1(self):
 
         self.assertTrue(is_criticality_balanced(
-            temprature=750, neutrons_emitted=650), msg="Expected True but returned False")
+            temperature=750, neutrons_emitted=650), msg="Expected True but returned False")
 
     @pytest.mark.task(taskno=1)
     def test_is_criticality_balanced_set2(self):
 
         self.assertTrue(is_criticality_balanced(
-            temprature=799, neutrons_emitted=501), msg="Expected True but returned False")
+            temperature=799, neutrons_emitted=501), msg="Expected True but returned False")
 
     @pytest.mark.task(taskno=1)
     def test_is_criticality_balanced_set3(self):
 
         self.assertTrue(
-            is_criticality_balanced(temprature=500, neutrons_emitted=600), msg="Expected True but returned False"
+            is_criticality_balanced(temperature=500, neutrons_emitted=600), msg="Expected True but returned False"
         )
 
     @pytest.mark.task(taskno=1)
     def test_is_criticality_balanced_set4(self):
 
         self.assertFalse(
-            is_criticality_balanced(temprature=800, neutrons_emitted=500), msg="Expected False but returned True"
+            is_criticality_balanced(temperature=800, neutrons_emitted=500), msg="Expected False but returned True"
         )
 
 # End of first functions testing