Repository: exercism/python
Pull request #2499 (2021-08-28 22:16:10)

Typos on "numbers" concept.
Closes [#2490](https://github.com/exercism/python/issues/2490)
Found a few things to fix in Currency Exchange and Meltdown Mitigation


Patch:
diff --git a/concepts/bools/about.md b/concepts/bools/about.md
index 6e960da7..e5480837 100644
--- a/concepts/bools/about.md
+++ b/concepts/bools/about.md
@@ -1,21 +1,25 @@
 # About
 
-Python represents True and False values with the [bool][bool] type. There are only two boolean values: `True` and `False`. These values can be assigned to a variable and combined with the [boolean operators][boolean-operators] (`and`, `or`, `not`):
+Python represents True and False values with the [bool][bool] type.
+ There are only two Boolean values in this type: `True` and `False`.
+  These values can be assigned to a variable and combined with the [Boolean operators][boolean-operators] (`and`, `or`, `not`):
+
 
 ```python
-true_variable = True and True
-false_variable = True and False
+>>> true_variable = True and True
+>>> false_variable = True and False
 
-true_variable = False or True
-false_variable = False or False
+>>> true_variable = False or True
+>>> false_variable = False or False
 
-true_variable = not False
-false_variable = not True
+>>> true_variable = not False
+>>> false_variable = not True
 ```
 
 [Boolean operators][boolean-operators] use _short-circuit evaluation_, which means that expression on the right-hand side of the operator is only evaluated if needed.
 
-Each of the operators has a different precedence, where `not` is evaluated before `and` and `or`. Brackets can be used to evaluate one part of the expression before the others:
+Each of the operators has a different precedence, where `not` is evaluated before `and` and `or`.
+ Brackets can be used to evaluate one part of the expression before the others:
 
 ```python
 >>>not True and True
@@ -27,9 +31,11 @@ True
 
 All `boolean operators` are considered lower precedence than Pythons [`comparison operators`][comparisons], such as `==`, `>`, `<`, `is` and `is not`.
 
+
 ## Type Coercion and Truthiness
 
-The bool function ([`bool()`][bool-function]) converts any object to a Boolean value. By default all objects return `True` unless defined to return `False`.
+The `bool` function ([`bool()`][bool-function]) converts any object to a Boolean value.
+ By default all objects return `True` unless defined to return `False`.
 
 A few `built-ins` are always considered `False` by definition:
 
@@ -37,46 +43,56 @@ A few `built-ins` are always considered `False` by definition:
 - zero of any _numeric type_ (`int`, `float`, `complex`, `decimal`, or `fraction`)
 - empty _sequences_ and _collections_ (`str`, `list`, `set`, `tuple`, `dict`, `range(0)`)
 
+
 ```python
 >>>bool(None)
 False
 
 >>>bool(1)
 True
+
 >>>bool(0)
 False
 
 >>>bool([1,2,3])
 True
+
 >>>bool([])
 False
 
 >>>bool({"Pig" : 1, "Cow": 3})
 True
+
 >>>bool({})
 False
 ```
 
-When a object is used in a _boolean context_, it is evaluated transparently as _truthy_ or _falsey_ using `bool()`:
+When an object is used in a _boolean context_, it is evaluated transparently as _truthy_ or _falsey_ using `bool()`:
+
 
 ```python
-a = "is this true?"
-b = []
+>>> a = "is this true?"
+>>> b = []
 
 # This will print "True", as a non-empty string is considered a "truthy" value
-if a:
-  print("True")
+>>> if a:
+...  print("True")
 
 # This will print "False", as an empty list is considered a "falsey" value
-if not b:
-   print("False")
+>>> if not b:
+...   print("False")
 ```
 
+
 Classes may define how they are evaluated in truthy situations if they override and implement a `__bool__()` method, and/or a `__len__()` method.
 
+
 ## How Booleans work under the hood
 
-The `bool` type is implemented as a _sub-type_ of _int_. That means that `True` is _numerically equal_ to `1` and `False` is _numerically equal_ to `0`. This is observable when comparing them using an _equality operator_:
+The `bool` type is implemented as a _sub-type_ of _int_.
+ That means that `True` is _numerically equal_ to `1` and `False` is _numerically equal_ to `0`.
+  This is observable when comparing them using an _equality operator_:
+
 
 ```python
 >>>1 == True
@@ -86,7 +102,8 @@ True
 True
 ```
 
-However, `bools` are **still different** from `ints`, as noted when compairing using the _identity operator_:
+However, `bools` are **still different** from `ints`, as noted when comparing them using the _identity operator_, `is`:
+
 
 ```python
 >>>1 is True
@@ -96,25 +113,29 @@ False
 False
 ```
 
-> Note: in python >= 3.8, using a literal (such as 1, '', [], or {}) on the left side of `is` will raise a warning.
+> Note: in python >= 3.8, using a literal (such as 1, '', [], or {}) on the _left side_ of `is` will raise a warning.
+
+
+It is considered a [Python anti-pattern][comparing to true in the wrong way] to use the equality operator to compare a boolean variable to `True` or `False`.
+ Instead, the identity operator `is` should be used:
 
-It is considered a [Python anti-pattern][comparing to true in the wrong way] to use the equality operator to comaire a booleand variable to `True` or `False`. Instead, the identity operator `is` should be used:
 
 ```python
 
-flag = True
+>>> flag = True
 
 # Not "Pythonic"
-if flag == True:
-    print("This works, but it's not considered Pythonic.")
+>>> if flag == True:
+...    print("This works, but it's not considered Pythonic.")
 
 # A better way
-if flag:
-    print("Pythonistas prefer this pattern as more Pythonic.")
+>>> if flag:
+...    print("Pythonistas prefer this pattern as more Pythonic.")
 ```
 
+
 [bool-function]: https://docs.python.org/3/library/functions.html#bool
 [bool]: https://docs.python.org/3/library/stdtypes.html#truth
-[boolean-operators]: https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not
-[comparisons]: https://docs.python.org/3/library/stdtypes.html#comparisons
+[Boolean-operators]: https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not
 [comparing to true in the wrong way]: https://docs.quantifiedcode.com/python-anti-patterns/readability/comparison_to_true.html
+[comparisons]: https://docs.python.org/3/library/stdtypes.html#comparisons
diff --git a/concepts/bools/introduction.md b/concepts/bools/introduction.md
index 3d4e64bf..535f90be 100644
--- a/concepts/bools/introduction.md
+++ b/concepts/bools/introduction.md
@@ -1,21 +1,23 @@
 # Introduction
 
-Python represents true and false values with the `bool` type. There are only two values: `True` and `False`. These values can be bound to a variable:
+Python represents true and false values with the `bool` type.
+ There are only two values under that type: `True` and `False`.
+  These values can be bound to a variable:
 
 ```python
-true_variable = True
-false_variable = False
+>>> true_variable = True
+>>> false_variable = False
 ```
 
-We can evaluate boolean expressions using the `and`, `or`, and `not` operators.
+We can evaluate Boolean expressions using the `and`, `or`, and `not` operators.
 
 ```python
-true_variable = True and True
-false_variable = True and False
+>>> true_variable = True and True
+>>> false_variable = True and False
 
-true_variable = False or True
-false_variable = False or False
+>>> true_variable = False or True
+>>> false_variable = False or False
 
-true_variable = not False
-false_variable = not True
+>>> true_variable = not False
+>>> false_variable = not True
 ```
diff --git a/concepts/string-methods/.meta/config.json b/concepts/string-methods/.meta/config.json
index bce2ba2d..4bb37fcd 100644
--- a/concepts/string-methods/.meta/config.json
+++ b/concepts/string-methods/.meta/config.json
@@ -1,5 +1,5 @@
 {
-  "blurb": "The str class provides many useful methods that can be used to manipulate str types. These methods can be used for cleaning, splitting, translating, or otherwise working with any str object. Because str are immutable, any functions or methods that operate on a  str will return a new instance or copy of that str, instead of modifying the original.",
+  "blurb": "The 'str' class provides many useful 'string-methods'. They can be used for cleaning, splitting, translating, or otherwise working with any 'str' object. Because strings are immutable, any functions or methods that operate on a 'str' will return a new instance or copy of the 'str' rather than modifying the original 'str' object.",
   "authors": ["kimolivia"],
   "contributors": ["valentin-p", "bethanyg"]
 }
diff --git a/concepts/string-methods/about.md b/concepts/string-methods/about.md
index c4c15b99..4b068d31 100644
--- a/concepts/string-methods/about.md
+++ b/concepts/string-methods/about.md
@@ -1,27 +1,138 @@
-# String Methods in Python
+# String Methods
 
 A `str` is an [immutable sequence][text sequence] of [Unicode code points][unicode code points].
-These could include letters, diacritical marks, positioning characters, numbers, currecy symbols, emoji, punctuation, space and line break characters, and more.
+This may include letters, diacritical marks, positioning characters, numbers, currency symbols, emoji, punctuation, space and line breaks, and more.
 
-Strings implement all [common sequence operations][common sequence operations], and can be iterated through using `for item in <string>` or `for index, item in enumerate(<string>)` syntax.
-Strings can be concatenated with `+`, or via `<str>.join(<iterable>)`, split via `<str>.split(<separator>)`, and offer multiple types of formatting.
+Strings implement all [common sequence operations][common sequence operations] and can be iterated through using `for item in <str>` or `for index, item in enumerate(<str>)` syntax.
+ Individual code points (_strings of length 1_) can be referenced by `0-based index` number from the left, or `-1-based index` number from the right.
+  Strings can be concatenated with `+`, or via `<str>.join(<iterable>)`, split via `<str>.split(<separator>)`, and offer multiple formatting and assembly options.
 
-To further work with strings, Python provides a rich set of [string methods][str-methods] that can assist with searching, cleaning, transforming, translating, and many other operations.
+ To further work with strings, Python provides a rich set of [string methods][str-methods] for searching, cleaning, transforming, translating, and many other operations.
 
 Some of the more commonly used `str` methods include:
 
-- Checking for prefixes/suffixes with `startswith()` and `endswith()`
-- Altering string casing with methods like `upper()`, `lower()`, and `swapcase()`
-- Removing leading or trailing characters from a string using `strip()`, `lstrip()`, or `rstrip()`
-- Replacing substrings with the `replace()` method
-- Checking for the existence of a substring with `in`
+- Checking for prefixes/suffixes with `startswith(<substr>)` and `endswith(<substr>)`
+- Altering string casing with methods like `<str>.title()`, `<str>.upper()`/`<str>.lower()`, and `<str>.swapcase()`
+- Removing leading or trailing characters from a string using `<str>.strip(<chars>)`, `<str>.lstrip(<chars>)`, or `<str>.rstrip(<chars>)`
+- Replacing substrings with the `<str>.replace(<old>, <new>)` method
 
-The `str` type is _immutable_, so all of these methods will return a new `str` instead of modifying the existing one.
+Being _immutable_, a `str` object's value in memory cannot change; methods that appear to modify a string return a new copy or instance of that `str` object.
 
-For more information, you can check out the strings [informal tutorial][informal tutorial] or the [`str` docs][str-methods].
+[`<str>.endswith(<suffix>)`][str-endswith] returns `True` if the string ends with `<suffix>`, `False` otherwise.
 
+```python
+>>> 'My heart breaks. 💔'.endswith('💔')
+True
+
+>>> 'cheerfulness'.endswith('ness')
+True
+
+# Punctuation is part of the string, so needs to be included in any endswith match.
+>>> 'Do you want to 💃?'.endswith('💃')
+False
+
+>> 'The quick brown fox jumped over the lazy dog.'.endswith('dog')
+False
+```
+
+[`<str>.title()`][str-title] parses a string and capitalizes the first "character" of each "word" found.
+In Python, this is very dependent on the [language codec][codecs] used and how the particular language represents words and characters.
+There may also be [locale][locale] rules in place for a language or character set.
+
+
+```python
+>>> man_in_hat_th = 'ู้ชายในหมวก'
+>>> man_in_hat_ru = 'mужчина в шляпе'
+>>> man_in_hat_ko = '모자를 쓴 남자'
+>>> main_in_hat_en = 'the man in the hat.'
+
+>>> man_in_hat_th.title()
+'ผู้ชายในหมวก'
+
+>>> man_in_hat_ru.title()
+'Мужчина В Шляпе'
+
+>>> man_in_hat_ko.title()
+'모자를 쓴 남자'
+
+>> main_in_hat_en.title()
+'The Man In The Hat.'
+```
+
+
+[`<str>.strip(<chars>)`][str-strip] returns a copy of the `str` with leading and trailing `<chars>` removed.
+The code points specified in `<chars>` are not a prefix or suffix - **all combinations** of the code points will be removed starting from **both ends** of the string.
+ If nothing is specified for `<chars>`, all combinations of whitespace code points will be removed.
+ If only left-side or right-side removal is wanted, `<str>.lstrip(<chars>)` and `<str>.rstrip(<chars>)` can be used.
+
+
+ ```python
+# This will remove "https://", because it can be formed from "/stph:". 
+>>> 'https://unicode.org/emoji/'.strip('/stph:')
+'unicode.org/emoji'
+
+# Removal of all whitespace from both ends of the str.
+>>> '   🐪🐪🐪🌟🐪🐪🐪   '.strip()
+'🐪🐪🐪🌟🐪🐪🐪'
+
+>>> justification = 'оправдание'
+>>> justification.strip('еина')
+'оправд'
+
+# Prefix and suffix in one step.
+>>> 'unaddressed'.strip('dnue')
+'address'
+
+>>> '  unaddressed  '.strip('dnue ')
+'address'
+```
+
+
+[`<str>.replace(<substring>, <replacement substring>)`][str-replace] returns a copy of the string with all occurrences of `<substring>` replaced with `<replacement substring>`.
+
+
+The quote used below is from [The Hunting of the Snark][The Hunting of the Snark] by [Lewis Carroll][Lewis Carroll]
+
+```python
+# The Hunting of the Snark, by Lewis Carroll
+>>> quote = '''
+"Just the place for a Snark!" the Bellman cried,
+   As he landed his crew with care;
+Supporting each man on the top of the tide
+   By a finger entwined in his hair.
+
+"Just the place for a Snark! I have said it twice:
+   That alone should encourage the crew.
+Just the place for a Snark! I have said it thrice:
+   What I tell you three times is true."
+'''
+
+>>> quote.replace('Snark', '🐲')
+...
+'\n"Just the place for a 🐲!" the Bellman cried,\n   As he landed his crew with care;\nSupporting each man on the top of the tide\n   By a finger entwined in his hair.\n\n"Just the place for a 🐲! I have said it twice:\n   That alone should encourage the crew.\nJust the place for a 🐲! I have said it thrice:\n   What I tell you three times is true."\n'
+
+>>> 'bookkeeper'.replace('kk', 'k k')
+'book keeper'
+```
+
+
+For more examples and methods the [informal tutorial][informal tutorial] is a nice jumping-off point.
+[How to Unicode][howto unicode] in the Python docs offers great detail on Unicode, encoding, bytes, and other technical considerations for working with strings in Python.
+
+Python also supports regular expressions via the `re` module, which will be covered in a future exercise.
+
+
+[Lewis Carroll]: https://www.poetryfoundation.org/poets/lewis-carroll
+[The Hunting of the Snark]: https://www.poetryfoundation.org/poems/43909/the-hunting-of-the-snark
+[codecs]: https://docs.python.org/3/library/codecs.html
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
-[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
+[howto unicode]: https://docs.python.org/3/howto/unicode.html
 [informal tutorial]: https://docs.python.org/3/tutorial/introduction.html#strings
+[locale]: https://docs.python.org/3/library/locale.html#module-locale
+[str-endswith]: https://docs.python.org/3/library/stdtypes.html#str.endswith
 [str-methods]: https://docs.python.org/3/library/stdtypes.html#string-methods
+[str-replace]: https://docs.python.org/3/library/stdtypes.html#str.replace
+[str-strip]: https://docs.python.org/3/library/stdtypes.html#str.strip
+[str-title]: https://docs.python.org/3/library/stdtypes.html#str.title
+[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
diff --git a/concepts/string-methods/introduction.md b/concepts/string-methods/introduction.md
index d81c0339..e20e58e7 100644
--- a/concepts/string-methods/introduction.md
+++ b/concepts/string-methods/introduction.md
@@ -1,15 +1,15 @@
 # Introduction
 
 A `str` in Python is an [immutable sequence][text sequence] of [Unicode code points][unicode code points].
-These could include letters, diacritical marks, positioning characters, numbers, currecy symbols, emoji, punctuation, space and line break characters, and more.
+These may include letters, diacritical marks, positioning characters, numbers, currency symbols, emoji, punctuation, various spaces, line breaks, and more.
 
-Strings implement all [common sequence operations][common sequence operations], and can be iterated through using `for item in <string>` or `for index, item in enumerate(<string>)` syntax.
-Strings can be concatenated with `+`, or via `<str>.join()`, split via `<str>.split(<separator>)`, and offer multiple types of formatting.
-To further work with strings, Python provides a rich set of [string methods][str-methods] that can assist with searching, cleaning, transforming, translating, and many other operations.
+Strings implement all [common sequence operations][common sequence operations] and can be iterated through using `for item in <str>` or `for index, item in enumerate(<str>)` syntax.
+They can be concatenated with `+`, or via `<str>.join(<iterable>)`, split via `<str>.split(<separator>)`, and offer multiple formatting and assembly options.
 
-Being immutable, a `str` object's value in memory doesn't change; methods that appear to modify a string return a new copy or instance of `str`.
+To further work with strings, Python provides a rich set of [string methods][str-methods] that can assist with searching, cleaning, transforming, translating, and many other operations.
+Being _immutable_, a `str` object's value in memory doesn't change; methods that appear to modify a string return a new copy or instance of that `str` object.
 
-[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
 [str-methods]: https://docs.python.org/3/library/stdtypes.html#string-methods
+[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
diff --git a/concepts/string-methods/links.json b/concepts/string-methods/links.json
index d13894c1..2e6fc846 100644
--- a/concepts/string-methods/links.json
+++ b/concepts/string-methods/links.json
@@ -14,9 +14,5 @@
   {
     "url": "https://www.programiz.com/python-programming/string",
     "description": "more string operations and functions"
-  },
-  {
-    "url": "https://realpython.com/python-string-formatting/",
-    "description": "string formatting best practices"
   }
 ]
diff --git a/concepts/strings/about.md b/concepts/strings/about.md
index c4d4f8f0..e9da2423 100644
--- a/concepts/strings/about.md
+++ b/concepts/strings/about.md
@@ -1,10 +1,16 @@
 # About
 
 A `str` in Python is an [immutable sequence][text sequence] of [Unicode code points][unicode code points].
-These could include letters, diacritical marks, positioning characters, numbers, currecy symbols, emoji, punctuation, space and line break characters, and more.
-Being immutable, a `str` object's value in memory doesn't change; methods that appear to modify a string return a new copy or instance of `str`.
+These may include letters, diacritical marks, positioning characters, numbers, currency symbols, emoji, punctuation, space and line break characters, and more.
+
+For a deep dive on what information a string encodes (or, _"how does a computer know how to translate zeroes and ones into letters?"_), [this blog post is enduringly helpful][joel-on-text].
+The Python docs also provide a very detailed [unicode HOWTO][unicode how-to] that discusses Pythons support for the Unicode specification in the `str`, `bytes` and `re` modules, considerations for locales, and some common issues with encoding and translation.
+
+Strings implement all [common sequence operations][common sequence operations] and can be iterated through using `for item in <str>` or `for index, item in enumerate(<str>)` syntax.
+ Individual code points (_strings of length 1_) can be referenced by `0-based index` number from the left, or `-1-based index` number from the right.
+
+Strings can be concatenated with `+`, or via `<str>.join(<iterable>)`, split via `<str>.split(<separator>)`, and offer multiple formatting and assembly options.
 
-For a deep dive on what information a string encodes (or, _"how does the computer know how to translate zeroes and ones into letters?"_), [this blog post is enduringly helpful][joel-on-text]. Additionally, the docs provide a [unicode HOWTO][unicode how-to] that discusses Pythons support for the Unicode specification in the `str`, `bytes` and `re` modules, and some common issues.
 
 A `str` literal can be declared via single `'` or double `"` quotes. The escape `\` character is available as needed.
 
@@ -16,19 +22,18 @@ A `str` literal can be declared via single `'` or double `"` quotes. The escape
 ```
 
 
-Muliti-line strings are declared with `'''` or `"""`.
+Multi-line strings are declared with `'''` or `"""`.
 
 ```python
->>> triple_quoted =  '''Three single quotes or "double quotes" in a row allow for multi-line string literals.
-  Line break characters, tabs and other whitespace is fully supported.
-
-  You\'ll most often encounter these as "doc strings" or "doc tests" written just below the first line of a function or class definition.
+>>> triple_quoted = '''Three single quotes or "double quotes" in a row allow for multi-line string literals.
+  Line break characters, tabs and other whitespace is fully supported. Remember - The escape "\" character is also available if needed (as can be seen below). 
+  
+  You\'ll most often encounter multi-line strings as "doc strings" or "doc tests" written just below the first line of a function or class definition.
     They\'re often used with auto documentation ✍ tools.
     '''
 ```
 
-
-The [`str()` constructor][str-constructor] can be used to create/coerce strings from other objects:
+The [`str(<object>)` constructor][str-constructor] can be used to create/coerce strings from other objects:
 
 ```python
 >>> my_number = 42
@@ -37,8 +42,9 @@ The [`str()` constructor][str-constructor] can be used to create/coerce strings
 "42"
 ```
 
-While the `str()` constructor can be used to coerce strings from other objects, it _**will not iterate**_ through an object.
-This lack of iteration can have surprising results.
+While the `str(<object>)` constructor can be used to coerce/convert strings, it _**will not iterate**_ or unpack an object.
+This is different from the behavior of constructors for other data types such as `list()`, `set()`, `dict()`, or `tuple()`, and can have surprising results.
+
 
 ```python
 >>> numbers = [1,3,5,7]
@@ -48,7 +54,7 @@ This lack of iteration can have surprising results.
 ```
 
 
-Code points within a `str` can be referenced by 0-based index number from the right:
+Code points within a `str` can be referenced by `0-based index` number from the left:
 
 ```python
 creative = '창의적인'
@@ -64,7 +70,7 @@ creative = '창의적인'
 
 ```
 
-Indexing also works from the left, starting with `-1`:
+Indexing also works from the right, starting with a `-1-based index`:
 
 ```python
 creative = '창의적인'
@@ -80,7 +86,7 @@ creative = '창의적인'
 
 ```
 
-There is no separate “character” or "rune" type in Python, so indexing a string produces a new `str` of length 1:
+There is no separate “character” or "rune" type in Python, so indexing a string produces a new `str` of **length 1**:
 
 ```python
 
@@ -95,7 +101,6 @@ There is no separate “character” or "rune" type in Python, so indexing a str
 True
 ```
 
-
 Substrings can be selected via _slice notation_, using [`<str>[<start>:stop:<step>]`][common sequence operations] to produce a new string.
 Results exclude the `stop` index.
 If no `start` is given, the starting index will be 0.
@@ -121,7 +126,6 @@ moon_and_stars = '🌟🌟🌙🌟🌟⭐'
 '🌟🌟🌙'
 ```
 
-
 Strings can also be broken into smaller strings via [`<str>.split(<separator>)`][str-split], which will return a `list` of substrings.
 Using `<str>.split()` without any arguments will split the string on whitespace.
 
@@ -149,7 +153,6 @@ yellow"""
 ['red', 'orange', 'green', 'purple', 'yellow']
 ```
 
-
 Strings can be concatenated using the `+` operator.
 This method should be used sparingly, as it is not very performant or easily maintained.
 
@@ -165,9 +168,9 @@ sentence = word + " " + "means" + " " + number + " in " + language + "."
 "девять means nine in Ukrainian."
 ```
 
-
 If a `list`, `tuple`, `set` or other collection of individual strings needs to be combined into a single `str`, [`<str>.join(<iterable>)`][str-join], is a better option:
 
+
 ```python
 # str.join() makes a new string from the iterables elements.
 >>> chickens = ["hen", "egg", "rooster"]
@@ -184,13 +187,14 @@ If a `list`, `tuple`, `set` or other collection of individual strings needs to b
 
 Strings support all [common sequence operations][common sequence operations].
 Individual code points can be iterated through in a loop via `for item in <str>`.
-Indexes _with_ items can be iterated through in a loop via `for index, item in enumerate(<str>)`
+Indexes _with_ items can be iterated through in a loop via `for index, item in enumerate(<str>)`.
+
 
 ```python
 
 >>> exercise = 'လေ့ကျင့်'
 
-# Note that there are more code points than percieved glyphs or characters
+# Note that there are more code points than perceived glyphs or characters
 >>> for code_point in exercise:
 ...    print(code_point)
 ...
@@ -217,35 +221,42 @@ Indexes _with_ items can be iterated through in a loop via `for index, item in e
 7 :  ့
 ```
 
+
 ## String Methods
 
-To manipulate strings, Python provides a rich set of [string methods][str-methods] that can assist with searching, cleaning, splitting, transforming, translating, and many other operations.
+Python provides a rich set of [string methods][str-methods] that can assist with searching, cleaning, splitting, transforming, translating, and many other operations.
+A selection of these methods are covered in another exercise.
 
 
 ## Formatting
 
-Python also provides a rich set of tools for [formatting][str-formatting] and [templating][template-strings] strings, as well as more sophisticated text processing through the [re (_regular expressions_)][re], [difflib (_sequence comparison_)][difflib], and [textwrap][textwrap] modules. For a great introduction to string formatting in Python, see [this post at Real Python][real python string formatting]. For more details on string methods, see [Strings and Character Data in Python][strings and characters] at the same site.
+Python also provides a rich set of tools for [formatting][str-formatting] and [templating][template-strings] strings, as well as more sophisticated text processing through the [re (_regular expressions_)][re], [difflib (_sequence comparison_)][difflib], and [textwrap][textwrap] modules.
+For a great introduction to string formatting in Python, see [this post at Real Python][real python string formatting].
+ For an introduction to string methods, see [Strings and Character Data in Python][strings and characters] at the same site.
+
 
 ## Related types and encodings
 
-In addition to `str` (a _text_ sequence), Python has corresponding [binary sequence types][binary sequence types] summarized under [binary data services][binary data services] -- `bytes` (a _binary_ sequence), `bytearray`, and `memoryview` for the efficient storage and handling of binary data. Additionally, [Streams][streams] allow sending and receiving binary data over a network connection without using callbacks.
+In addition to `str` (a _text_ sequence), Python has corresponding [binary sequence types][binary sequence types] summarized under [binary data services][binary data services] -- `bytes` (a _binary_ sequence), `bytearray`, and `memoryview` for the efficient storage and handling of binary data.
+Additionally, [Streams][streams] allow sending and receiving binary data over a network connection without using callbacks.
 
-[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
+
+[binary data services]: https://docs.python.org/3/library/binary.html#binaryservices
+[binary sequence types]: https://docs.python.org/3/library/stdtypes.html#binaryseq
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
+[difflib]: https://docs.python.org/3/library/difflib.html
 [joel-on-text]: https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/
-[str-methods]: https://docs.python.org/3/library/stdtypes.html#string-methods
+[re]: https://docs.python.org/3/library/re.html
+[real python string formatting]: https://realpython.com/python-string-formatting/
 [str-constructor]: https://docs.python.org/3/library/stdtypes.html#str
 [str-formatting]: https://docs.python.org/3/library/string.html#custom-string-formatting
+[str-join]: https://docs.python.org/3/library/stdtypes.html#str.join
+[str-methods]: https://docs.python.org/3/library/stdtypes.html#string-methods
+[str-split]: https://docs.python.org/3/library/stdtypes.html#str.split
+[streams]: https://docs.python.org/3/library/asyncio-stream.html#streams
+[strings and characters]: https://realpython.com/python-strings/
 [template-strings]: https://docs.python.org/3/library/string.html#template-strings
-[re]: https://docs.python.org/3/library/re.html
-[difflib]: https://docs.python.org/3/library/difflib.html
+[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
 [textwrap]: https://docs.python.org/3/library/textwrap.html
-[real python string formatting]: https://realpython.com/python-string-formatting/
-[strings and characters]: https://realpython.com/python-strings/
-[binary sequence types]: https://docs.python.org/3/library/stdtypes.html#binaryseq
-[streams]: https://docs.python.org/3/library/asyncio-stream.html#streams
+[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
 [unicode how-to]: https://docs.python.org/3/howto/unicode.html
-[str-split]: https://docs.python.org/3/library/stdtypes.html#str.split
-[binary data services]: https://docs.python.org/3/library/binary.html#binaryservices
-[str-join]: https://docs.python.org/3/library/stdtypes.html#str.join
diff --git a/concepts/strings/introduction.md b/concepts/strings/introduction.md
index f22096df..61b5fbd5 100644
--- a/concepts/strings/introduction.md
+++ b/concepts/strings/introduction.md
@@ -1,17 +1,20 @@
 # Introduction
 
 A `str` in Python is an [immutable sequence][text sequence] of [Unicode code points][unicode code points].
-These could include letters, diacritical marks, positioning characters, numbers, currecy symbols, emoji, punctuation, space and line break characters, and more.
+These could include letters, diacritical marks, positioning characters, numbers, currency symbols, emoji, punctuation, space and line break characters, and more.
 
 Strings implement all [common sequence operations][common sequence operations], and can be iterated through using `for item in <string>` or `for index, item in enumerate(<string>)` syntax.
+
 Strings can be concatenated with `+`, or via `<str>.join()`, split via `<str>.split(<separator>)`, and offer multiple types of formatting, interpolation, and templating.
 
 Being immutable, a `str` object's value in memory doesn't change; methods that appear to modify a string return a new copy or instance of `str`.
 
-For a deep dive on what information a string encodes (or, _"how does the computer know how to translate zeroes and ones into letters?"_), [this blog post is enduringly helpful][joel-on-text]. Additionally, the docs provide a [unicode HOWTO][unicode how-to] that discusses Pythons support for the Unicode specification in the `str`, `bytes` and `re` modules, and some common issues.
+For a deep dive on what information a string encodes (or, _"how does a computer know how to translate zeroes and ones into letters?"_), [this blog post is enduringly helpful][joel-on-text].
+The Python docs also provide a very detailed [unicode HOWTO][unicode how-to] that discusses Pythons support for the Unicode specification in the `str`, `bytes` and `re` modules, considerations for locales, and some common issues with encoding and translation.
+
 
+[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
 [joel-on-text]: https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/
 [text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
 [unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
 [unicode how-to]: https://docs.python.org/3/howto/unicode.html
-[common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
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/ghost-gobble-arcade-game/.docs/hints.md b/exercises/concept/ghost-gobble-arcade-game/.docs/hints.md
index 8b57aeb6..6859b17f 100644
--- a/exercises/concept/ghost-gobble-arcade-game/.docs/hints.md
+++ b/exercises/concept/ghost-gobble-arcade-game/.docs/hints.md
@@ -2,23 +2,24 @@
 
 ## General
 
-- Don't worry about how the arguments are derived, just focus on combining the arguments to return the intended result.
+- Don't worry about how the arguments are _derived_, focus on combining the arguments to return the intended result.
 
 ## 1. Define if Pac-Man can eat a ghost
 
-- You can use the [boolean][boolean] [operators][boolean-operators] to combine the arguments for a result.
+- You can use the [Boolean][boolean] [operators][Boolean-operators] to combine arguments for a result.
 
 ## 2. Define if Pac-Man scores
 
-- You can use the [boolean][boolean] [operator][boolean-operators] to combine the arguments for a result.
+- You can use the [Boolean][boolean] [operator][Boolean-operators] to combine arguments for a result.
 
 ## 3. Define if Pac-Man loses
 
-- You can use the [boolean][boolean] [operator][boolean-operators] to combine the arguments for a result.
+- You can use the [boolean][Boolean] [operator][Boolean-operators] to combine arguments for a result.
 
 ## 4. Define if Pac-Man wins
 
-- You can use the [boolean][boolean] [operator][boolean-operators] to combine the arguments for a result.
+- You can use the [Boolean][boolean] [operator][Boolean-operators] to combine arguments for a result.
 
 [boolean]: https://docs.python.org/3/library/stdtypes.html#truth
-[boolean-operators]: https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not
+[Boolean-operators]: https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not
+
diff --git a/exercises/concept/ghost-gobble-arcade-game/.docs/instructions.md b/exercises/concept/ghost-gobble-arcade-game/.docs/instructions.md
index 023f40cd..4b748395 100644
--- a/exercises/concept/ghost-gobble-arcade-game/.docs/instructions.md
+++ b/exercises/concept/ghost-gobble-arcade-game/.docs/instructions.md
@@ -1,43 +1,53 @@
 # Instructions
 
-In this exercise, you need to implement some rules from [Pac-Man, the classic arcade-game](https://en.wikipedia.org/wiki/Pac-Man).
+In this exercise, you need to implement some rules from [Pac-Man][Pac-Man], the classic 1980s-era arcade-game.
 
 You have four rules to implement, all related to the game states.
 
-> Don't worry about how the arguments are derived, just focus on combining the arguments to return the intended result.
+> _Do not worry about how the arguments are derived, just focus on combining the arguments to return the intended result._
 
 ## 1. Define if Pac-Man eats a ghost
 
-Define the `eat_ghost()` function that takes two parameters (_if Pac-Man has a power pellet active_ and _if Pac-Man is touching a ghost_) and returns a boolean value if Pac-Man is able to eat the ghost. The function should return `True` only if Pac-Man has a power pellet active and is touching a ghost.
+Define the `eat_ghost()` function that takes two parameters (_if Pac-Man has a power pellet active_ and _if Pac-Man is touching a ghost_) and returns a Boolean value if Pac-Man is able to eat the ghost.
+ The function should return `True` only if Pac-Man has a power pellet active and is touching a ghost.
 
 ```python
-eat_ghost(False, True)
-# => False
+>>> eat_ghost(False, True)
+...
+False
 ```
 
 ## 2. Define if Pac-Man scores
 
-Define the `score()` function that takes two parameters (_if Pac-Man is touching a power pellet_ and _if Pac-Man is touching a dot_) and returns a boolean value if Pac-Man scored. The function should return `True` if Pac-Man is touching a power pellet or a dot.
+Define the `score()` function that takes two parameters (_if Pac-Man is touching a power pellet_ and _if Pac-Man is touching a dot_) and returns a Boolean value if Pac-Man scored.
+ The function should return `True` if Pac-Man is touching a power pellet or a dot.
 
 ```python
-score(True, True)
-# => True
+>>> score(True, True)
+...
+True
 ```
 
 ## 3. Define if Pac-Man loses
 
-Define the `lose()` function that takes two parameters (_if Pac-Man has a power pellet active_ and _if Pac-Man is touching a ghost_) and returns a boolean value if Pac-Man loses. The function should return `True` if Pac-Man is touching a ghost and does not have a power pellet active.
+Define the `lose()` function that takes two parameters (_if Pac-Man has a power pellet active_ and _if Pac-Man is touching a ghost_) and returns a Boolean value if Pac-Man loses.
+ The function should return `True` if Pac-Man is touching a ghost and does not have a power pellet active.
 
 ```python
-lose(False, True)
-# => True
+>>> lose(False, True)
+...
+True
 ```
 
 ## 4. Define if Pac-Man wins
 
-Define the `win()` function that takes three parameters (_if Pac-Man has eaten all of the dots_, _if Pac-Man has a power pellet active_, and _if Pac-Man is touching a ghost_) and returns a boolean value if Pac-Man wins. The function should return `True` if Pac-Man has eaten all of the dots and has not lost based on the parameters defined in part 3.
+Define the `win()` function that takes three parameters (_if Pac-Man has eaten all of the dots_, _if Pac-Man has a power pellet active_, and _if Pac-Man is touching a ghost_) and returns a Boolean value if Pac-Man wins.
+ The function should return `True` if Pac-Man has eaten all of the dots and has not lost based on the parameters defined in part 3.
 
 ```python
-win(False, True, False)
-# => False
+>>> win(False, True, False)
+...
+False
 ```
+
+[Pac-Man]: https://en.wikipedia.org/wiki/Pac-Man
diff --git a/exercises/concept/ghost-gobble-arcade-game/.docs/introduction.md b/exercises/concept/ghost-gobble-arcade-game/.docs/introduction.md
index 3d4e64bf..cf09a2ce 100644
--- a/exercises/concept/ghost-gobble-arcade-game/.docs/introduction.md
+++ b/exercises/concept/ghost-gobble-arcade-game/.docs/introduction.md
@@ -1,21 +1,23 @@
 # Introduction
 
-Python represents true and false values with the `bool` type. There are only two values: `True` and `False`. These values can be bound to a variable:
+Python represents true and false values with the `bool` type.
+ There are only two values in this type: `True` and `False`.
+  These values can be bound to a variable:
 
 ```python
-true_variable = True
-false_variable = False
+>>> true_variable = True
+>>> false_variable = False
 ```
 
-We can evaluate boolean expressions using the `and`, `or`, and `not` operators.
+We can evaluate Boolean expressions using the `and`, `or`, and `not` operators:
 
 ```python
-true_variable = True and True
-false_variable = True and False
+>>> true_variable = True and True
+>>> false_variable = True and False
 
-true_variable = False or True
-false_variable = False or False
+>>> true_variable = False or True
+>>> false_variable = False or False
 
-true_variable = not False
-false_variable = not True
+>>> true_variable = not False
+>>> false_variable = not True
 ```
diff --git a/exercises/concept/ghost-gobble-arcade-game/.meta/config.json b/exercises/concept/ghost-gobble-arcade-game/.meta/config.json
index 28951110..a304f1f6 100644
--- a/exercises/concept/ghost-gobble-arcade-game/.meta/config.json
+++ b/exercises/concept/ghost-gobble-arcade-game/.meta/config.json
@@ -2,7 +2,7 @@
   "blurb": "Learn about bools by setting up the rules for the Ghost Gobble arcade game.",
   "icon": "matching-brackets",
   "authors": ["neenjaw"],
-  "contributors": ["cmccandless"],
+  "contributors": ["cmccandless", "bethanyg"],
   "files": {
     "solution": ["arcade_game.py"],
     "test": ["arcade_game_test.py"],
diff --git a/exercises/concept/ghost-gobble-arcade-game/.meta/design.md b/exercises/concept/ghost-gobble-arcade-game/.meta/design.md
index 544244bb..420f66a7 100644
--- a/exercises/concept/ghost-gobble-arcade-game/.meta/design.md
+++ b/exercises/concept/ghost-gobble-arcade-game/.meta/design.md
@@ -2,18 +2,18 @@
 
 ## Goal
 
-The goal of this exercise is to teach the student how [`bool`](https://github.com/exercism/v3/blob/master/languages/python/reference/concepts/builtin_types/bool.md) is implemented and used in Python. We will teach the `bool` type by showing the student how to use it.
+The goal of this exercise is to teach the student how [`bool`][bools] is implemented and used in Python. We will teach the `bool` type by showing the student how to use it.
 
 ## Learning objectives
 
 - create a `bool` object via literal declaration
-- obtain a `bool` object from using [logical operators](https://docs.python.org/3/reference/expressions.html#boolean-operations) (`and`, `or`, `not`)
+- obtain a `bool` object from using [logical operators][logical operators] (`and`, `or`, `not`)
 
 ## Out of scope
 
-- obtain a `bool` object from [comparison operators](https://docs.python.org/3/reference/expressions.html#value-comparisons) (`>`, `<`, `==`)
-- obtain a `bool` object from [membership operators](https://docs.python.org/3/reference/expressions.html#membership-test-operations) (`in`, `not in`)
-- obtain a `bool` object from [identity operators](https://docs.python.org/3/reference/expressions.html#is-not) (`is`, `is not`)
+- obtain a `bool` object from [comparison operators][comparison operators] (`>`, `<`, `==`)
+- obtain a `bool` object from [membership operators][membership operators] (`in`, `not in`)
+- obtain a `bool` object from [identity operators][identity operators] (`is`, `is not`)
 - 'truthyness' and 'falsyness'
   - create a `bool` object from other objects (`collections`, `integers`, `strings`) with the the `bool()` constructor.
 - catching/raising Exceptions
@@ -32,7 +32,18 @@ The goal of this exercise is to teach the student how [`bool`](https://github.co
 
 ## Resources
 
-- [Boolean Operations — and, or, not](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)
-- [Built-in Functions - bool](https://docs.python.org/3/library/functions.html#bool)
-- [Truth Value Testing](https://docs.python.org/3/library/stdtypes.html#truth)
-- [Comparisons](https://docs.python.org/3/library/stdtypes.html#comparisons)
+- [Boolean Operations — and, or, not][Boolean Operations — and, or, not]
+- [Built-in Functions - bool][Built-in Functions - bool]
+- [Truth Value Testing][Truth Value Testing]
+- [Comparisons][Comparisons]
+
+
+[Boolean Operations — and, or, not]: https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not
+[Built-in Functions - bool]: https://docs.python.org/3/library/functions.html#bool
+[Comparisons]: https://docs.python.org/3/library/stdtypes.html#comparisons
+[Truth Value Testing]: https://docs.python.org/3/library/stdtypes.html#truth
+[bools]: https://github.com/exercism/v3/blob/master/languages/python/reference/concepts/builtin_types/bool.md
+[comparison operators]: https://docs.python.org/3/reference/expressions.html#value-comparisons
+[identity operators]: https://docs.python.org/3/reference/expressions.html#is-not
+[logical operators]: https://docs.python.org/3/reference/expressions.html#boolean-operations
+[membership operators]: https://docs.python.org/3/reference/expressions.html#membership-test-operations
diff --git a/exercises/concept/ghost-gobble-arcade-game/arcade_game.py b/exercises/concept/ghost-gobble-arcade-game/arcade_game.py
index 3b6b3515..152356f2 100644
--- a/exercises/concept/ghost-gobble-arcade-game/arcade_game.py
+++ b/exercises/concept/ghost-gobble-arcade-game/arcade_game.py
@@ -1,12 +1,38 @@
 def eat_ghost(power_pellet_active, touching_ghost):
+    '''
+
+    :param power_pellet_active: bool - does the player have an active power pellet?
+    :param touching_ghost:  bool - is the player touching a ghost?
+    :return: bool
+    '''
     pass
 
 def score(touching_power_pellet, touching_dot):
+    '''
+
+    :param touching_power_pellet: bool - does the player have an active power pellet?
+    :param touching_dot:  bool - is the player touching a dot?
+    :return: bool
+    '''
     pass
 
 def lose(power_pellet_active, touching_ghost):
+    '''
+
+    :param power_pellet_active: bool - does the player have an active power pellet?
+    :param touching_ghost: bool - is the player touching a ghost?
+    :return: bool
+    '''
     pass
 
 def win(has_eaten_all_dots, power_pellet_active, touching_ghost):
+    '''
+
+    :param has_eaten_all_dots: bool - has the player "eaten" all the dots?
+    :param power_pellet_active: bool - does the player have an active power pellet?
+    :param touching_ghost:  bool - is the player touching a ghost?
+    :return: bool
+    '''
     pass
 
+
diff --git a/exercises/concept/little-sisters-essay/.docs/instructions.md b/exercises/concept/little-sisters-essay/.docs/instructions.md
index 0da803e1..77613513 100644
--- a/exercises/concept/little-sisters-essay/.docs/instructions.md
+++ b/exercises/concept/little-sisters-essay/.docs/instructions.md
@@ -6,7 +6,10 @@ You have four tasks to clean up and modify strings.
 
 ## 1. Capitalize the title of the paper
 
-Any good paper needs a properly formatted title. Implement the function `capitalize_title()` which takes `title` as a parameter, and capitalizes the first letter of each word of the title. This function will return a `str`.
+Any good paper needs a properly formatted title.
+Implement the function `capitalize_title(<title>)` which takes a title `str` as a parameter and capitalizes the first letter of each word.
+This function should return a `str` in title case.
+
 
 ```python
 >>> capitalize_title("my hobbies")
@@ -15,7 +18,9 @@ Any good paper needs a properly formatted title. Implement the function `capital
 
 ## 2. Check if each sentence ends with a period
 
-You want to make sure that the punctuation in the paper is perfect. Implement the function `check_sentence_ending()` that takes `sentence` as a parameter. This function should return a `bool`.
+You want to make sure that the punctuation in the paper is perfect.
+Implement the function `check_sentence_ending()` that takes `sentence` as a parameter. This function should return a `bool`.
+
 
 ```python
 >>> check_sentence_ending("I like to hike, bake, and read.")
@@ -25,9 +30,10 @@ True
 ## 3. Clean up spacing
 
 To make the paper look professional, unnecessary spacing needs to be removed.
-Implement the function `clean_up_spacing()` that takes  `sentence` as a parameter.  
+Implement the function `clean_up_spacing()` that takes  `sentence` as a parameter.
 The function should remove extra whitespace at both the beginning and the end of the sentence, returning a new, updated sentence `str`.
 
+
 ```python
 >>> clean_up_spacing(" I like to go on hikes with my dog.  ")
 "I like to go on hikes with my dog."
@@ -35,10 +41,13 @@ The function should remove extra whitespace at both the beginning and the end of
 
 ## 4. Replace words with a synonym
 
-To make the paper _even better_, you can replace some of the adjectives with synonyms. Write the function `replace_word_choice()` that takes `sentence`, `old_word`, and `new_word` as parameters.
+To make the paper _even better_, you can replace some of the adjectives with their synonyms.
+Write the function `replace_word_choice()` that takes `sentence`, `old_word`, and `new_word` as parameters.
 This function should replace all instances of the `old_word` with the `new_word`, and return a new `str` with the updated sentence.
 
+
 ```python
 >>> replace_word_choice("I bake good cakes.", "good", "amazing")
 "I bake amazing cakes."
 ```
+
diff --git a/exercises/concept/little-sisters-essay/.docs/introduction.md b/exercises/concept/little-sisters-essay/.docs/introduction.md
index c527df88..1b0e9531 100644
--- a/exercises/concept/little-sisters-essay/.docs/introduction.md
+++ b/exercises/concept/little-sisters-essay/.docs/introduction.md
@@ -3,16 +3,22 @@
 The `str` class offers [many useful methods][str methods] for working with and composing strings.
 These include searching, cleaning, splitting, transforming, translating, and many other techniques.
 
-Strings are [immutable sequences][text sequence] of [Unicode code points][unicode code points] (_for more details, see [HOWTO Unicode][howto unicode] in the Python Docs._) -- individual "characters" or code points (_strings of length 1_) can be referenced by `0-based index` number from the left, or `-1-based index` number from the right.
+Strings are [immutable sequences][text sequence] of [Unicode code points][unicode code points] -- individual "characters" or code points (_strings of length 1_) can be referenced by `0-based index` number from the left, or `-1-based index` number from the right.
 
-Strings can be iterated through using `for item in <string>` or `for item in enumerate(<string>)` syntax.
-They can be concatenated using the `+` operator or with the `<string>.join()` method, and also implement all [common sequence operations][common sequence operations].
+Strings can be iterated through using `for item in <str>` or `for index, item in enumerate(<str>)` syntax.
+They can be concatenated using the `+` operator or via `<string>.join(<iterable>)` and implement all [common sequence operations][common sequence operations].
 
-Strings are immutable, meaning the value of a `str` object in memory cannot change.
-Functions or methods that operate on a `str` (_like the ones we are learning about here_) will return a _new instance_ of that `str` instead of modifying the original `str` object.
+Strings are _immutable_, meaning the value of a `str` object in memory cannot change.
+Functions or methods that operate on a `str` (_like the ones we are learning about here_) will return a new `instance` of that `str` object instead of modifying the original `str`.
 
+Following is a small selection of Python string methods.
+For a complete list, see the [str class][str methods] in the Python docs.
+
+
+[`<str>.title()`][str-title] parses a string and capitalizes the first "character" of each "word" found.
+In Python, this is very dependent on the [language codec][codecs] used and how the particular language represents words and characters.
+There may also be [locale][locale] rules in place for a language or character set.
 
-[`<str>.title()`][str-title] parses a string and capitalizes the first "character" of each "word" found.  In Python, this is very dependant on the [language codec][codecs] used, and how the particular language represents words and characters.  There may also be [locale][locale] rules in place.
 
 ```python
 man_in_hat_th = 'ู้ชายในหมวก'
@@ -33,7 +39,8 @@ main_in_hat_en = 'the man in the hat.'
 'The Man In The Hat.'
 ```
 
-[`<str>`.endswith(<suffix>)][str-endswith] returns `True` if the string ends with `<suffix>`, `False` otherwise.
+[`<str>.endswith(<suffix>)`][str-endswith] returns `True` if the string ends with `<suffix>`, `False` otherwise.
+
 
 ```python
 >>> 'My heart breaks. 💔'.endswith('💔')
@@ -42,6 +49,7 @@ True
 >>> 'cheerfulness'.endswith('ness')
 True
 
+# Punctuation is part of the string, so needs to be included in any endswith match.
 >>> 'Do you want to 💃?'.endswith('💃')
 False
 
@@ -49,14 +57,17 @@ False
 False
 ```
 
-[`<str>`.strip(<chars>)][str-strip] returns a copy of the `str` with leading and trailing `<chars>` removed.
-The code points specified in `<chars>` are not a prefix or suffix - all combinations of the code points will be removed starting from both ends of the string.
- If nothing is specified for `<chars>`, all combinations of whitespace will be removed.
+[`<str>.strip(<chars>)`][str-strip] returns a copy of the `str` with leading and trailing `<chars>` removed.
+The code points specified in `<chars>` are not a prefix or suffix - **all combinations** of the code points will be removed starting from **both ends** of the string.
+ If nothing is specified for `<chars>`, all combinations of whitespace code points will be removed.
+
 
  ```python
- >>> 'https://unicode.org/emoji/'.strip('/stph:')
+# This will remove "https://", because it can be formed from "/stph:". 
+>>> 'https://unicode.org/emoji/'.strip('/stph:')
 'unicode.org/emoji'
 
+# Removal of all whitespace from both ends of the str.
 >>> '   🐪🐪🐪🌟🐪🐪🐪   '.strip()
 '🐪🐪🐪🌟🐪🐪🐪'
 
@@ -64,6 +75,7 @@ The code points specified in `<chars>` are not a prefix or suffix - all combinat
 >>> justification.strip('еина')
 'оправд'
 
+# Prefix and suffix in one step.
 >>> 'unaddressed'.strip('dnue')
 'address'
 
@@ -71,10 +83,13 @@ The code points specified in `<chars>` are not a prefix or suffix - all combinat
 'address'
 ```
 
-[`<str>.replace(<substring>, <replacement substring>)`][str-replace] returns a copy of the string with all occurences of `<substring>` replaced with `<replacement substring>`.
+
+[`<str>.replace(<substring>, <replacement substring>)`][str-replace] returns a copy of the string with all occurrences of `<substring>` replaced with `<replacement substring>`.
+
+The quote used below is from [The Hunting of the Snark][The Hunting of the Snark] by [Lewis Carroll][Lewis Carroll]
 
 ```python
-# Quote from The Hunting of the Snark, by Lewis Carroll
+# The Hunting of the Snark, by Lewis Carroll
 >>> quote = '''
 "Just the place for a Snark!" the Bellman cried,
    As he landed his crew with care;
@@ -95,14 +110,15 @@ Just the place for a Snark! I have said it thrice:
 'book keeper'
 ```
 
-[str methods]: https://docs.python.org/3/library/stdtypes.html#string-methods
-[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
+[Lewis Carroll]: https://www.poetryfoundation.org/poets/lewis-carroll
+[The Hunting of the Snark]: https://www.poetryfoundation.org/poems/43909/the-hunting-of-the-snark
+[codecs]: https://docs.python.org/3/library/codecs.html
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[str-title]: https://docs.python.org/3/library/stdtypes.html#str.title
+[locale]: https://docs.python.org/3/library/locale.html#module-locale
+[str methods]: https://docs.python.org/3/library/stdtypes.html#string-methods
 [str-endswith]: https://docs.python.org/3/library/stdtypes.html#str.endswith
-[str-strip]: https://docs.python.org/3/library/stdtypes.html#str.strip
 [str-replace]: https://docs.python.org/3/library/stdtypes.html#str.replace
-[codecs]: https://docs.python.org/3/library/codecs.html
-[locale]: https://docs.python.org/3/library/locale.html#module-locale
-[howto unicode]: https://docs.python.org/3/howto/unicode.html
+[str-strip]: https://docs.python.org/3/library/stdtypes.html#str.strip
+[str-title]: https://docs.python.org/3/library/stdtypes.html#str.title
+[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
diff --git a/exercises/concept/little-sisters-essay/.meta/exemplar.py b/exercises/concept/little-sisters-essay/.meta/exemplar.py
index 7a208fab..8335a3db 100644
--- a/exercises/concept/little-sisters-essay/.meta/exemplar.py
+++ b/exercises/concept/little-sisters-essay/.meta/exemplar.py
@@ -1,13 +1,35 @@
 def capitalize_title(title):
+    '''
+
+    :param title: str title string that needs title casing
+    :return:  str title string in title case (first letters capitalized)
+    '''
     return title.title()
 
 def check_sentence_ending(sentence):
+    '''
+
+    :param sentence: str a sentence to check.
+    :return:  bool True if punctuated correctly with period, False otherwise.
+    '''
     return sentence.endswith(".")
 
 def clean_up_spacing(sentence):
+    '''
+
+    :param sentence: str a sentence to clean of leading and trailing space characters.
+    :return: str a sentence that has been cleaned of leading and trailing space characters.
+    '''
     clean_sentence = sentence.strip()
     return clean_sentence
 
 def replace_word_choice(sentence, new_word, old_word):
+    '''
+
+    :param sentence: str a sentence to replace words in.
+    :param new_word: str replacement word
+    :param old_word: str word to replace
+    :return:  str input sentence with new words in place of old words
+    '''
     better_sentence = sentence.replace(new_word, old_word)
     return better_sentence
diff --git a/exercises/concept/little-sisters-essay/string_methods.py b/exercises/concept/little-sisters-essay/string_methods.py
index a52f6257..710f84e6 100644
--- a/exercises/concept/little-sisters-essay/string_methods.py
+++ b/exercises/concept/little-sisters-essay/string_methods.py
@@ -1,12 +1,34 @@
 def capitalize_title(title):
+    '''
+
+   :param title: str title string that needs title casing
+   :return:  str title string in title case (first letters capitalized)
+   '''
     pass
 
 def check_sentence_ending(sentence):
+    '''
+
+    :param sentence: str a sentence to check.
+    :return:  bool True if punctuated correctly with period, False otherwise.
+    '''
     pass
 
 def clean_up_spacing(sentence):
+    '''
+
+    :param sentence: str a sentence to clean of leading and trailing space characters.
+    :return: str a sentence that has been cleaned of leading and trailing space characters.
+    '''
     pass
 
 def replace_word_choice(sentence, old_word, new_word):
+    '''
+
+   :param sentence: str a sentence to replace words in.
+   :param new_word: str replacement word
+   :param old_word: str word to replace
+   :return:  str input sentence with new words in place of old words
+   '''
     pass
 
diff --git a/exercises/concept/little-sisters-vocab/.docs/instructions.md b/exercises/concept/little-sisters-vocab/.docs/instructions.md
index 19d703ad..1fc23177 100644
--- a/exercises/concept/little-sisters-vocab/.docs/instructions.md
+++ b/exercises/concept/little-sisters-vocab/.docs/instructions.md
@@ -1,28 +1,45 @@
 # Instructions
 
-You're helping your younger sister with her English vocabulary homework, which she's finding very tedious. Her class is learning to create new words by adding _prefixes_ and _suffixes_. Given a set of words, the teacher is looking for correctly transformed words with correct spelling by adding the prefix to the beginning or the suffix to the ending.
+You are helping your younger sister with her English vocabulary homework, which she's finding very tedious.
+ Her class is learning to create new words by adding _prefixes_ and _suffixes_.
+ Given a set of words, the teacher is looking for correctly transformed words with correct spelling by adding the prefix to the beginning or the suffix to the ending.
 
 There's four activities in the assignment, each with a set of text or words to work with.
 
+
 ## 1. Add a prefix to a word
 
-One of the most common prefixes in English is `un`, meaning "not". In this activity, your sister needs to make negative, or "not" words by adding `un` to them.
+One of the most common prefixes in English is `un`, meaning "not".
+ In this activity, your sister needs to make negative, or "not" words by adding `un` to them.
 
 Implement the `add_prefix_un()` function that takes `word` as a parameter and returns a new `un` prefixed word:
 
+
 ```python
 >>> add_prefix_un("happy")
 'unhappy'
 
 >>> add_prefix_un("manageable")
-'unmanagable'
+'unmanageable'
 ```
 
+
 ## 2. Add prefixes to word groups
 
-There are four more common prefixes that your sister's class is studying: `en` (_meaning to 'put into' or 'cover with'_), `pre` (_meaning 'before' or 'forward'_), `auto` (_meaning 'self' or 'same'_), and `inter` (_meaning 'between' or 'among'_). In this exercise, the class is creating groups of vocabulary words using these prefixes, so they can be studied together. Each prefix comes in a list with common words it's used with. The students need to apply the prefix and produce a string that shows the prefix applied to all of the words.
+There are four more common prefixes that your sister's class is studying:
+ `en` (_meaning to 'put into' or 'cover with'_),
+ `pre` (_meaning 'before' or 'forward'_),
+ `auto` (_meaning 'self' or 'same'_),
+  and `inter` (_meaning 'between' or 'among'_).
+
+ In this exercise, the class is creating groups of vocabulary words using these prefixes, so they can be studied together.
+ Each prefix comes in a list with common words it's used with.
+ The students need to apply the prefix and produce a string that shows the prefix applied to all of the words.
+
+Implement the `make_word_groups(<vocab_words>)` function that takes a `vocab_words` as a parameter in the following form:
+ `[<prefix>, <word_1>, <word_2> .... <word_n>]`, and returns a string with the prefix applied to each word that looks like:
+  `'<prefix> :: <prefix><word_1> :: <prefix><word_2> :: <prefix><word_n>'`.
 
-Implement the `make_word_groups()` function that takes a `vocab_words` as a parameter in the following form: [`<prefix>`, `word_1`, `word_2` .... `word_n`], and returns a string with the prefix applied to each word that looks like `'<prefix> :: <prefix><word_1> :: <prefix><word_2> :: <prefix><word_n>'`.
 
 ```python
 >>> make_word_groups(['en', 'close', 'joy', 'lighten'])
@@ -35,14 +52,19 @@ Implement the `make_word_groups()` function that takes a `vocab_words` as a para
 'auto :: autodidactic :: autograph :: automate'
 
 >>> make_word_groups(['inter', 'twine', 'connected', 'dependant'])
-'inter :: intertwine :: interconnected :: interdependant'
+'inter :: intertwine :: interconnected :: interdependent'
 ```
 
+
 ## 3. Remove a suffix from a word
 
-`ness` is a common suffix that means _'state of being'_. In this activity, your sister needs to find the original root word by removing the `ness` suffix. But of course there are pesky spelling rules: If the root word originally ended in a consonant followed by a 'y', then the 'y' was changed to to 'i'. Removing 'ness' needs to restore the 'y' in those root words. e.g. `happiness` --> `happi` --> `happy`.
+`ness` is a common suffix that means _'state of being'_.
+ In this activity, your sister needs to find the original root word by removing the `ness` suffix.
+  But of course there are pesky spelling rules: If the root word originally ended in a consonant followed by a 'y', then the 'y' was changed to to 'i'.
+ Removing 'ness' needs to restore the 'y' in those root words. e.g. `happiness` --> `happi` --> `happy`.
+
+Implement the `remove_suffix_ness(<word>)` function that takes in a word `str`, and returns the root word without the `ness` suffix.
 
-Implement the `remove_suffix_ness()` function that takes in a word and returns the root word without the `ness` suffix.
 
 ```python
 >>> remove_suffix_ness("heaviness")
@@ -54,11 +76,16 @@ Implement the `remove_suffix_ness()` function that takes in a word and returns t
 
 ## 4. Extract and transform a word
 
-Suffixes are often used to change the part of speech a word has. A common practice in English is "verbing" or "verbifying" -- where a adjective _becomes_ a verb by adding an `en` suffix.
+Suffixes are often used to change the part of speech a word has.
+ A common practice in English is "verbing" or "verbifying" -- where a adjective _becomes_ a verb by adding an `en` suffix.
 
-In this task, your sister is going to practice "verbing" words by extracting an adjective from a sentence and turning it into a verb. Fortunately, all the words that need to be transformed here are "regular" - they don't need spelling changes to add the suffix.
+In this task, your sister is going to practice "verbing" words by extracting an adjective from a sentence and turning it into a verb.
+ Fortunately, all the words that need to be transformed here are "regular" - they don't need spelling changes to add the suffix.
+
+Implement the `noun_to_verb(<sentence>, <index>)` function that takes two parameters.
+ A `sentence` using the vocabulary word, and the `index` of the word, once that sentence is split apart.
+ The function should return the extracted adjective as a verb.
 
-Implement the `noun_to_verb()` function that takes two parameters. A `sentence` using the vocabulary word, and the `index` of the word, once that sentence is split apart. The function should return the extracted adjective as a verb.
 
 ```python
 >>> noun_to_verb('I need to make that bright.', -1 )
@@ -67,3 +94,4 @@ Implement the `noun_to_verb()` function that takes two parameters. A `sentence`
 >>> noun_to_verb('It got dark as the sun set.', 2)
 'darken'
 ```
+
diff --git a/exercises/concept/little-sisters-vocab/.docs/introduction.md b/exercises/concept/little-sisters-vocab/.docs/introduction.md
index 8401957c..9b9ca9dd 100644
--- a/exercises/concept/little-sisters-vocab/.docs/introduction.md
+++ b/exercises/concept/little-sisters-vocab/.docs/introduction.md
@@ -1,11 +1,13 @@
 # Introduction
 
 A `str` in Python is an [immutable sequence][text sequence] of [Unicode code points][unicode code points].
-These could include letters, diacritical marks, positioning characters, numbers, currecy symbols, emoji, punctuation, space and line break characters, and more.
-Being immutable, a `str` object's value in memory doesn't change; methods that appear to modify a string return a new copy or instance of `str`.
+These could include letters, diacritical marks, positioning characters, numbers, currency symbols, emoji, punctuation, space and line break characters, and more.
+ Being immutable, a `str` object's value in memory doesn't change; methods that appear to modify a string return a new copy or instance of that `str` object.
+
 
 A `str` literal can be declared via single `'` or double `"` quotes. The escape `\` character is available as needed.
 
+
 ```python
 
 >>> single_quoted = 'These allow "double quoting" without "escape" characters.'
@@ -17,6 +19,7 @@ A `str` literal can be declared via single `'` or double `"` quotes. The escape
 
 Multi-line strings are declared with `'''` or `"""`.
 
+
 ```python
 >>> triple_quoted =  '''Three single quotes or "double quotes" in a row allow for multi-line string literals.
   Line break characters, tabs and other whitespace are fully supported.
@@ -27,7 +30,8 @@ Multi-line strings are declared with `'''` or `"""`.
 ```
 
 Strings can be concatenated using the `+` operator.
-This method should be used sparingly, as it is not very performant or easily maintained.
+ This method should be used sparingly, as it is not very performant or easily maintained.
+
 
 ```python
 language = "Ukrainian"
@@ -43,6 +47,7 @@ sentence = word + " " + "means" + " " + number + " in " + language + "."
 
 If a `list`, `tuple`, `set` or other collection of individual strings needs to be combined into a single `str`, [`<str>.join(<iterable>)`][str-join], is a better option:
 
+
 ```python
 # str.join() makes a new string from the iterables elements.
 >>> chickens = ["hen", "egg", "rooster"]
@@ -57,7 +62,8 @@ If a `list`, `tuple`, `set` or other collection of individual strings needs to b
 'hen 🌿 egg 🌿 rooster'
 ```
 
-Code points within a `str` can be referenced by 0-based index number from the left:
+Code points within a `str` can be referenced by `0-based index` number from the left:
+
 
 ```python
 creative = '창의적인'
@@ -72,7 +78,8 @@ creative = '창의적인'
 '인'
 ```
 
-Indexing also works from the right, starting with `-1`:
+Indexing also works from the right, starting with a `-1-based index`:
+
 
 ```python
 creative = '창의적인'
@@ -88,8 +95,10 @@ creative = '창의적인'
 
 ```
 
+
 There is no separate “character” or "rune" type in Python, so indexing a string produces a new `str` of length 1:
 
+
 ```python
 
 >>> website = "exercism"
@@ -104,9 +113,10 @@ True
 ```
 
 Substrings can be selected via _slice notation_, using [`<str>[<start>:stop:<step>]`][common sequence operations] to produce a new string.
-Results exclude the `stop` index.
-If no `start` is given, the starting index will be 0.
-If no `stop` is given, the `stop` index will be the end of the string.
+ Results exclude the `stop` index.
+ If no `start` is given, the starting index will be 0.
+ If no `stop` is given, the `stop` index will be the end of the string.
+
 
 ```python
 moon_and_stars = '🌟🌟🌙🌟🌟⭐'
@@ -138,8 +148,9 @@ sun_and_moon = '🌞🌙🌞🌙🌞🌙🌞🌙🌞'
 ```
 
 Strings can also be broken into smaller strings via [`<str>.split(<separator>)`][str-split], which will return a `list` of substrings.
-The list can then be further indexed or split, if needed.
-Using `<str>.split()` without any arguments will split the string on whitespace.
+ The list can then be further indexed or split, if needed.
+ Using `<str>.split()` without any arguments will split the string on whitespace.
+
 
 ```python
 >>> cat_ipsum = "Destroy house in 5 seconds mock the hooman."
@@ -158,7 +169,10 @@ Using `<str>.split()` without any arguments will split the string on whitespace.
 ['feline', 'four-footed', 'ferocious', 'furry']
 ```
 
-Seperators for `<str>.split()` can be more than one character. The whole string will be used for matching.
+
+Separators for `<str>.split()` can be more than one character.
+The **whole string** is used for split matching.
+
 
 ```python
 
@@ -173,14 +187,15 @@ yellow"""
 ```
 
 Strings support all [common sequence operations][common sequence operations].
-Individual code points can be iterated through in a loop via `for item in <str>`.
-Indexes _with_ items can be iterated through in a loop via `for index, item in enumerate(<str>)`
+ Individual code points can be iterated through in a loop via `for item in <str>`.
+ Indexes _with_ items can be iterated through in a loop via `for index, item in enumerate(<str>)`.
+
 
 ```python
 
 >>> exercise = 'လေ့ကျင့်'
 
-# Note that there are more code points than percieved glyphs or characters
+# Note that there are more code points than perceived glyphs or characters
 >>> for code_point in exercise:
 ...    print(code_point)
 ...
@@ -207,9 +222,10 @@ Indexes _with_ items can be iterated through in a loop via `for index, item in e
 7 :  ့
 ```
 
-[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
-[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
+
 [common sequence operations]: https://docs.python.org/3/library/stdtypes.html#common-sequence-operations
-[str-split]: https://docs.python.org/3/library/stdtypes.html#str.split
 [str-join]: https://docs.python.org/3/library/stdtypes.html#str.join
-[str-constructor]: https://docs.python.org/3/library/stdtypes.html#str
+[str-split]: https://docs.python.org/3/library/stdtypes.html#str.split
+[text sequence]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+[unicode code points]: https://stackoverflow.com/questions/27331819/whats-the-difference-between-a-character-a-code-point-a-glyph-and-a-grapheme
+
diff --git a/exercises/concept/little-sisters-vocab/.meta/exemplar.py b/exercises/concept/little-sisters-vocab/.meta/exemplar.py
index c190de6e..8b268bb6 100644
--- a/exercises/concept/little-sisters-vocab/.meta/exemplar.py
+++ b/exercises/concept/little-sisters-vocab/.meta/exemplar.py
@@ -28,7 +28,7 @@ def make_word_groups(vocab_words):
 def remove_suffix_ness(word):
     '''
 
-    :param word: str of word to remvoe suffix from.
+    :param word: str of word to remove suffix from.
     :return: str of word with suffix removed & spelling adjusted.
 
     This function takes in a word and returns the base word with `ness` removed.
@@ -42,7 +42,7 @@ def remove_suffix_ness(word):
 def noun_to_verb(sentence, index):
     '''
 
-    :param sentence: str that uses the word in sentance
+    :param sentence: str that uses the word in sentence
     :param index:  index of the word to remove and transform
     :return:  str word that changes the extracted adjective to a verb.
 
diff --git a/exercises/concept/little-sisters-vocab/strings.py b/exercises/concept/little-sisters-vocab/strings.py
index 0a9ee47e..3a9ebe15 100644
--- a/exercises/concept/little-sisters-vocab/strings.py
+++ b/exercises/concept/little-sisters-vocab/strings.py
@@ -25,7 +25,7 @@ def make_word_groups(vocab_words):
 def remove_suffix_ness(word):
     '''
 
-    :param word: str of word to remvoe suffix from.
+    :param word: str of word to remove suffix from.
     :return: str of word with suffix removed & spelling adjusted.
 
     This function takes in a word and returns the base word with `ness` removed.
@@ -35,7 +35,7 @@ def remove_suffix_ness(word):
 def noun_to_verb(sentence, index):
     '''
 
-    :param sentence: str that uses the word in sentance
+    :param sentence: str that uses the word in sentence
     :param index:  index of the word to remove and transform
     :return:  str word that changes the extracted adjective to a verb.
 
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/little-sisters-essay/string_methods_test.py b/exercises/concept/little-sisters-essay/string_methods_test.py
index dfcd304c..6c6e8713 100644
--- a/exercises/concept/little-sisters-essay/string_methods_test.py
+++ b/exercises/concept/little-sisters-essay/string_methods_test.py
@@ -1,11 +1,9 @@
 import unittest
 import pytest
-from string_methods import (
-    capitalize_title,
-    check_sentence_ending,
-    clean_up_spacing,
-    replace_word_choice
-)
+from string_methods import (capitalize_title,
+                            check_sentence_ending,
+                            clean_up_spacing,
+                            replace_word_choice)
 
 
 class TestStringMethods(unittest.TestCase):
diff --git a/exercises/concept/little-sisters-vocab/strings_test.py b/exercises/concept/little-sisters-vocab/strings_test.py
index 8006eb83..75d62139 100644
--- a/exercises/concept/little-sisters-vocab/strings_test.py
+++ b/exercises/concept/little-sisters-vocab/strings_test.py
@@ -1,11 +1,9 @@
 import unittest
 import pytest
-from strings import (
-    add_prefix_un,
-    make_word_groups,
-    remove_suffix_ness,
-    noun_to_verb
-)
+from strings import (add_prefix_un,
+                    make_word_groups,
+                    remove_suffix_ness,
+                    noun_to_verb)
 
 
 class TestStrings(unittest.TestCase):
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