Added notes on complexity.

Author: Clément

source/code/snippets/complexity.cs

@@ -0,0 +1,95 @@
+using System;
+using System.IO;
+
+class Program
+{
+    static int factorial(int n)
+    {
+        if (n == 0)
+            return 1;
+        else
+            return checked(factorial(n - 1) * n);
+    }
+    
+    static void Main()
+    {
+        Console.WriteLine(int.MaxValue);
+        
+        int x = int.MaxValue;
+        int y = x + 1;
+        Console.WriteLine(y);
+        
+        try
+        {
+            y = checked(x + 1);
+        }
+        catch (System.OverflowException)
+        {
+            Console.WriteLine("An overflow exception was thrown.");
+        }
+        
+        int count0 = 0;
+        int n0 = 3;
+        try
+        {
+            while (true)
+            {
+                count0++;
+                n0 = checked(n0 +1 );
+            }
+        }
+        catch (System.OverflowException)
+        {
+            Console.WriteLine("An overflow exception was thrown after " + count0 + " iterations.");
+            // An overflow exception was thrown after 2147483645 iterations.
+        }
+        
+        int count1 = 0;
+        int n1 = 3;
+        try
+        {
+            while (true)
+            {
+                count1++;
+                n1 = checked(n1 * n1);
+            }
+        }
+        catch (System.OverflowException)
+        {
+            Console.WriteLine("An overflow exception was thrown after " + count1 + " iterations.");
+            // An overflow exception was thrown after 5 iterations.
+        }
+        
+        int count2 = 0;
+        int n2 = 3;
+        try
+        {
+            while (true)
+            {
+                count2++;
+                n2 = factorial(n2);
+            }
+        }
+        catch (System.OverflowException)
+        {
+            Console.WriteLine("An overflow exception was thrown after " + count2 + " iterations.");
+            // An overflow exception was thrown after 3 iterations.
+        }
+        
+        int count3 = 0;
+        int n3 = 100;
+        try
+        {
+            while (true)
+            {
+                count3++;
+                n3 = checked(n3 * (int)Math.Log(n3, 2));
+            }
+        }
+        catch (System.OverflowException)
+        {
+            Console.WriteLine("An overflow exception was thrown after " + count3 + " iterations.");
+            // An overflow exception was thrown after 7 iterations.
+        }
+    }
+}

source/docs/programming_and_computer_usage/complexity.md

@@ -0,0 +1,22 @@
+#  Some Notes on Complexity
+
+Have a look at the [Big-O complexity chart](https://www.bigocheatsheet.com/):
+
+![Big-O Complexity Chart](https://www.bigocheatsheet.com/img/big-o-complexity-chart.png)
+
+A function [has an order](https://en.wikipedia.org/wiki/Big_O_notation#Orders_of_common_functions), it can be for example
+
+- constant (O(c)),
+- logarithmic (O(log n)),
+- linear (O(n)),
+- [linearithmic](https://en.wikipedia.org/wiki/Time_complexity#Quasilinear_time) (O(n log n)),
+- quadratic (O(n^2)),
+- cubic (O(n^3)),
+- exponential (O(c^n)),
+- factorial (O(n!)).
+
+This can make a *very* significant difference, as exemplified in the following code:
+
+```
+!include code/snippets/complexity.cs
+```

source/order

@@ -15,6 +15,7 @@
 ./docs/programming_and_computer_usage/keyboard_shortcuts.md
 ./docs/programming_and_computer_usage/datatypes_in_csharp.md
 ./docs/programming_and_computer_usage/uml_class.md
+./docs/programming_and_computer_usage/complexity.md
 ./lectures/
 ./lectures/intro/
 ./lectures/intro/computers_and_programming.md