blank lines after headers and remove trailing whitespace

Author: petrem

exercises/practice/robot-name/.approaches/introduction.md

@@ -1,12 +1,15 @@
 # Introduction
+
 Robot Name in Python is an interesting exercise for practicing randomness.
 
 ## General Guidance
+
 Two ways immediately come to mind: generate all the possible names and then return them sequentially, or generate a random name and ensure that it's not been previously used.
 
 Randomness can be a little, well, random, so **it's very easy to have an incorrect solution and still pass the tests**. It's strongly recommended to submit your solution for Code Review.
 
 ## Approach: mass name generation
+
 We'd first have to generate all the possible names, shuffle them, and then use `next` (the simplest way) or maintain a `current_index` and get the name.
 Here's a possible way to do it:
 
@@ -30,6 +33,7 @@ Note that selecting randomly from the list of all names would be incorrect, as t
 For more detail and explanation of the code, [read here][approach-mass-name-generation].
 
 ## Approach: name on the fly
+
 Another approach is to generate the name on the fly and add it to a cache or a store, checking if the generated name hasn't been used previously.
 
 

exercises/practice/robot-name/.approaches/mass-name-generation/content.md

@@ -1,4 +1,5 @@
 # Mass Name Generation
+
 We first generate all the possible names, shuffle them, and then either use `next` (the simplest way) or maintain a `current_index` to get the name.
 Note that selecting randomly from the list of all names would be incorrect, as there is a possibility of the name being repeated.
 
@@ -31,14 +32,14 @@ numbers = (str(i).zfill(3) for i in range(1000))
 names = [l + n for l in letter_pairs for n in numbers]
 ```
 
-After the name generation, the names are shuffled - using the [default `seed`][random-seed] in the `random` module (the current timestamp). 
+After the name generation, the names are shuffled - using the [default `seed`][random-seed] in the `random` module (the current timestamp).
 When the tests reseed `random`, this has no effect as the names were shuffled before that.
 
-We then set `NAMES` to the iterable of names, and in `reset`, set the robot's name to the  `next(name)`. 
+We then set `NAMES` to the iterable of names, and in `reset`, set the robot's name to the  `next(name)`.
 If you are interested, you can read more on [`iter` and `next`][iter-and-next].
 
 Unlike the [on the fly approach][approach-name-on-the-fly], this has a relatively short "generation" time, because we are merely giving the `next` name instead of generating it.
-However, this has a huge startup memory and time cost, as 676,000 strings have to be calculated and stored. 
+However, this has a huge startup memory and time cost, as 676,000 strings have to be calculated and stored.
 For an approximate calculation, 676,000 strings * 5 characters / string * 1 byte / character gives 3380000 bytes or 3.38 MB of RAM - and that's just the memory aspect of it.
 Sounds small, but this might be a relatively significant startup cost.
 

exercises/practice/robot-name/.approaches/name-on-the-fly/content.md

@@ -1,4 +1,5 @@
 # Find name on the fly
+
 We generate the name on the fly and add it to a cache or a store, checking to make sure that the generated name has not been used previously.
 
 A possible way to implement this:
@@ -10,7 +11,7 @@ cache = set()
 
 
 class Robot:
-    def __get_name(self): 
+    def __get_name(self):
         return ''.join(choices(ascii_uppercase, k=2) + choices(digits, k=3))
 
     def reset(self):
@@ -19,7 +20,7 @@ class Robot:
         cache.add(name)
         self.name = name
 
-    def __init__(self): 
+    def __init__(self):
         self.reset()
 ```
 We use a `set` for the cache as it has a low access time, and because we do not need the preservation of order or the ability to access by index.
@@ -53,7 +54,7 @@ This has almost no startup time and memory, apart from declaring an empty `set`.
 Note that the _generation_ time is the same as the [mass generation approach][approach-mass-name-generation], as a similar method is used.
 However, as the name is generated at the time of setting/resetting, the method time itself is higher.
 
-In the long run, if many names are generated, this is inefficient, since collisions will start being generated more often than unique names. 
+In the long run, if many names are generated, this is inefficient, since collisions will start being generated more often than unique names.
 
 [walrus-operator]: https://realpython.com/python-walrus-operator/
 [private-helper-methods]: https://www.geeksforgeeks.org/private-methods-in-python/