Merge branch 'main' of github.com:princomp/princomp.github.io

Author: Clément

source/code/projects/CQueue/CQueue/CQueue.cs

@@ -5,6 +5,7 @@ class CQueue<T>
   private int front,
     end,
     size;
+
   private T[] mArray;
 
   public CQueue(int capacity = 10)
@@ -31,11 +32,11 @@ public bool IsFull()
     return size == mArray.Length;
   }
 
-  public void Enqueue(T newItem)
+  public void Enqueue(T dataP)
   {
     if (!IsFull())
     {
-      mArray[end] = newItem;
+      mArray[end] = dataP;
       Increment(ref end);
       size++;
     }
@@ -53,23 +54,26 @@ public T Dequeue()
 
   public void Resize()
   {
-    throw new Exception(
-      "Queue Resize is not implemented - you could implement it"
+    throw new NotImplementedException(
+      "Queue Resize is not implemented."
     );
   }
 
   // Increment must be done carefully:
-  // what if we reached the "end of mArray"
-  // but there is room available at the
-  // beginning of the queue? Then the value
-  // needs to become 0.
+  // if we reached the "end" of mArray,
+  // then the value needs to become 0:
+  // we resume "circling" through the 
+  // array.
   private void Increment(ref int value)
   {
     value++;
     if (value == mArray.Length)
     {
       value = 0;
     }
+    // This if statement could be replaced
+    // with
+    // value %= mArray.Length;
   }
 
   public int Capacity
@@ -82,6 +86,7 @@ public override string ToString()
     string returned = "";
     returned +=
       $"Front : {front}, end : {end}, size : {size}, capacity: {Capacity}\n";
+    // Note how the for is constructed:
     for (int i = front; i < size + front; i++)
     {
       returned += mArray[i % mArray.Length] + ":";

source/lectures/data/queue.md

@@ -78,4 +78,38 @@ Our implementation can recover the capacity of the queue by using:
 ```
 capacity = mArray.Length - size;
 ```
-.
+
+However, trying to recover the size from the `front` and `end` values is not possible.
+One could try, using
+
+```
+public int CSize
+{
+    get
+    {
+        int csize = 0;
+        if (front < end) { csize = end - front; }
+        else if (front == end) { csize = mArray.Length; }
+        else
+        {
+            csize = mArray.Length - front + end;
+        }
+        if (csize != size)
+        {
+            throw new NotImplementedException("CSize is not correctly implemented!");
+        }
+        return csize;
+    }
+}
+```
+
+but the exception would be thrown: can you figure out in which case(s) the "computed size" would be incorrect?
+<details>
+<summary>Solution</summary>
+The implementation is *almost* correct, the problem is that `front == end` can be true for two reasons:
+
+#. The queue is empty, no element have been added yet (hence, size should be 0),
+#. The queue is full, no element can be added (hence, size should be `mArray.Length`).
+
+Since `IsFull`, `IsEmpty` and `Capacity` all uses `size`, we have no way of telling if we are in the first or second situation. The rest of the implementation is correct, but `size` must be an attribute to be able to differenciate those two cases (note that we could also have added a `bool` to distinguish between "full" and "empty", but it's more convenient to have a `size` attribute available at all time).
+</details>

source/order

@@ -95,6 +95,7 @@
 ./exercises/data/
 ./exercises/data/1darrays.md
 ./exercises/data/2darrays.md
+./exercises/data/lists.md
 ./exercises/control/
 ./exercises/control/conditionals.md
 ./exercises/control/iteratives.md

source/solutions/data/lists.md

@@ -0,0 +1,111 @@
+---
+tags:
+  - datatypes/collections
+---
+
+# Lists (Solutions)
+
+## Multiple Choices
+
+#. Put a checkmark in the box corresponding to true statements about the List abstract data type.
+
+    - [ ] A list contains an finite collection of elements, in a particular order.
+    - [ ] A list cannot contain multiple elements with the same value.
+    - [x] A list must have a fixed number of elements.
+    - [x] A list is generally endowed with an operation to test for emptiness.
+    - [ ] Only the element at the beginning of a list can be removed.
+
+    
+    <details>
+    <summary>Comments on the solution</summary>
+    
+    - A list cannot contain an *infinite* collection of elements.
+    - A list can have repetition, the same value can be present multiple times.
+    - At any given time, a list has a fixed size.
+    - This is *generally* the case in definitions of lists.
+    - This restriction applies to queues or stacks (depending how "beginning" is interpreted), but not to lists.   
+    </details>
+  
+
+## Exercises
+
+#. Given the usual implementation of `Cell` and `CList`:
+
+    ```
+    public class CList<T>{
+        private Cell first;
+        private class Cell{
+            public T Data { get; set; }
+            public Cell Next { get; set; }
+            public Cell(T dataP, Cell nextP){Data = dataP; Next = nextP;}
+        }
+        public CList(){first = null;}
+    }
+    ``` 
+    Write…
+       
+    #. … a `IsEmpty` property that is `true` if the `CList` calling object is empty.
+    
+        <details>
+        <summary>Solution</summary>
+
+        Note that the question asks for a *property*: 
+        
+        ```
+        public bool IsEmpty{
+            get{ return first == null; }
+        }
+        ```
+        </details>
+    #. … the `AddF` method that add a cell at the beginning of the CList (to the left).
+
+        <details>
+        <summary>Solution</summary>
+
+        The key is to use the given `Cell` constructor to create the new element:
+        
+        ```
+        public void AddF(T dataP){
+            first = new Cell(dataP, first);
+        }
+        ```
+        </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>
+        <summary>Solution</summary>
+
+        Remembering that `IsEmpty` is a property, we obtain:
+        
+        ```
+        CList<char> myList1 = new CList<char>();
+        myList1.AddF('b');
+        myList1.AddF('/');
+        Console.WriteLine("myList1 is empty:" + myList1.IsEmpty);
+        ```
+        </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>
+    <summary>Solution</summary>
+    This property indicates whether the `ICollection<T>` is read-only: if set to `true`, the `ICollection<T>` object should not accept addition or removal of elements.
+    Hence, any method involving adding (`AddF`, `AddL`, …) or removing (`Clear`, `RemoveF`, `RemoveL`, `RemoveI`, …) values should test whether `IsReadonly` is `true` before proceeding.
+    </details>
+    
+#. Explain the main differences between singly linked list and doubly linked list, and name a few methods that need to be implemented differently.
+
+    <details>
+    <summary>Solution</summary>
+    Doubly linked lists use a `Cell` class that contains *two* references: in addition to containing a reference to the `Cell` coming "after" themselves, as in singly linked lists, they also contain a reference to the `Cell` that is "before" them. This also requires to manipulate two references for the list: in addition to one reference to the first element (now called `Head`), as in singly linked list, they contain a reference to the "last" element (called `Tail`).
+    
+    Clearing the list, adding and removing an element need to be implemented differently, as more references need to be updated.
+    </details>
+
+#. For what operation(s) does doubly linked list provide a complexity gain over singly linked list?
+
+    <details>
+    <summary>Solution</summary>
+    Inserting at the end of the list is $O(c)$ for doubly linked list, but $O(n)$ for singly linked list. 
+    In general, traversing the list in reverse order is less costly if the list is doubly linked.
+    </details>