Získajte poslednú duplicitné prvok v zozname

Jeden spôsob, ako to urobiť, by bolo použiť Index položka v pôvodnej kolekcie spolu s GroupBy. Napríklad,

    var lastDistinct = filterList.Select((x,index)=> new {Value=x,Index=index})
                                 .GroupBy(x=>x.Value)
                                 .Select(x=> x.Last())
                                 .OrderBy(x=>x.Index)
                                 .Select(x=>x.Value);
    var result = string.Join(",",lastDistinct);

Výstup

access,postpone,success

Váš vstup, zoznam je len typu string, tak pomocou groupBy nie je naozaj nič pridávať. Ak si myslíte, že je váš kód, váš prvý riadok vám dáva odlišné zoznam, môžete iba stratiť, rôzne predmety, pretože ste reťazec.pripojte sa na riadku 2. Všetko, čo musíte urobiť, je pridať riadok predtým, než ste sa pripojili:

List<string> filter = filterList.Distinct().ToList();
string last = filter.LastOrDefault();
string a = string.Join(",", filter.Select(a => a).ToArray());
Console.WriteLine(a);

Myslím, že by ste mohli urobiť váš kód viac jadrný, pretože budete potrebovať ani jedno .Vyberte položku(a => a) ani nebude .ToArray() v call reťazec.Pripoj sa.

GroupBy by sa použiť ak by ste mali zoznam triedy/struct/záznam/n-tice položky, kde by ste skupiny konkrétny kláves (alebo klávesy), skôr než pomocou Odlišné() na celú vec. GroupBy je veľmi užitočné, a vy by ste sa dozvedeli, že, a tiež ToDictionary a ToLookup LINQ pomocné funkcie.

Je OrderedDictionary to. Všetko, čo musíte urobiť, je pridať vaše položky, aby to s logikou "ak je to v slovníku, vyberte ju. pridať". OrderedDictionary zachováva poradie pridanie takže odstránením staršej pridané na jeden a re-pridanie skočí do konca slovník

var d = new OrderedDictionary();
filterList.ForEach(x => { if(d.Contains(x)) d.Remove(x); d[x] = null; });

Vaše d.Keys teraz je zoznam reťazcov

access
postpone
success

OrderedDictionary je v Collections.Specialized menný priestor

Ak ste chceli tlačidiel ako CSV, môžete použiť Cast aby sa obrátili od objektu k reťazec

var s = string.Join(",", d.Keys.Cast<string>());

Tak prečo by nemal vrátite prvý výskyt "odložiť"? Pretože neskôr v poradí vidíte, to isté slovo "odložiť" znova. Prečo by ste vrátiť prvý výskyt "prístup"? Pretože neskôr v poradí nevidíte toto slovo už.

Takže: návrat slovo, ak zvyšok postupnosti nemá toto slovo.

To by bolo jednoduché, v LINQ, s rekurzie, ale to nie je veľmi efektívny: pre každé slovo, ktoré by ste mali skontrolovať, zvyšok postupnosti zistiť, či slovo je v pokoji.

To by bolo tak účinnejší, aby si najvyšší index, na ktorom ste našli slovo.

Ako rozšírenie metódy. Ak nie ste oboznámení s príponou metódy, pozri rozšírenie metódy demystified.

private static IEnumerable<T> FindLastOccurences<T>(this IEnumerable<T> source)
{
    return FindLastOccurrences<T>(source, null);
}

private static IEnumerable<T> FindLastOccurences<T>(this IEnumerable<T> source,
    IEqualityComparer<T> comparer)
{
    // TODO: check source not null
    if (comparer == null) comparer = EqualityComparer<T>.Default;

    Dictionary<T, int> dictionary = new Dictionary<T, int>(comparer);

    int index = 0;
    foreach (T item in source)
    {
        // did we already see this T? = is this in the dictionary
        if (dictionary.TryGetValue(item, out int highestIndex))
        {
            // we already saw it at index highestIndex.
            dictionary[item] = index;
        }
        else
        {
            // it is not in the dictionary, we never saw this item.
            dictionary.Add(item, index);
        }
        ++index;
    }

    // return the keys after sorting by value (which contains the highest index)
    return dictionay.OrderBy(keyValuePair => keyValuePair.Value)
                    .Select(keyValuePair => keyValuePair.Key);
}
         

Takže pre každý bod v zdrojovej postupnosti, sme skontrolovať, či je v slovníku. Ak nie, sme pridať položku ako kľúč do slovníka. Hodnota indexu.

Ak je už v slovníku, potom hodnota bol najvyšší index, kde sme našli táto položka predtým. Zrejme aktuálneho indexu je vyššia, a tak sme sa nahradiť hodnotu v slovníku.

Konečne sme, aby kľúčové hodnoty páry v slovníku vzostupne hodnotu, a vrátiť sa iba kľúče.