Testen Sie, ob alle Werte in einer Liste eindeutig sind

Ich habe eine kleine Liste von Bytes und möchte testen, ob sie alle unterschiedliche Werte haben. Zum Beispiel habe ich Folgendes:

List<byte> theList = new List<byte> { 1,4,3,6,1 };

Wie kann am besten überprüft werden, ob alle Werte unterschiedlich sind oder nicht?

bool isUnique = theList.Distinct().Count() == theList.Count();

Hier ist ein anderer Ansatz, der effizienter als Enumerable.Distinct+ ist Enumerable.Count(umso mehr, wenn die Sequenz kein Sammlungstyp ist). Es verwendet a, HashSet<T>das Duplikate eliminiert, bei der Suche sehr effizient ist und eine count-Eigenschaft hat:

var distinctBytes = new HashSet<byte>(theList);
bool allDifferent = distinctBytes.Count == theList.Count;

oder ein anderer - subtilerer und effizienterer - Ansatz:

var diffChecker = new HashSet<byte>();
bool allDifferent = theList.All(diffChecker.Add);

HashSet<T>.AddGibt zurück, falsewenn das Element nicht hinzugefügt werden konnte, da es bereits in der enthalten war HashSet. Enumerable.Allstoppt beim ersten "false".

Okay, hier ist die effizienteste Methode, die ich mir vorstellen kann, Standard .Net zu verwenden

using System;
using System.Collections.Generic;

public static class Extension
{
    public static bool HasDuplicate<T>(
        this IEnumerable<T> source,
        out T firstDuplicate)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }

        var checkBuffer = new HashSet<T>();
        foreach (var t in source)
        {
            if (checkBuffer.Add(t))
            {
                continue;
            }

            firstDuplicate = t;
            return true;
        }

        firstDuplicate = default(T);
        return false;
    }
}

Im Wesentlichen müssen Sie die gesamte Sequenz zweimal aufzählen, wenn Sie nur das erste Duplikat finden möchten.

Ich könnte dies weiter optimieren, indem ich eine leere und eine einzelne Elementsequenz speziell umhülle, aber dies würde die Lesbarkeit / Wartbarkeit mit minimalem Gewinn beeinträchtigen.

Die ähnliche Logik wie bei der DistinctVerwendung von GroupBy:

var isUnique = theList.GroupBy(i => i).Count() == theList.Count;

Man kann auch: Hashset verwenden

var uniqueIds = new HashSet<long>(originalList.Select(item => item.Id));

            if (uniqueIds.Count != originalList.Count)
            {
            }

Es gibt viele Lösungen.

Und zweifellos schönere mit der Verwendung von LINQ als "juergen d" und "Tim Schmelter" erwähnt.

Wenn Sie jedoch "Komplexität" und Geschwindigkeit haben, ist es die beste Lösung, diese selbst zu implementieren. Eine der Lösungen besteht darin, ein Array mit einer Größe von N zu erstellen (für Byte sind es 256). Und Schleife des Arrays, und bei jeder Iteration wird der Index der übereinstimmenden Zahlen getestet, wenn der Wert 1 ist, wenn dies der Fall ist. Das bedeutet, dass ich den Array-Index bereits inkrementiere und daher das Array nicht eindeutig ist, andernfalls inkrementiere ich die Array-Zelle und setze die Überprüfung fort .

Und eine andere Lösung, wenn Sie doppelte Werte finden möchten.

var values = new [] { 9, 7, 2, 6, 7, 3, 8, 2 };

var sorted = values.ToList();
sorted.Sort();
for (var index = 1; index < sorted.Count; index++)
{
    var previous = sorted[index - 1];
    var current = sorted[index];
    if (current == previous)
        Console.WriteLine(string.Format("duplicated value: {0}", current));
}

Ausgabe:

duplicated value: 2
duplicated value: 7

http://rextester.com/SIDG48202

Ich überprüfe, ob eine IEnumerable (aray, list, etc) wie folgt eindeutig ist:

var isUnique = someObjectsEnum.GroupBy(o => o.SomeProperty).Max(g => g.Count()) == 1;