Revert "Optimize stage 1"

This reverts commit 89390c3.

Author: ngtduc693

Algorithms/Other/Luhn.cs

@@ -10,36 +10,62 @@ namespace Algorithms.Other;
 /// </summary>
 public static class Luhn
 {
-    // Checking the validity of a sequence of numbers.
+    /// <summary>
+    ///     Checking the validity of a sequence of numbers.
+    /// </summary>
+    /// <param name="number">The number that will be checked for validity.</param>
+    /// <returns>
+    ///     True: Number is valid.
+    ///     False: Number isn`t valid.
+    /// </returns>
     public static bool Validate(string number) => GetSum(number) % 10 == 0;
 
-    // Finds one missing digit. In place of the unknown digit, put "x".
+    /// <summary>
+    ///     This algorithm finds one missing digit.
+    ///     In place of the unknown digit, put "x".
+    /// </summary>
+    /// <param name="number">The number in which to find the missing digit.</param>
+    /// <returns>Missing digit.</returns>
     public static int GetLostNum(string number)
     {
-        var missingDigitIndex = number.Length - 1 - number.LastIndexOf('x');
-        var checkDigit = GetSum(number.Replace("x", "0")) * 9 % 10;
-
-        return missingDigitIndex % 2 == 0
-            ? checkDigit
-            : Validate(number.Replace("x", (checkDigit / 2).ToString()))
-                ? checkDigit / 2
-                : (checkDigit + 9) / 2;
+        var missingDigitIndex = number.Length - 1 - number.LastIndexOf("x", StringComparison.CurrentCultureIgnoreCase);
+        var checkDigit = GetSum(number.Replace("x", "0", StringComparison.CurrentCultureIgnoreCase)) * 9 % 10;
+
+        // Case 1: If the index of the missing digit is even.
+        if (missingDigitIndex % 2 == 0)
+        {
+            return checkDigit;
+        }
+
+        var candidateDigit = checkDigit / 2;
+
+        // Case 2: if the index of the missing digit is odd and the candidate is valid.
+        // Case 3: if the index of the missing digit is odd and we need the alternative.
+        return Validate(number.Replace("x", candidateDigit.ToString())) ? candidateDigit : (checkDigit + 9) / 2;
     }
 
-    // Computes the sum found by the Luhn algorithm, optimized with Span.
+    /// <summary>
+    ///     Computes the sum found by the Luhn algorithm.
+    /// </summary>
+    /// <param name="number">The number for which the sum will be calculated.</param>
+    /// <returns>Sum.</returns>
     private static int GetSum(string number)
     {
         var sum = 0;
-        var span = number.AsSpan();
-        for (var i = 0; i < span.Length; i++)
+        for (var i = 0; i < number.Length; i++)
         {
-            var c = span[i];
-            if (c is < '0' or > '9') continue;
-            var digit = c - '0';
-            digit = (i + span.Length) % 2 == 0 ? 2 * digit : digit;
-            if (digit > 9) digit -= 9;
+            var digit = number[i] - '0';
+            digit = (i + number.Length) % 2 == 0
+                ? 2 * digit
+                : digit;
+            if (digit > 9)
+            {
+                digit -= 9;
+            }
+
             sum += digit;
         }
+
         return sum;
     }
 }

DataStructures/BinarySearchTree/BinarySearchTree.cs

@@ -15,43 +15,88 @@ namespace DataStructures.BinarySearchTree;
 /// <typeparam name="TKey">Type of key for the BST. Keys must implement IComparable.</typeparam>
 public class BinarySearchTree<TKey>
 {
-    // Comparer to use when comparing node elements/keys.
+    /// <summary>
+    ///     Comparer to use when comparing node elements/keys.
+    /// </summary>
     private readonly Comparer<TKey> comparer;
 
-    // Gets the root of the BST.
+    /// <summary>
+    ///     Gets the root of the BST.
+    /// </summary>
     public BinarySearchTreeNode<TKey>? Root { get; private set; }
 
-    public BinarySearchTree() => (Root, Count, comparer) = (null, 0, Comparer<TKey>.Default);
+    public BinarySearchTree()
+    {
+        Root = null;
+        Count = 0;
+        comparer = Comparer<TKey>.Default;
+    }
 
-    public BinarySearchTree(Comparer<TKey> customComparer) => (Root, Count, comparer) = (null, 0, customComparer);
+    public BinarySearchTree(Comparer<TKey> customComparer)
+    {
+        Root = null;
+        Count = 0;
+        comparer = customComparer;
+    }
 
-    // Gets the number nodes currently in the BST.
+    /// <summary>
+    ///     Gets the number nodes currently in the BST.
+    /// </summary>
     public int Count { get; private set; }
 
-    // Insert a key into the BST.
+    /// <summary>
+    ///     Insert a key into the BST.
+    /// </summary>
+    /// <param name="key">The key to insert.</param>
+    /// <exception cref="ArgumentException">
+    ///     Thrown if key is already in BST.
+    /// </exception>
     public void Add(TKey key)
     {
         if (Root is null)
+        {
             Root = new BinarySearchTreeNode<TKey>(key);
+        }
         else
+        {
             Add(Root, key);
+        }
+
         Count++;
     }
 
-    // Insert multiple keys into the BST.
+    /// <summary>
+    ///     Insert multiple keys into the BST.
+    ///     Keys are inserted in the order they appear in the sequence.
+    /// </summary>
+    /// <param name="keys">Sequence of keys to insert.</param>
     public void AddRange(IEnumerable<TKey> keys)
     {
         foreach (var key in keys)
+        {
             Add(key);
+        }
     }
 
-    // Find a node with the specified key.
+    /// <summary>
+    ///     Find a node with the specified key.
+    /// </summary>
+    /// <param name="key">The key to search for.</param>
+    /// <returns>The node with the specified key if it exists, otherwise a default value is returned.</returns>
     public BinarySearchTreeNode<TKey>? Search(TKey key) => Search(Root, key);
 
-    // Checks if the specified key is in the BST.
+    /// <summary>
+    ///     Checks if the specified key is in the BST.
+    /// </summary>
+    /// <param name="key">The key to search for.</param>
+    /// <returns>true if the key is in the BST, false otherwise.</returns>
     public bool Contains(TKey key) => Search(Root, key) is not null;
 
-    // Removes a node with a key that matches key.
+    /// <summary>
+    ///     Removes a node with a key that matches <paramref name="key" />.
+    /// </summary>
+    /// <param name="key">The key to search for.</param>
+    /// <returns>true if the removal was successful, false otherwise.</returns>
     public bool Remove(TKey key)
     {
         if (Root is null)

DataStructures/Timeline.cs

@@ -12,6 +12,7 @@ this data structure can be used to represent an ordered series of dates or times
             330: Constantine move the capital to Constantinople.
 */
 
+using System.Collections;
 
 namespace DataStructures;
 
@@ -22,39 +23,83 @@ namespace DataStructures;
 /// <typeparam name="TValue">Value associated with a <see cref="DateTime" />.</typeparam>
 public class Timeline<TValue> : ICollection<(DateTime Time, TValue Value)>, IEquatable<Timeline<TValue>>
 {
-    // Inner collection storing the timeline events as key-tuples.
-    private List<(DateTime Time, TValue Value)> timeline = [];
+    /// <summary>
+    ///     Inner collection storing the timeline events as key-tuples.
+    /// </summary>
+    private readonly List<(DateTime Time, TValue Value)> timeline = new();
 
-    // Default constructor
-    public Timeline() { }
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="Timeline{TValue}"/> class.
+    /// </summary>
+    public Timeline()
+    {
+    }
 
-    // Constructor with initial event
-    public Timeline(DateTime time, TValue value) => timeline = [(time, value)];
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="Timeline{TValue}"/> class populated with an initial event.
+    /// </summary>
+    /// <param name="time">The time at which the given event occurred.</param>
+    /// <param name="value">The event's content.</param>
+    public Timeline(DateTime time, TValue value)
+        => timeline = new List<(DateTime, TValue)>
+        {
+            (time, value),
+        };
 
-    // Constructor with provided events, ordered chronologically
-    public Timeline(params (DateTime, TValue)[] timeline) => this.timeline = timeline.OrderBy(pair => pair.Item1).ToList();
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="Timeline{TValue}"/> class containing the provided events
+    ///     ordered chronologically.
+    /// </summary>
+    /// <param name="timeline">The timeline to represent.</param>
+    public Timeline(params (DateTime, TValue)[] timeline)
+        => this.timeline = timeline
+            .OrderBy(pair => pair.Item1)
+            .ToList();
 
-    // Gets the number of unique times within this timeline.
-    public int TimesCount => GetAllTimes().Length;
+    /// <summary>
+    /// Gets he number of unique times within this timeline.
+    /// </summary>
+    public int TimesCount
+        => GetAllTimes().Length;
 
-    // Gets all events that has occurred in this timeline.
-    public int ValuesCount => GetAllValues().Length;
+    /// <summary>
+    ///     Gets all events that has occurred in this timeline.
+    /// </summary>
+    public int ValuesCount
+        => GetAllValues().Length;
 
-    // Get or set all values associated with a time
+    /// <summary>
+    ///     Get all values associated with <paramref name="time" />.
+    /// </summary>
+    /// <param name="time">Time to get values for.</param>
+    /// <returns>Values associated with <paramref name="time" />.</returns>
     public TValue[] this[DateTime time]
     {
         get => GetValuesByTime(time);
         set
         {
-            timeline.RemoveAll(@event => @event.Time == time);
+            var overridenEvents = timeline.Where(@event => @event.Time == time).ToList();
+            foreach (var @event in overridenEvents)
+            {
+                timeline.Remove(@event);
+            }
+
             foreach (var v in value)
+            {
                 Add(time, v);
+            }
         }
     }
 
-    bool ICollection<(DateTime Time, TValue Value)>.IsReadOnly => false;
+    /// <inheritdoc />
+    bool ICollection<(DateTime Time, TValue Value)>.IsReadOnly
+        => false;
 
-    public int Count => timeline.Count;
+    /// <summary>
+    ///     Gets the count of pairs.
+    /// </summary>
+    public int Count
+        => timeline.Count;
 
     /// <summary>
     ///     Clear the timeline, removing all events.