Optimize stage 1

Author: ducnt7-rks

Algorithms/Other/Luhn.cs

@@ -10,62 +10,36 @@ namespace Algorithms.Other;
 /// </summary>
 public static class Luhn
 {
-    /// <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>
+    // Checking the validity of a sequence of numbers.
     public static bool Validate(string number) => GetSum(number) % 10 == 0;
 
-    /// <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>
+    // Finds one missing digit. In place of the unknown digit, put "x".
     public static int GetLostNum(string number)
     {
-        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;
+        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;
     }
 
-    /// <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>
+    // Computes the sum found by the Luhn algorithm, optimized with Span.
     private static int GetSum(string number)
     {
         var sum = 0;
-        for (var i = 0; i < number.Length; i++)
+        var span = number.AsSpan();
+        for (var i = 0; i < span.Length; i++)
         {
-            var digit = number[i] - '0';
-            digit = (i + number.Length) % 2 == 0
-                ? 2 * digit
-                : digit;
-            if (digit > 9)
-            {
-                digit -= 9;
-            }
-
+            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;
             sum += digit;
         }
-
         return sum;
     }
 }

DataStructures/BinarySearchTree/BinarySearchTree.cs

@@ -15,88 +15,43 @@ namespace DataStructures.BinarySearchTree;
 /// <typeparam name="TKey">Type of key for the BST. Keys must implement IComparable.</typeparam>
 public class BinarySearchTree<TKey>
 {
-    /// <summary>
-    ///     Comparer to use when comparing node elements/keys.
-    /// </summary>
+    // Comparer to use when comparing node elements/keys.
     private readonly Comparer<TKey> comparer;
 
-    /// <summary>
-    ///     Gets the root of the BST.
-    /// </summary>
+    // Gets the root of the BST.
     public BinarySearchTreeNode<TKey>? Root { get; private set; }
 
-    public BinarySearchTree()
-    {
-        Root = null;
-        Count = 0;
-        comparer = Comparer<TKey>.Default;
-    }
+    public BinarySearchTree() => (Root, Count, comparer) = (null, 0, Comparer<TKey>.Default);
 
-    public BinarySearchTree(Comparer<TKey> customComparer)
-    {
-        Root = null;
-        Count = 0;
-        comparer = customComparer;
-    }
+    public BinarySearchTree(Comparer<TKey> customComparer) => (Root, Count, comparer) = (null, 0, customComparer);
 
-    /// <summary>
-    ///     Gets the number nodes currently in the BST.
-    /// </summary>
+    // Gets the number nodes currently in the BST.
     public int Count { get; private set; }
 
-    /// <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>
+    // Insert a key into the BST.
     public void Add(TKey key)
     {
         if (Root is null)
-        {
             Root = new BinarySearchTreeNode<TKey>(key);
-        }
         else
-        {
             Add(Root, key);
-        }
-
         Count++;
     }
 
-    /// <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>
+    // Insert multiple keys into the BST.
     public void AddRange(IEnumerable<TKey> keys)
     {
         foreach (var key in keys)
-        {
             Add(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>
+    // Find a node with the specified key.
     public BinarySearchTreeNode<TKey>? Search(TKey key) => Search(Root, key);
 
-    /// <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>
+    // Checks if the specified key is in the BST.
     public bool Contains(TKey key) => Search(Root, key) is not null;
 
-    /// <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>
+    // Removes a node with a key that matches key.
     public bool Remove(TKey key)
     {
         if (Root is null)

DataStructures/Timeline.cs

@@ -12,7 +12,6 @@ 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;
 
@@ -23,83 +22,39 @@ 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>>
 {
-    /// <summary>
-    ///     Inner collection storing the timeline events as key-tuples.
-    /// </summary>
-    private readonly List<(DateTime Time, TValue Value)> timeline = new();
+    // Inner collection storing the timeline events as key-tuples.
+    private List<(DateTime Time, TValue Value)> timeline = [];
 
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="Timeline{TValue}"/> class.
-    /// </summary>
-    public Timeline()
-    {
-    }
+    // Default constructor
+    public Timeline() { }
 
-    /// <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 initial event
+    public Timeline(DateTime time, TValue value) => timeline = [(time, value)];
 
-    /// <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();
+    // Constructor with provided events, ordered chronologically
+    public Timeline(params (DateTime, TValue)[] timeline) => this.timeline = timeline.OrderBy(pair => pair.Item1).ToList();
 
-    /// <summary>
-    /// Gets he number of unique times within this timeline.
-    /// </summary>
-    public int TimesCount
-        => GetAllTimes().Length;
+    // Gets the number of unique times within this timeline.
+    public int TimesCount => GetAllTimes().Length;
 
-    /// <summary>
-    ///     Gets all events that has occurred in this timeline.
-    /// </summary>
-    public int ValuesCount
-        => GetAllValues().Length;
+    // Gets all events that has occurred in this timeline.
+    public int ValuesCount => GetAllValues().Length;
 
-    /// <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>
+    // Get or set all values associated with a time
     public TValue[] this[DateTime time]
     {
         get => GetValuesByTime(time);
         set
         {
-            var overridenEvents = timeline.Where(@event => @event.Time == time).ToList();
-            foreach (var @event in overridenEvents)
-            {
-                timeline.Remove(@event);
-            }
-
+            timeline.RemoveAll(@event => @event.Time == time);
             foreach (var v in value)
-            {
                 Add(time, v);
-            }
         }
     }
 
-    /// <inheritdoc />
-    bool ICollection<(DateTime Time, TValue Value)>.IsReadOnly
-        => false;
+    bool ICollection<(DateTime Time, TValue Value)>.IsReadOnly => false;
 
-    /// <summary>
-    ///     Gets the count of pairs.
-    /// </summary>
-    public int Count
-        => timeline.Count;
+    public int Count => timeline.Count;
 
     /// <summary>
     ///     Clear the timeline, removing all events.