Fixing wrong regexp in makefile / interaction with Action project.

Author: aubertc

source/Makefile

@@ -557,7 +557,7 @@ $(PROJECT_DIR)%.zip: $(PROJECT_DIR)%/*/Program.cs | $(PROJECT_DIR)/%/*/*.cs
 # $(notdir $*) # Name of Solution
 # $(notdir $(patsubst %/,%,$(dir $<))) # Name of Project
 # $@ # Name of target, the zip file
-# cat $< | grep -oP '^\s*(public |private )?class \K.*' # name of the class in Program.cs
+# cat $< | grep -oP '(((internal)|(public)|(private)|(protected)|(sealed)|(abstract)|(static))?[\s\r\n\t]+){0,2}class[\s]+\K([[:alnum:]]|_)*[\s\S]' # name of the class in Program.cs
 #
 # We start by creating the required Properties directory:
 	@mkdir -p $(dir $<)Properties

source/code/projects/Actions/Actions/Program.cs

@@ -25,8 +25,8 @@ static void Main()
         Action<int> display_variable = ExampleActions.Display;
         display_variable(10);
 
-        // We can even have action
-        // from class that uses generic
+        // We can even have actions
+        // from classes that uses generic
         // type parameters.
 
         int[] arrayT = { 20, 30, 40 };
@@ -37,6 +37,5 @@ static void Main()
 
         // Passing an Action as an argument:
         CallingAction.Demo(ExampleActions.Test);
-}
-
-}
+    }
+}

source/lectures/misc/actions.md

@@ -0,0 +1,51 @@
+---
+tags:
+- datatypes
+---
+
+# Actions
+
+## Motivation
+
+[Wikipedia](https://en.wikipedia.org/wiki/Sorting_algorithm) explains it very nicely: sorting is ubiquitous in Computer Sciences. 
+It is a simple problem ("*How can I sort the following values the most efficiently?*") that has many solutions, but still offers open problems.
+
+We only consider **correct** algorithms, i.e., one where their output is such that
+
+- each element is larger than or equal to the previous one, according to the order picked,
+- all the elements that were in the input are present in the output (with the same cardinality, if repetition is allowed).
+
+There are many ways of "comparing" sorting algorithms.
+A sorting algorithm…
+
+- has a best, worst and average case time complexity (measured in general in number of comparisons required),
+- has a best, worst and average case space complexity (i.e., "how much additional memory is required?"),
+- can be "stable" (i.e., equal values are not permutted),
+- uses *insertion*, *exchange*, *selection*, *merging* method,
+- is serial or parallel,
+
+among other properties.
+
+# Insertion Sort Algorithm
+
+This algorithm is [nicely explained and illustrated on wikipedia](https://en.wikipedia.org/wiki/Insertion_sort), and can be implemented as follows:
+
+```
+!include`snippetStart="// Insertion Algorithm", snippetEnd="// Done with insertion Algorithm"` code/projects/Sorting/Sorting/Sorting.cs
+```
+
+# Heapsort Algorithm
+
+We first define some helper methods:
+
+```
+!include`snippetStart="// Helper methods for Heapsort", snippetEnd="// Done with helper methods for Heapsort"` code/projects/Sorting/Sorting/Sorting.cs
+```
+
+and then leverage the heap structure to sort:
+
+```
+!include`snippetStart="// Heapsort Algorithm", snippetEnd="// Done with heapsort Algorithm"` code/projects/Sorting/Sorting/Sorting.cs
+```
+
+Note that `PercDown` builds a *max heap*: once the values are "pre-sorted **greater value first**", removing the first one to move it to the *end* of the list makes the list sorted from smallest to greatest value once we are done.

source/order

@@ -74,6 +74,7 @@
 ./lectures/misc/exceptions.md
 ./lectures/misc/references.md
 ./lectures/misc/files.md
+./lectures/misc/actions.md
 ./lectures/misc/sorting.md
 ./lecture/slides.md
 ./labs/