Add a new trick

Author: LoneWandererProductions

ExtendedSystemObjects/IntArray.cs

@@ -126,89 +126,55 @@ public void RemoveAt(int index)
         ///     Removes all specified indices from the array
         /// </summary>
         /// <param name="indicesToRemove">The indices to remove.</param>
-        public void RemoveMultiple(int[] indicesToRemove)
+        /// <summary>
+        /// Removes multiple elements efficiently. If the indices are sequential and sorted,
+        /// uses a fast bulk-removal path. Otherwise falls back to element-wise compaction.
+        /// </summary>
+        /// <param name="indices">Indices to remove. Must be sorted and within bounds.</param>
+        public void RemoveMultiple(ReadOnlySpan<int> indices)
         {
-            if (indicesToRemove == null || indicesToRemove.Length == 0)
-            {
-                return;
-            }
+            if (indices.Length == 0) return;
 
-            // Sort indices ascending (important!)
-            Array.Sort(indicesToRemove);
+            // === Fast-path: Trivial sequential sequence ===
+            // If [3,4,5,6] then indices[^1] - indices[0] == indices.Length - 1
+            if (indices.Length > 1 && indices[^1] - indices[0] == indices.Length - 1)
+            {
+                int start = indices[0];
+                int count = indices.Length;
 
-            // Validate indices within bounds
 #if DEBUG
-            foreach (var idx in indicesToRemove)
-            {
-                if (idx < 0 || idx >= Length)
-                {
-                    throw new IndexOutOfRangeException($"Index {idx} is out of range.");
-                }
-            }
+                if (start < 0 || start + count > Length)
+                    throw new IndexOutOfRangeException();
 #endif
 
-            if (IsSequential(indicesToRemove))
-            {
-                // Optimized path for continuous block removal
-                var start = indicesToRemove[0];
-                var count = indicesToRemove.Length;
-
-                // Move tail elements left by count positions
-                var tailLength = Length - (start + count);
-                if (tailLength > 0)
-                {
-                    Buffer.MemoryCopy(
-                        _ptr + start + count,
-                        _ptr + start,
-                        tailLength * sizeof(int),
-                        tailLength * sizeof(int)
-                    );
-                }
+                int moveCount = Length - (start + count);
+                if (moveCount > 0)
+                    Buffer.MemoryCopy(_ptr + start + count, _ptr + start, moveCount * sizeof(int), moveCount * sizeof(int));
 
                 Length -= count;
+                return;
             }
-            else
-            {
-                // General multi-block removal, no assumption on indices continuity
 
-                var srcIndex = 0;
-                var dstIndex = 0;
+            // === Fallback: Compact array by skipping indices ===
+            int readIndex = 0, writeIndex = 0, removeIndex = 0;
 
-                foreach (var removeIndex in indicesToRemove)
+            while (readIndex < Length)
+            {
+                if (removeIndex < indices.Length && readIndex == indices[removeIndex])
                 {
-                    var lengthToCopy = removeIndex - srcIndex;
-
-                    if (lengthToCopy > 0)
-                    {
-                        Buffer.MemoryCopy(
-                            _ptr + srcIndex,
-                            _ptr + dstIndex,
-                            (Length - dstIndex) * sizeof(int),
-                            lengthToCopy * sizeof(int)
-                        );
-                        dstIndex += lengthToCopy;
-                    }
-
-                    srcIndex = removeIndex + 1;
+                    readIndex++;
+                    removeIndex++;
                 }
-
-                // Copy remaining tail block after last removed index
-                var tailLength = Length - srcIndex;
-                if (tailLength > 0)
+                else
                 {
-                    Buffer.MemoryCopy(
-                        _ptr + srcIndex,
-                        _ptr + dstIndex,
-                        (Length - dstIndex) * sizeof(int),
-                        tailLength * sizeof(int)
-                    );
-                    dstIndex += tailLength;
+                    _ptr[writeIndex++] = _ptr[readIndex++];
                 }
-
-                Length = dstIndex;
             }
+
+            Length = writeIndex;
         }
 
+
         /// <summary>
         ///     Resizes the internal array to the specified new size.
         ///     Contents will be preserved up to the minimum of old and new size.
@@ -242,31 +208,6 @@ public Span<int> AsSpan()
             return new((void*)_buffer, Length);
         }
 
-        /// <summary>
-        ///     Determines whether the specified sorted indices is sequential.
-        /// </summary>
-        /// <param name="sortedIndices">The sorted indices.</param>
-        /// <returns>
-        ///     <c>true</c> if the specified sorted indices is sequential; otherwise, <c>false</c>.
-        /// </returns>
-        private static bool IsSequential(IReadOnlyList<int> sortedIndices)
-        {
-            if (sortedIndices is not { Count: > 1 })
-            {
-                return true;
-            }
-
-            for (var i = 1; i < sortedIndices.Count; i++)
-            {
-                if (sortedIndices[i] != sortedIndices[i - 1] + 1)
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
         /// <summary>
         ///     Finalizes an instance of the <see cref="IntArray" /> class.
         /// </summary>

ExtendedSystemObjects/Utility.cs

@@ -255,58 +255,41 @@ public static List<KeyValuePair<int, int>> Sequencer(List<int> numbers, int sequ
         /// <returns>List of Sequences, with start and end index, null if none were found.</returns>
         public static List<KeyValuePair<int, int>> Sequencer(List<int> numbers, int stepWidth, int sequenceLength)
         {
+            if (numbers == null || numbers.Count == 0 || sequenceLength <= 1)
+                return null;
+
             numbers.Sort();
-            var max = numbers.Max();
+            var numberSet = new HashSet<int>(numbers);
 
-            var sequenceGroups = new List<List<int>>();
-            var currentSequence = new List<int>();
-            var observer = new List<int>();
+            var result = new List<KeyValuePair<int, int>>();
+            var visited = new HashSet<int>();
 
-            foreach (var element in numbers)
+            foreach (var num in numbers)
             {
-                var cache = Math.Abs(element);
-                var count = cache;
-
-                do
-                {
-                    if (currentSequence.Contains(cache))
-                    {
-                        break;
-                    }
-
-                    count += stepWidth;
-
-                    if (observer.Contains(count))
-                    {
-                        continue;
-                    }
-
-                    if (!numbers.Contains(count))
-                    {
-                        break;
-                    }
+                if (visited.Contains(num))
+                    continue;
 
-                    currentSequence.Add(count);
-                    observer.Add(count);
-                } while (count < max);
+                int current = num;
+                int streak = 1;
 
-                if (currentSequence.Count == 0)
+                // Try to build sequence by jumping stepWidth repeatedly
+                while (numberSet.Contains(current + stepWidth))
                 {
-                    continue;
+                    current += stepWidth;
+                    streak++;
                 }
 
-                currentSequence.AddFirst(cache);
-                sequenceGroups.Add(currentSequence);
-                currentSequence = new List<int>();
+                if (streak >= sequenceLength)
+                {
+                    result.Add(new KeyValuePair<int, int>(num, current));
+
+                    // Mark all in this sequence as visited to avoid duplicates
+                    for (int val = num; val <= current; val += stepWidth)
+                        visited.Add(val);
+                }
             }
 
-            return sequenceGroups.Count == 0
-                ? null
-                : (from stack in sequenceGroups
-                    where stack.Count >= sequenceLength
-                    let start = stack[0]
-                    let end = stack[^1]
-                    select new KeyValuePair<int, int>(start, end)).ToList();
+            return result.Count == 0 ? null : result;
         }
 
         /// <summary>