webentwicklung-frage-antwort-db.com.de

Wie überprüfe ich, ob mein Array wiederholte Werte enthält?

Also hier ist mein Array.

double[] testArray = new double[10];
// will generate a random numbers from 1-20, too lazy to write the code

Ich möchte eine Suchschleife erstellen, um zu überprüfen, ob Werte wiederholt werden. Wie mache ich das?

Ich würde es vorziehen, keine speziellen eingebauten Methoden zu verwenden, da dies ein kleines Array ist.

c#arraysrepeat
9
puretppc

Sie könnten dies mit einem kleinen Linq tun:

if (testArray.Length != testArray.Distinct().Count())
{
    Console.WriteLine("Contains duplicates");
}

Die Distinct Erweiterungsmethode entfernt alle Duplikate, und Count ruft die Größe der Ergebnismenge ab. Wenn sie sich überhaupt unterscheiden, enthält die Liste einige Duplikate.

Alternativ ist die Abfrage hier etwas komplizierter, aber möglicherweise effizienter:

if (testArray.GroupBy(x => x).Any(g => g.Count() > 1))
{
    Console.WriteLine("Contains duplicates");
}

Die Methode GroupBy gruppiert identische Elemente und Any gibt true zurück, wenn eine der Gruppen mehr als ein Element enthält.

Beide oben genannten Lösungen funktionieren mit einem HashSet<T> , Sie können jedoch auch einen solchen direkt verwenden:

if (!testArray.All(new HashSet<double>().Add))
{
    Console.WriteLine("Contains duplicates");
}

Oder wenn Sie eine Lösung bevorzugen, die sich überhaupt nicht auf Linq verlässt:

var hashSet = new HashSet<double>();
foreach(var x in testArray) 
{
    if (!hashSet.Add(x)) 
    {
        Console.WriteLine("Contains duplicates");
        break;
    }
}
27
p.s.w.g

Generische Erweiterungsmethode:

public static bool HasDuplicate<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer)
{
    if (source == null)
        throw new ArgumentException(nameof(source));

    HashSet<T> set = new HashSet<T>(comparer);
    foreach (var item in source)
        if (!set.Add(item))
            return true;

    return false;
}
2
Ali Bayat

schauen Sie sich meine Implementierung an: generic und efficient

public static bool HasDuplicates<T>(IList<T> items)
    {
        Dictionary<T, bool> map = new Dictionary<T, bool>();
        for (int i = 0; i < items.Count; i++)
        {
            if (map.ContainsKey(items[i]))
            {
                return true; // has duplicates
            }
            map.Add(items[i], true);
        }
        return false; // no duplicates
    }

hier sind einige Anrufe

string[] strings = new[] { "1", "2", "3" };
Utility.HasDuplicates(strings)// this will return false

int[] items=new []{1,2,3,1};
Utility.HasDuplicates(items)// this will return true
1
Basheer AL-MOMANI

Benutze das:

bool CheckUniqueness(double[] values)
{
    var uniqueValues = new HashSet<double>();
    foreach (double d in values)
    {
        if(uniqueValues.Contains(d))
        {
            return false;
        }
        uniqueValues.Add(d);
    }
    return true;
}
1
helb

Wir müssen j aus i in der ersten Schleife initialisieren und eine (i + 1) hinzufügen, da wir den ersten Schleifenwert mit dem nächsten Wert desselben Arrays vergleichen möchten.

int[] arr = new int[]{1,2,3,1,4,2,5,4};

//create one loop for arr values
for (int i = 0;  i < arr.Length; i++)
{
    //create nested loop for compare current values with actual value of arr
    for (int j = i+1; j < arr.Length; j++)
    {

        //and here we put our condition
        if (arr[i] == arr[j])
        {
            Console.WriteLine(arr[i]);
        }
    }
}
0
Javidan Akberov

Mit (OP) 10 verdoppelt sich der Zufall ziemlich schnell. Die Chance einer Wiederholung: ~ 0,000002%.

static bool repeat(double[] a)
{
    return
        a[0] == a[1] || a[0] == a[2] || a[0] == a[3] || a[0] == a[4] ||
        a[0] == a[5] || a[0] == a[6] || a[0] == a[7] || a[0] == a[8] ||
        a[0] == a[9] || a[1] == a[2] || a[1] == a[3] || a[1] == a[4] ||
        a[1] == a[5] || a[1] == a[6] || a[1] == a[7] || a[1] == a[8] ||
        a[1] == a[9] || a[2] == a[3] || a[2] == a[4] || a[2] == a[5] ||
        a[2] == a[6] || a[2] == a[7] || a[2] == a[8] || a[2] == a[9] ||
        a[3] == a[4] || a[3] == a[5] || a[3] == a[6] || a[3] == a[7] ||
        a[3] == a[8] || a[3] == a[9] || a[4] == a[5] || a[4] == a[6] ||
        a[4] == a[7] || a[4] == a[8] || a[4] == a[9] || a[5] == a[6] ||
        a[5] == a[7] || a[5] == a[8] || a[5] == a[9] || a[6] == a[7] ||
        a[6] == a[8] || a[6] == a[9] || a[7] == a[8] || a[7] == a[9] ||
        a[8] == a[9];
}

Allgemeiner, mit 10 Zahlen ~ 2 mal langsamer als oben,
aber ~ 7 mal schneller als der Hashset-Ansatz.

static bool repeat(double[] a)
{
    int k = a.Length - 1;
    if (k < 70)
    {
        double aj;
        for (int i = 0, j; i < k; )
        {
            for (aj = a[k--], j = k; j >= i; j--)
                if (aj == a[j]) return true;
            for (aj = a[i++], j = i; j <= k; j++)
                if (aj == a[j]) return true;
        }
        return false;
    }
    var h = new HashSet<double>();
    while (k >= 0) if (!h.Add(a[k--])) return false;
    return true;
}

Zwei Zeilen (langsam mit einer Wiederholung;)

static bool repeat(double[] a)
{ return (new HashSet<double>(a).Count < a.Length); }
0
P_P