Adding exam #1 and its solution.

Author: Clément

source/code/projects/CList_ICollection/CList_ICollection/CList.cs

@@ -181,4 +181,32 @@ IEnumerator IEnumerable.GetEnumerator()
   }
 
   /* We are done realizing the ICollection class. */
+
+  // One last method, to remove the last cell and
+  // returns its value.
+  public T RemoveL()
+  {
+    if (isReadonly)
+    {
+      throw new InvalidOperationException(
+        "List is read-only"
+      );
+    }
+    if (IsEmpty())
+    {
+      throw new InvalidOperationException(
+        "Cannot remove last cell from an empty list!."
+      );
+    }
+    T data;
+
+    Cell cCell = first;
+    while (cCell.Next != null && cCell.Next.Next != null)
+    {
+      cCell = cCell.Next;
+    }
+    data = cCell.Next.Data;
+    cCell.Next = null;
+    return data;
+  }
 }

source/code/projects/CList_ICollection/CList_ICollection/Program.cs

@@ -91,5 +91,31 @@ static void Main(string[] args)
     {
       Console.Write(i + " ");
     }
+    // Last, we test the RemoveL method
+    myList1.IsReadOnly = false;
+    Console.WriteLine("\nThe list contains:");
+    foreach (int i in myList1)
+    {
+      Console.Write(i + " ");
+    }
+    for (int i = 0; i < myList1.Count; i++)
+    {
+      try
+      {
+        Console.WriteLine(
+          "\nValue removed: " + myList1.RemoveL()
+        );
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine(e.Message);
+      }
+    }
+
+    Console.WriteLine("\nThe list contains:");
+    foreach (int i in myList1)
+    {
+      Console.Write(i + " ");
+    }
   }
 }

source/code/projects/RBTree/RBTree/Program.cs

@@ -0,0 +1,13 @@
+using System;
+
+class Program
+{
+    static void Main()
+    {
+        RBTree<int> btree = new RBTree<int>();
+        btree.Insert(1);
+        btree.Insert(2);
+        btree.Insert(3);
+        btree.Insert(4);
+    }
+}

source/code/projects/RBTree/RBTree/RBTree.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+
+public class RBTree<T>
+{
+  private class Node
+  {
+    public T Data { get; set; }
+    public Node left;
+    public Node right;
+
+    public Node(
+      T dataP = default(T),
+      Node leftP = null,
+      Node rightP = null
+    )
+    {
+      Data = dataP;
+      left = leftP;
+      right = rightP;
+    }
+}
+  private Node root;
+
+  public RBTree()
+  {
+    root = null;
+  }
+    public void Insert(T dataP)
+    {
+        root = Insert(dataP, root);
+    }
+
+    private Node Insert(T dataP, Node nodeP)
+    {
+        if (nodeP == null)
+        {
+            return new Node(dataP, null, null);
+        }
+        else
+        {
+            Random gen = new Random();
+            if(gen.NextDouble() > 0.5)
+            {
+                nodeP.left = Insert(dataP, nodeP.left);
+            }
+            else
+            {
+                nodeP.right = Insert(dataP, nodeP.right);
+            }
+        }
+        return nodeP;
+    }
+}

source/diag/gra/bstree_example_5.txt

@@ -0,0 +1,6 @@
+%%% The "random" binary tree obtained by inserting 1, 2, 3 and 4 (in that order).
+
+A((1))-->B((2))
+A-->C((3))
+C~~~H1:::hidden
+C-->D((4))

source/order

@@ -96,6 +96,9 @@
 ./exercises/data/1darrays.md
 ./exercises/data/2darrays.md
 ./exercises/data/lists.md
+./exercises/data/stacks.md
+./exercises/data/queues.md
+./exercises/data/trees.md
 ./exercises/control/
 ./exercises/control/conditionals.md
 ./exercises/control/iteratives.md

source/solutions/data/lists.md

@@ -26,6 +26,12 @@ tags:
     - This restriction applies to queues or stacks (depending how "beginning" is interpreted), but not to lists.   
     </details>
 
+#. Implementing a list as a doubly linked list (as opposed to singly linked list) allows to …
+    
+    - [ ] use fewer attributes.
+    - [x] keep track of the end of the list.
+    - [ ] store more elements.
+    - [ ] insert at the beginning of the list faster.
 
 ## Exercises
 
@@ -41,7 +47,8 @@ tags:
         }
         public CList(){first = null;}
     }
-    ``` 
+    ```   
+
     Write…
        
     #. … a `IsEmpty` property that is `true` if the `CList` calling object is empty.
@@ -57,7 +64,7 @@ tags:
         }
         ```
         </details>
-    #. … the `AddF` method that add a cell at the beginning of the CList (to the left).
+    #. … a `AddF` method that takes an argument of type `T` and adds it at the beginning ("to the left") of the `CList` calling object.
 
         <details>
         <summary>Solution</summary>
@@ -70,6 +77,36 @@ tags:
         }
         ```
         </details>
+    #. … a `RemoveL` method that remove the value at the end ("to the right") of the `CList` calling object and returns it.
+    
+        <details>
+        <summary>Solution</summary>        
+        ```
+        public T RemoveL()
+            {
+                if (first == null)
+                {
+                    throw new InvalidOperationException(
+                                "Cannot remove last cell from an empty list!."
+                                );
+                }
+                T data;
+
+                Cell cCell = first;
+                while (
+                    cCell.Next != null && cCell.Next.Next != null
+                )
+                {
+                    cCell = cCell.Next;
+                }
+                data = cCell.Next.Data;
+                cCell.Next = null;
+                return data;
+            }
+        ```
+        </details>
+        
+
     #. … a series of statements, to be inserted in a `Main` method, that a. create a `CList` object capable of containing `char`, b. insert the elements `'b'` and `'/'` in it, c. displays whether it is empty using `IsEmpty`.
 
         <details>
@@ -84,7 +121,14 @@ tags:
         Console.WriteLine("myList1 is empty:" + myList1.IsEmpty);
         ```
         </details>
-    
+        
+    #. If the `AddF` and `RemoveL` were the only two methods to add to and to remove from the list, what would be the name of the data-structure we actually just implemented?
+
+        <details>
+        <summary>Solution</summary>
+        It would be a queue.
+        </details>
+        
 #. Briefly explain the purpose of the `IsReadonly` property from the `ICollection<T>` interface, and list at least two methods in a List implementation realizing `ICollection<T>` that should use it.
 
     <details>

source/solutions/data/queues.md

@@ -0,0 +1,38 @@
+---
+tags:
+  - datatypes/collections
+---
+
+# Queues (Solutions)
+
+## Multiple Choices
+
+#. A queue is generally endowed with operations called…
+   
+        - [ ] Requeue
+        - [x] Dequeue
+        - [x] Enqueue
+        - [ ] Unqueue
+        
+#. A queue implements which principle?
+    
+        - [ ] LIFO
+        - [x] FIFO 
+        - [ ] LILO
+        - [ ] FOFI
+
+#. LIFO stands for…
+    
+        - [ ] Least Is First Out
+        - [ ] Last Is First Outside
+        - [x] Last In First Out
+        - [ ] Low Input Fast Output
+
+## Exercises
+
+#. Suppose given an empty `Queue` object, and assume that we store the values 10 and 20 (in that order), and then remove one and insert 30. Draw the resulting queue, labelling explicitly the front (or beginning) and end of your queue.
+
+    <details>
+    <summary>Solution</summary>
+    We get: (end ->) 30 ; 20 (<- front).
+    </details>

source/solutions/data/stacks.md

@@ -0,0 +1,25 @@
+---
+tags:
+  - datatypes/collections
+---
+
+# Lists (Solutions)
+
+## Multiple Choices
+
+#. A stack is generally endowed with operations called…
+    
+    - [x] Pop
+    - [x] Push
+    - [ ] Pull
+    - [x] Peek
+    - [ ] Pounce
+
+## Exercises
+
+#. Suppose given an empty `Stack` object, and assume that we store the values 10 and 20 (in that order), and then remove one and insert 30. Draw the resulting stack, labelling explicitly the bottom and top of your stack.
+
+    <details>
+    <summary>Solution</summary>
+    We would obtain: (top ->) 30; 10 (<- bottom).
+    </details>