‫راهنمای تشخیص تکراری‌ها در لیست‌ها

bool HasDuplicateBruteForce<T>(IList<T> list)
{
    for (int i = 0; i < list.Count - 1; i++)
        for (int j = i + 1; j < list.Count; j++)
            if (EqualityComparer<T>.Default.Equals(list[i], list[j]))
                return true;
    return false;
}

• پیچیدگی زمانی (Time Complexity): O(n2)
• مصرف حافظه (Memory Usage): صفر حافظه اضافی.
• کاربرد: فقط برای مجموعه‌های بسیار کوچک (کمتر یا مساوی ۱۰ عنصر) قابل استفاده است.

bool HasDuplicateHashSet<T>(IEnumerable<T> source)
{
    var seen = new HashSet<T>();
    foreach (var item in source)
        if (!seen.Add(item))   // Add returns false if already present
            return true;
    return false;
}

• پیچیدگی زمانی: O(n)
• مصرف حافظه: یک HashSet<T> به اندازه تعداد عناصر منحصربه‌فرد.
• مزیت اصلی: قابلیت خروج زودهنگام (Early-Exit)، به این معنا که الگوریتم به محض یافتن اولین تکراری متوقف می‌شود که در لیست‌های بزرگ با تکراری‌های در ابتدا بسیار کارآمد است.

bool HasDuplicateAny<T>(IEnumerable<T> src)
{
    var seen = new HashSet<T>();
    return src.Any(item => !seen.Add(item));
}

• خوانایی: بسیار خوانا و مختصر.
• عملکرد: کمی کندتر از حلقه ForEach به دلیل سربار (overhead) استفاده از لامبدا (lambda).

bool HasDuplicateAll<T>(IEnumerable<T> src)
{
    var seen = new HashSet<T>();
    return !src.All(item => seen.Add(item)); // All returns false when Add fails
}

• خوانایی: تک‌عبارتی.
• عملکرد: مشابه LINQ Any، کمی کندتر از حلقه ForEach.

bool HasDuplicateGroupBy<T>(IEnumerable<T> src) =>
    src.GroupBy(x => x).Any(g => g.Count() > 1);

• پیچیدگی زمانی: O(n)، اما شامل سربار ایجاد گروه‌ها است.
• مصرف حافظه: متوسط، زیرا از Lookup داخلی استفاده می‌کند که تخصیص‌های اضافی (extra allocations) دارد.
• محدودیت: فاقد خروج زودهنگام است و باید کل مجموعه را پیمایش کند.

bool HasDuplicateDistinct<T>(ICollection<T> src) =>
    src.Count != src.Distinct().Count();

• پیچیدگی زمانی: O(n)، اما Distinct ممکن است دو بار پیمایش کند یا تمام عناصر را یک بار ذخیره کند.
• محدودیت: فاقد خروج زودهنگام است و باید کل مجموعه را پیمایش کند.

bool HasDuplicateToHashSet<T>(ICollection<T> src) =>
    src.Count != src.ToHashSet().Count;

• پیچیدگی زمانی: O(n)
• مصرف حافظه: یک HashSet<T> کامل به اندازه تمام عناصر منحصر به فرد.
• مزیت: زمان اجرا ثابت (constant time) بدون توجه به موقعیت تکراری‌ها، مناسب برای سناریوهایی که نیاز به تأخیر (latency) یکنواخت دارند.

bool HasDuplicateCtor<T>(ICollection<T> src) =>
    src.Count != new HashSet<T>(src).Count;

• پیچیدگی زمانی: O(n)
• مصرف حافظه: یک HashSet<T> کامل.
• مزیت: مشابه ToHashSet, زمان اجرای ثابت و مناسب برای تأخیر یکنواخت.

• زمان اجرای متوسط (Median Times): نتایج بنچمارک با استفاده از ابزاری مانند Benchmark.NET نشان می‌دهد که در لیست‌های با 100 تا 10,000 عنصر، روش‌های مبتنی بر HashSet (مانند ForEach + HashSet یا Any() + HashSet) به‌طور قابل توجهی سریع‌تر از Brute Force هستند. Brute Force در لیست‌های بزرگ به شدت کند می‌شود.
• مزیت خروج زودهنگام (Early-Exit Advantage): در سناریوهایی که احتمالاً اولین تکراری در اوایل لیست قرار دارد، روش‌های با قابلیت خروج زودهنگام (مثل ForEach + HashSet, Any() + HashSet, All() + HashSet) به شدت سریع‌تر عمل می‌کنند، زیرا به محض یافتن تکراری، پیمایش را متوقف می‌کنند.
• مصرف حافظه: روش‌هایی مانند GroupBy(), Distinct(), ToHashSet(), و HashSet Constructor که کل لیست را در حافظه اضافی ذخیره می‌کنند، مصرف حافظه بالاتری دارند. اگرچه برای لیست‌های بزرگتر و تأخیر یکنواخت مفید هستند، اما در سناریوهای حساس به حافظه باید با احتیاط استفاده شوند.

• اگر خروج زودهنگام مطلوب است (اولین تکراری در اوایل لیست محتمل است):ForEach + HashSet بهترین انتخاب است.
• برای تأخیر یکنواخت (مناسب برای API‌ها و میکروسرویس‌ها):src.ToHashSet().Count یا new HashSet توصیه می‌شود. این روش‌ها زمان اجرای ثابتی دارند، بدون توجه به اینکه تکراری کجای لیست قرار دارد.
• برای سادگی کد و خوانایی (Code Golf / Readability):Any() + HashSet انتخاب خوبی است.
• برای مجموعه‌های بسیار کوچک (le10): حتی Brute Force هم قابل قبول است، اما بهتر است عادت استفاده از روش‌های کارآمدتر را داشته باشید.
• در پایپ‌لاین‌های (pipelines) فقط LINQ:Distinct().Count می‌تواند استفاده شود، اما حتماً عملکرد آن را اندازه‌گیری کنید.
• حساسیت به حافظه: از روش‌های HashSet با خروج زودهنگام استفاده کنید و از GroupBy یا Distinct خودداری کنید.

• پیش‌تخصیص ظرفیت (Pre-allocate Capacity): اگر تعداد تقریبی عناصر منحصربه‌فرد را می‌دانید، می‌توانید ظرفیت اولیه HashSet را هنگام ایجاد آن تنظیم کنید (مانند new HashSet). این کار می‌تواند تخصیص‌های حافظه و بازسازی‌های داخلی را کاهش دهد.
• اجتناب از LINQ در مسیرهای حساس (Hot Paths): در بخش‌هایی از کد که عملکرد حیاتی است، از LINQ خودداری کنید، زیرا سربار لامبدا (lambda) و تخصیص‌های پنهان ممکن است بر عملکرد تأثیر بگذارند.