C#-ban hogyan lehet egy listában megkeresni azokat a számokat, amikből kettő van?

#1, egy ilyen feladathoz egészen biztosan nem LINQ kell, de ha a Kérdező véletlen önmagától szórakozik ilyen feladatokkal, mert tanulni akar, akkor se hinném, hogy LINQ-val akarná megoldani.

Egyébként ez egy eldöntés és kiválogatás tétele nagyjából (és asszem), két for ciklus, a belső i+1-től indul, végigmenni és megszámolni (sőt, igazából a belső while i+1-től, igazából így eldöntés, ha már megvan a 3. az i-edikből, tehát éppen aktuális számból, akkor nem kell tovább menni és azt a számot nem kell kiválogatni. Ha végigértél és csak 1 db volt, maga az i., akkor nem kell kiválogatni. Ha kettő volt, beteszed abba a kollekcióba, amibe kiválogatsz.

De kedvet kaptam megírni C-ben. :D

((Egyébként biztosan túlbonyolítom.))

Elsőre jónak tűnik:

https://pastebin (pont) com/fYRxeVKX

Szóval for ciklussal végigmész a számokon.

Amelyiknél tartasz, ott egyrészt megnézed, hogy korábban vizsgáltad-e már (amíg ezt nem néztem, olyan számot is kiadott, amiből 3 db vagy több volt), másrészt megnézed, hogy a továbbiakban hány db lesz belőle. Én addig mentem el while-al, amíg csak kettőt talált, amint megvolt a harmadik, kiléptem.

Már ha jól értem a feladatot, és az a kérdés, hogy melyekből van _pontosan_ kettő.

A programozási nyelvért bocsi, de nagyon hasonló a szintaktikája. ;)

Aki meg idetéved, ne legyen rosszul attól, ahogyan a C-t használom. :D :D

Tehát

- végigmész a listán

- az aktuális elem utáni elemtől kezdve megnézed van-e ugyanolyan mint az aktuális

- ha nincs, nem számít

- ha van megnézed mi volt már korábban egy 3. beágyazott ciklussal...

szerintem túlbonyolítod, illetve nem logikus a kódod, bár működik.

Simán nézd meg 2 egymásba ágyazott ciklussal, elejétől végéig. Az hogy i+1-től nézed bonyolítás, hiszen később meg kell nézni a korábbi elemeket is. (Nyilván az optimalizációkat érdemes berakni, max 3 elemig nézni, illetve ha olyan számot nézünk mint ami már volt azon túllépni)

A te kódodat, változóidat felhasználva, pl így:

    int i, j, idx = 0, count, index;

    for (i = 0; i < len; ++i)

    {

        // számoljuk meg hány olyan van ami == num[i]-vel, de max 3-ig számoljunk

        count = 0;

        for (j = 0; j < len && count < 3; ++j)

        {

            if (nums[i] == nums[j])

            {

                if (j < i)

                {

                    // ez a szám már volt korábban

                    break;

                }

                count++;

            }

        }

        if (count == 2)

        {

            doubles[idx] = nums[i];

            ++idx;                    

        }

    }

    return idx;

Örömmel látom, hogy mindkét változat működik C#-ban is:

[link]

Kíváncsi vagyok Kérdező kódjára, most az egyszer nyilván nem fog eltűnni a balfenéken, ahogy szokott.

Optimális megoldást akkor lehetne mondani, ha ismernénk a részleteket. Milyen intervallumba tartoznak a számok, hány db lehet a listában, amiből nem kettő van abból bármennyi lehet-e vagy mondjuk csak 1 vagy 3 stb.

A négyzetes komplexitású megoldáshoz meg illene odaírni azért megjegyzésként, hogy oké, hogy működik, de performancia szempontjából az egyik legrosszabb megoldás.

Remélhetőleg nem tévesen feltételezem, hogy nem pontosan két darabot, hanem kettő vagy több darabot, tehát úgy általában a duplikált elemeket keresnéd.

Végigiterálsz a listán, és ahol a FindAll (értékre) egynél hosszabb listával tér vissza, azt az értéket hozzáadod egy sethez (így minden érték csak egyszer szerepel az eredményben).

Rövid, tömör, és relatíve jól olvasható. Teljesítmény tekintetében mondhatni botrányos, de optimalizálni eleve csak akkor szabad, ha kifejezetten szükség van rá (ld. "premature optimization"); ebben az esetben számos lehetőség kínálkozik a futásidő javítására.

Körülbelül (nem volt szempont, hogy másolható legyen, csak szemléltetés):

public HashSet<T> FindDuplicates(List myList)

{

˙˙˙˙var duplicates = new HashSet<T>();

˙˙˙˙myList.forEach(delegate(T item)

˙˙˙˙{

˙˙˙˙˙˙˙˙if (myList.FindAll(delegate(T other) { other == item }).Count > 1)

˙˙˙˙˙˙˙˙{

˙˙˙˙˙˙˙˙˙˙˙˙duplicates.Add(item);

˙˙˙˙˙˙˙˙}

˙˙˙˙});

˙˙˙˙return duplicates;

}

Amennyiben mégis pontosan kettő darabot keresnél, úgy az if-ben a feltételt kell "> 1"-ről "== 2"-re módosítani.

De mi motiválja őket vajon?

Mert iskolában még érthető, ahol megverik a csicskát, ha nem csinálja meg a házit. De itt?