Эффективно получите отсортированные суммы отсортированного списка

Можно ли сделать это в двух строках в Python с

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

, стоимость этого является n^2 (возможно, дополнительный фактор журнала для набора?) для повторения и s * журнал (журналы) для сортировки, где s является размером набора.

размер набора мог быть целым n* (n-1)/2, например, если X = [1,2,4..., 2^n]. Таким образом, если Вы захотите генерировать этот список, то он возьмет, по крайней мере, n^2/2 в худшем случае, так как это - размер вывода.

Однако, если Вы хотите выбрать первые k элементы результата, можно сделать это в O (kn) использование алгоритма выбора для отсортированных матриц X+Y Frederickson, и Johnson ( посмотрите здесь для окровавленных деталей) . Хотя это может, вероятно, быть изменено, чтобы генерировать их онлайн путем многократного использования вычисления и получить эффективный генератор для этого набора.

@deuseldorf, Peter There является некоторым беспорядком о (n!) Я серьезно сомневаюсь относительно deuseldorf, предназначенного "n факториал", но просто "n, (очень взволнованный)!"

Вместо того, чтобы кодировать это, я полагаю, что псевдокодирую его на шагах и объясню мою логику, так, чтобы лучшие программисты могли ввести дыры по абсолютному адресу в моей логике при необходимости.

На первом шаге мы начинаем со списком длины чисел n. Для каждого числа мы должны создать список длины n-1 becuase, мы не добавляем число к себе. К концу у нас есть список приблизительно n отсортированные списки, который был сгенерирован в O (n^2) время.

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 

На шаге 2, потому что списки были отсортированы по дизайну (добавляют, число к каждому элементу в отсортированном списке и списке будет все еще отсортировано), мы можем просто сделать сортировку с объединением путем слияния каждого списка вместе вместо того, чтобы сортировать всех с объединением. В конце это должно взять O (n^2) время.

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

метод слияния был бы затем нормальным шагом слияния с проверкой, чтобы удостовериться, что нет никаких дублирующихся сумм. Я не выпишу это, потому что любой может искать сортировку с объединением.

, Таким образом, существует мое решение. Весь алгоритм является O (n^2) время. Не стесняйтесь указывать на любые ошибки или улучшения.

В 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);
}

Лучшее, которое я мог придумать, должно произвести матрицу сумм каждой пары и затем объединить строки вместе, сортировку слиянием крыла. Я чувствую, что пропускаю некоторое простое понимание, которое покажет намного более эффективное решение.

Мой алгоритм, в 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)

я нашел незначительное улучшение, один это более поддается ленивому кодированию на основе потоков. Вместо того, чтобы объединить столбцы попарно, объедините всех их сразу. Так как преимущество - это, Вы начинаете получать элементы списка сразу.

-- 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

Однако, если Вы знаете, что собираетесь использовать все суммы, и нет никакого преимущества для получения некоторых из них ранее, пойдите с' foldl merge []', поскольку это быстрее.

Независимо от того, что Вы делаете без дополнительных ограничений на входные значения, Вы не можете добиться большего успеха, чем O (n^2), просто потому что необходимо выполнить итерации через всех пар чисел. Повторение будет доминировать над сортировкой (который можно сделать в O (n, регистрируют n) или быстрее).

Этот вопрос разрушал мой мозг приблизительно в течение дня теперь. Потрясающий.

Так или иначе, Вы не можете убежать от n^2 природы его легко, но можно сделать немного лучше со слиянием, так как Вы можете, обязал диапазон вставлять каждый элемент в.

при рассмотрении всех списков, Вы генерируете, у них есть следующая форма:

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

при зеркальном отражении этого 90 градусами Вы добираетесь:

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

Теперь, процесс слияния должен брать два списка i и i+1 (которые соответствуют спискам, где первый участник всегда a[i] и a[i+1]), Вы можете, обязал диапазон вставлять элемент (a[i + 1], a[j]) в список i местоположением (a[i], a[j]) и местоположением (a[i + 1], a[j + 1]).

Это означает, что необходимо объединиться наоборот с точки зрения [1 110]. Я (еще) не знаю, можно ли усилить это через [1 111] также, но это кажется возможным.

Если Вы будете искать действительно решение агностика языка затем, то Вы будете очень разочарованы, по-моему, потому что Вы застрянете с для цикла и некоторых условных выражений. Однако, если Вы открыли его до функциональных языков или функциональных функций языка (я смотрю на Вас LINQ), затем, мои коллеги здесь могут заполнить эту страницу изящными примерами в Ruby, Lisp, Erlang и других.