Fixing method name in file_displayer project

Author: Clément

source/lectures/control/more_on_recursion.md

@@ -5,8 +5,6 @@ tags:
 
 # More on Recursion
 
-The code for this lecture is available [in this archive](./code/projects/AdvancedRecursion.zip).
-
 ## Re-Introduction
 
 We previously defined recursion as follows:
@@ -15,15 +13,15 @@ We previously defined recursion as follows:
 
 Applied very strictly, the simplest (and most likely shortest) recursive method is the following:
 
-```
+```{download="./code/projects/AdvancedRecursion.zip"}
 !include`snippetStart="// Simplest possible example of a recursive function:", snippetEnd="// Uncomment at your own risk!"` code/projects/AdvancedRecursion/AdvancedRecursion/Program.cs
 ```
 
 It is a method (`R`) that simply … calls itself. Even if this method does not "do" anything, calling it will most likely make your program crash, since `R` will keep calling itself forever: this is actually an example of an infinite loop, and the basics of the ["fork bomb" attack](https://en.wikipedia.org/wiki/Fork_bomb)^[Except that the fork bomb calls itself *twice*, and in parallel.].
 
 A better definition of recursion would include something about the method eventually terminating, like the following:
 
-```
+```{download="./code/projects/AdvancedRecursion.zip"}
 !include`snippetStart="// Recursive CountDown method", snippetEnd="// Usage example"` code/projects/AdvancedRecursion/AdvancedRecursion/Program.cs
 ```
 
@@ -37,15 +35,15 @@ But note that this method is not _always_ terminating: indeed, calling `CountDow
 
 A possible way to patch this would be to have two additional method: one to count "up" to 0, and one that decides which method to call:
 
-```
+```{download="./code/projects/AdvancedRecursion.zip"}
 !include`snippetStart="// Recursive CountUp method", snippetEnd="// Mutually recursive methods"` code/projects/AdvancedRecursion/AdvancedRecursion/Program.cs
 ```
 
 As we can see, `Count` itself is *not* recursive, but it calls a recursive method.
 
 Finally, methods can be *mutually recursive*: a method `MyTurn` can call a `YourTurn` method that itself calls `MyTurn`. While neither method are recursive, they create a recursive situation, as exemplified below:
 
-```
+```{download="./code/projects/AdvancedRecursion.zip"}
 !include`snippetStart="// Mutually recursive methods", snippetEnd="// Usage example"` code/projects/AdvancedRecursion/AdvancedRecursion/Program.cs
 ```
 

source/lectures/control/recursion.md

@@ -5,8 +5,6 @@ tags:
 
 # Recursion
 
-The code for this lecture is available [in this archive](./code/projects/RecursionHelloWorld.zip) (first parts) and [this one](./code/projects/ListDirectoriesFileRecursively.zip) (listing files and folders recursively).
-
 ## Introduction
 
 Recursion is a central notion in programming, simple to state but difficult to master: a method is *recursive* if it calls itself.
@@ -17,7 +15,7 @@ Below, we present some simple recursive programs: while some could be written wi
 
 Consider the following:
 
-```
+```{download="./code/projects/RecursionHelloWorld.zip"}
 !include`snippetStart="// Displays numbers from n to 1", snippetEnd="// Displays numbers from 1 to n"` code/projects/RecursionHelloWorld/RecursionHelloWorld/Program.cs
 ```
 
@@ -43,7 +41,7 @@ In our example, it would display "3 2 1 ".
 
 *When* the function calls itself matters a lot. Indeed, consider `displayRAll`, which calls itself *before* executing the `Console.WriteLine` instruction:
 
-```
+```{download="./code/projects/RecursionHelloWorld.zip"}
 !include`snippetStart="// Displays numbers from 1 to n", snippetEnd="// Recursive multiplication"` code/projects/RecursionHelloWorld/RecursionHelloWorld/Program.cs
 ```
 
@@ -72,7 +70,7 @@ In this example, "1 2 3 " would be displayed: the order is reversed with resp
 
 `displayAll` is an example of _tail recursion_: the recursive call is the **last** statement in the method.
 `displayRAll` is an example of _head recursion_: the recursive call is the **first** statement in the method.
-They are furthormore both examples of *linear recursion*, as they call themselves only once.
+They are furthermore both examples of *linear recursion*, as they call themselves only once.
 
 ## Recursive Methods Returning a Value
 
@@ -83,7 +81,7 @@ Recursive methods can also return a value, used by previous calls to compute som
 For example, consider that multiplication can be defined by addition: indeed, $x × y$ is $y + y + y + … + y$ where $y$ is summed $x$ times. Stated differently (read: recursively), $x × y$ is $y + ((x - 1) × y)$.
 We can implement such a program easily:
 
-```
+```{download="./code/projects/RecursionHelloWorld.zip"}
 !include`snippetStart="// Recursive multiplication", snippetEnd="// Recursive factorial"` code/projects/RecursionHelloWorld/RecursionHelloWorld/Program.cs
 ```
 
@@ -96,7 +94,7 @@ Observe that `mult(10000000, 0)` would call `mult` 10000001 times and add 0 to i
 The factorial of $n$ is $n! = n × (n-1) × (n-2) × (n-3) × … × 1$.
 This function can easily be implemented using recursion:
 
-```
+```{download="./code/projects/RecursionHelloWorld.zip"}
 !include`snippetStart="// Recursive factorial", snippetEnd="// An improvment would be to replace"` code/projects/RecursionHelloWorld/RecursionHelloWorld/Program.cs
 ```
 
@@ -107,12 +105,8 @@ Note that this code actually compute e.g., $5! = 5 × 4 × 3 × 2 × 1 × 1$ (wi
 While multiplication and factorial can be implemented without recursion, some structures makes it natural, or even required, to use recursion.
 Going through folders and files is an example of such situation.
 
-```
+```{download="./code/projects/ListDirectoriesFileRecursively.zip"}
 !include code/projects/ListDirectoriesFileRecursively/ListDirectoriesFileRecursively/Program.cs
 ```
 
-<!--
-`snippetStart="// https://stackoverflow.com/a/929277", snippetEnd="// An improvment would be to replace"
--->
-
 Note that our previous examples were calling themselves only once per method call, but that `ListDir` calls itself as many times as there are folders in the folder currently examined.

source/projects/file_displayer.md

@@ -23,7 +23,7 @@ A bonus (for more experienced programmers) asks to compute the winner of a race
 
 #### In more details
 
-Your goal is to design and implement a static `TextFileHelper` class containing 5 methods (the fifth one being optional):
+Your goal is to design and implement a static `FileDisplayer` class containing 5 methods (the fifth one being optional):
 
 #. A `Display` method that takes a `string` as an argument and displays the content of the file located at the corresponding path if it exists, and an error message otherwise.
 #. A `DisplayN` method that takes a `string` and an `int`, and displays the line corresponding to the `int` argument from the file located at the corresponding path if it exists (with a line number before), and an error message otherwise.

source/solutions/io/files.md

@@ -47,7 +47,7 @@ tags:
     sw.WriteLine("Hello World!!");
     ```
 
-    <details><summary>Solution</summary>This program would
+    <details><summary>Solution</summary> This program would
 
     #. Create a file located at `filePath`,
     #. Store in the file "Hello World!!", followed by a new line.