Hatékonyan kap kiválogatott összegeket rendezett listáját

Ha keres egy igazán nyelv-független megoldás, akkor lesz nagyon csalódott véleményem, mert akkor kell ragasztani a hurok, és néhány feltételes. Ha azonban megnyitotta azt a funkcionális nyelvek, illetve funkcionális nyelv jellemzői (én néztem meg LINQ), majd kollégáim itt kitöltheti ezt az oldalt elegáns példákat Ruby, Lisp, Erlang, és mások.

A legjobb, amit elér az, hogy egy mátrix összegek az egyes párok, majd egyesíteni a sorok együtt, a-la merge sort. Úgy érzem, hogy hiányzik néhány egyszerű betekintést, mely felfedi egy sokkal hatékonyabb megoldás.

Saját algoritmus, Haskell:

matrixOfSums list = [[a+b | b <- list, b >= a] | a <- list]

sortedSums = foldl merge [] matrixOfSums

--A normal merge, save that we remove duplicates
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys) = case compare x y of
    LT -> x:(merge xs (y:ys))
    EQ -> x:(merge xs (dropWhile (==x) ys))
    GT -> y:(merge (x:xs) ys)

Találtam egy kisebb javulás, az egyik, hogy sokkal alkalmasabb arra lusta stream-alapú kódolás. Ahelyett, hogy egyesíti a oszlopokban páronként, összeolvad mindet egyszerre. Az előnye az, hogy elkezd szerzés lista elemei azonnal.

-- wide-merge does a standard merge (ala merge-sort) across an arbitrary number of lists
-- wideNubMerge does this while eliminating duplicates
wideNubMerge :: Ord a => `a` -> [a]
wideNubMerge ls = wideNubMerge1 $ filter (/= []) ls
wideNubMerge1 [] = []
wideNubMerge1 ls = mini:(wideNubMerge rest)
    where mini = minimum $ map head ls
          rest = map (dropWhile (== mini)) ls

betterSortedSums = wideNubMerge matrixOfSums

Azonban, ha tudod, hogy fogsz használni az összes összegek, és nincs előnye, hogy néhány közülük korábban megy „ foldl merge []”, mivel ez gyorsabb.

Ahelyett kódoló ezt ki tudom képzelni én ál-kód azt lépéseket, és megmagyarázni a logika, hogy a jobb programozók lök lyukak az én logika, ha szükséges.

Az első lépésben elindul egy listát a számok n hosszúságú. Minden egyes szám létre kell hoznunk egy listát a hossza n-1 becuase nem vagyunk hozzá egy számot is. Végére van egy lista a n rendezve listákat, hogy keletkezett O (n ^ 2) időt.

step 1 (startinglist) 
for each number num1 in startinglist
   for each number num2 in startinglist
      add num1 plus num2 into templist
   add templist to sumlist
return sumlist 

A 2. lépés, mert a listákat sorolva mintával (Szám hozzáadása minden elemét egy rendezett listát, és a listát továbbra is rendezve) akkor egyszerűen nem egy mergesort összevonásával egyes listák együtt ahelyett mergesorting az egészet. A végén ez O (n ^ 2) időt.

step 2 (sumlist) 
create an empty list mergedlist
for each list templist in sumlist
   set mergelist equal to: merge(mergedlist,templist)
return mergedlist

Az egyesítési módszer az lenne, akkor a normális egyesítési lépést egy csekket, hogy megbizonyosodjon arról, hogy nincsenek ismétlődő összegeket. Nem írok ki ezt, mert bárki felnéz mergesort.

Tehát az én megoldás. A teljes algoritmus O (n ^ 2) időt. Nyugodtan rámutatni a hibákat vagy fejlesztéseket.

SQL:

create table numbers(n int not null)
insert into numbers(n) values(1),(1), (2), (2), (3), (4)


select distinct num1.n+num2.n sum2n
from numbers num1
inner join numbers num2 
    on num1.n<>num2.n
order by sum2n

C # LINQ:

List<int> num = new List<int>{ 1, 1, 2, 2, 3, 4};
var uNum = num.Distinct().ToList();
var sums=(from num1 in uNum
        from num2 in uNum 
        where num1!=num2
        select num1+num2).Distinct();
foreach (var s in sums)
{
    Console.WriteLine(s);
}

Megteheti ezt a két vonalat Python

allSums = set(a+b for a in X for b in X)
allSums = sorted(allSums)

Ennek költsége n ^ 2 (talán egy extra log tényező a beállított?) Az iteráció és s * log (ek) számára a rendezési ahol s a mérete a beállított.

A méret a beállított lehet olyan nagy, mint n * (n-1) / 2, például, ha X = [1,2,4, ..., 2 ^ n]. Tehát ha azt akarjuk, hogy létrehoz a lista fog tartani legalább n ^ 2/2 a legrosszabb esetben, mivel ez a méret a kimenetet.

Azonban ha azt szeretnénk, hogy válassza ki az első k elemet az eredmény, akkor ezt az O (kn) egy kiválasztási algoritmus szerint rendezve X + Y mátrixok által Frederickson és Johnson ( lásd itt a véres részleteket) . Bár ez valószínűleg módosítani kell generálni őket az interneten újrahasznosításával számítást, és kap egy hatékony generátor ezt meg.

@deuseldorf, Peter Van némi zavart a (n!) Én komolyan kétséges deuseldorf azt jelentette: „n faktoriális”, hanem egyszerűen „n, (nagyon izgatott)!”

Ezt a kérdést már wracking agyam körülbelül egy nap most. Fantasztikus.

Egyébként, akkor nem kap el a n ^ 2 természete könnyen, de meg lehet csinálni valamivel jobb az egyesítés, mert akkor kötött tartományban beszúrni minden eleme.

Ha megnézzük az összes listát generál, ezek a következő formában:

(a[i], a[j]) | j>=i

Ha flip 90 fokkal, kapsz:

(a[i], a[j]) | i<=j

Most, az egyesítési folyamatot kell figyelembe két listát iés i+1(amelyek megfelelnek a listára, ha az első elem mindig a[i]és a[i+1]), akkor köteles a tartomány beszúrni elem (a[i + 1], a[j])a listán ia helye (a[i], a[j])és a helyét (a[i + 1], a[j + 1]).

Ez azt jelenti, hogy meg kell egyesíteni fordított szempontjából j. Nem tudom, hogy (még), ha képes kihasználni ezt az egész jis, de úgy tűnik, lehetséges.

Nem számít, mit csinál, anélkül, hogy további megszorítások a bemeneti értékeket, akkor nem jobb, mint az O (n ^ 2), egyszerűen azért, mert van, hogy végiglépdelni számpárok. Az iteráció fog dominálni válogatása (amit tehetünk O (n log n) vagy gyorsabb).