R>perm :: [Int] -> [Int]
R>perm zs = perm' zs (tails zs)
R>    where perm' [] _ = []
R>          perm' _ [] = []
R>          perm' (x:xs) (y:ys) = map ((+) x . sum) ys ++ perm' xs ys

listsums :: (Num elt) => [elt]{-входные данные-} -> [elt{-сумма комбинации-}]{-для разных комбинаций-}

-- суммы комбинаций как минимум двух элементов
listsums [] = []
listsums [x] = []
listsums x1:x2:xs =  (listsums2 (x1+x2) xs) -- взяли два первых элемента, находим суммы комбинаций длиной >= 0
                  ++ (listsums1 x1 xs) -- взяли первый элемент, пропустили второй, суммы комбинаций длиной >= 1
                  ++ (listsums  x2:xs) -- пропустили первый элемент, находим суммы комбинаций длиной >= 2
  where
    -- суммы комбинаций как минимум одного элемента, плюс константа
    listsums1 :: elt{-прибавка к сумме-} -> [elt]{-хвост-} -> [elt]{-суммы комбинаций-}
    listsums1 x0 [] = []
    listsums1 x0 [x] = [x0+x]
    listsums1 x0 x1:xs = (listsums2 (x0+x1) xs) ++ (listsums1 x0 xs)
    -- суммы комбинаций в том числе нуля элементов, плюс константа
    listsums2 :: elt{-прибавка к сумме-} -> [elt]{-хвост-} -> [elt]{-суммы комбинаций-}
    listsums2 x0 [] = [x0]
    listsums2 x0 x:xs = (x0+sum(x:xs)) : (listsums2 x0 xs)
    -- listsumsN, N означает, сколько элементов уже учтено

M>Как оказалось, условие я и сам неправильно понял. Оказалось, что надо не просто суммы смежных двоек, троек и т.д., а все гораздо хуже Необходимо суммы всех возможных групп чисел вообще. Т.е. а1 + а2, а1 + а3, а1 + а4, ...., а1 + а2 + а3, а1 + а3 + а4, ..., а2 + а3, ..., а2 + а4 + а5, ...

M>И потом получившиеся суммы поставить в порядке возрастания. На вопрос "а нафига это надо", друг не ответил, сказал, что надо А я уже обещался помочь

allsums ([])= []
allsums ([a])= []
allsums ([a,b])= [a+b]
allsums (a:as)=  (allsums as)++(map (a+) as)++(map (a+) (allsums as))

main = interact (unwords.(map show).sort.allsums.(map read).words)

Т>allsums ([])= []
Т>allsums ([a])= []
Т>allsums ([a,b])= [a+b]
Т>allsums (a:as)=  (allsums as)++(map (a+) as)++(map (a+) (allsums as))

Т>main = interact (unwords.(map show).sort.allsums.(map read).words)
Т>

allsums (a:as) = subs ++ map (a+) (as ++ subs)
    where subs = allsums as

-- это чтобы с консоли можно было играться
answer {-xs-} = (sort.allsums) {-xs-}

A> length$answer [1..14]
(секунду подумал)
16369

A> answer [1..14]
(секунду подумал)
(следует дамп из 16 тысяч чисел)

A> answer [1..15]
ERROR - Garbage collection fails to reclaim sufficient space

merge [] ys = ys 
merge xs [] = xs
merge (x:xs) (y:ys) = if x<=y then x:(merge xs (y:ys)) else y: (merge(x:xs)  ys)

allsums ([])= []
allsums ([a])= []
allsums ([a,b])= [a+b]
allsums (a:as) = merge subs (map (a+) (merge as  subs))
    where subs = allsums as

sort:{x[<x]}
allsum:{:[(#x)<2;();(#x)=2;+/x; t, (*x)+(1_ x),t:_f[1_ x] ]}

  #allsum[!22]
4194281
  \t sort[allsum[!22]]
250 - время в ms

M>Я уже решил это все дело написать на С++ Потому что сделал вид, что умею думать и начертил вот такое:

M>Лучше уж я буду сохранять промежуточные результаты

unique :: (Eq elt) => [elt] -> [elt]

unique []              = []
unique x:[]            = x
unique x:x':xs | x==x' = unique x:xs -- выбрасываем дубликат
unique x:xs            = x : unique xs

mergeunique {-xs-} {-ys-} = unique.merge

Т>sort:{x[<x]}
Т>allsum:{:[(#x)<2;();(#x)=2;+/x; t, (*x)+(1_ x),t:_f[1_ x] ]}

Т>  #allsum[!22]
Т>4194281
Т>  \t sort[allsum[!22]]
Т>250 - время в ms
Т>

m=:1 7 4 5 2 0 6 6       NB. пример списка
x=:(2:+i.@-&2@#)+/\]     NB. магия
/:~@-.&0,x m
2 6 7 7 8 8 9 11 11 11 12 12 12 13 14 16 17 17 18 18 19 19 19 23 24 25 30