Rafting Problem (Knapsack variant)
Haskell 226 228 234 268 bytes

Naive answer in Haskell



import Data.List
o=map
u=sum
p=foldr(\x t-&gt;o([x]:)t++[(x:y):r|(y:r)&lt;-t&gt;&gt;=permutations])[[]]
m x=foldl(\[m,n]x-&gt;[m+(x-m)/(n+1),n+1])[0,0]x!!0
a!z=abs$u z-a
s t=(length t,u$o((m$o u t)!)t)
a n=head.sortOn s.filter(all$(&lt;=n).u).p


Or ungolfed

partition' :: [a] -&gt; [[[a]]]
partition' [] = [[]]
partition' (x:xs) = [[x]:ps     | ps &lt;- partition' xs]
                 ++ [(x:p):rest | ps &lt;- partition' xs, (p:rest) &lt;- permutations ps]

-- from Data.Statistics
mean :: [Double] -&gt; Double
mean xs = fst $ foldl (\(m, n) x -&gt; (m+(x-m)/n+1, n+1)) (0, 0) xs

diff :: Double -&gt; [Double] -&gt; Double
diff avg xs = abs $ sum xs - avg

rawScore :: [[Double]] -&gt; Double
rawScore xs = sum . map (diff avg) $ xs where avg = mean . map sum $ xs

score :: [[Double]] -&gt; (Int, Double)
score xs = (length xs, rawScore xs)

-- from Data.Ord
comparing :: (Ord b) =&gt; (a -&gt; b) -&gt; a -&gt; a -&gt; Ordering
comparing p x y = compare (p x) (p y)

candidates :: Double -&gt; [Double] -&gt; [[[Double]]]
candidates n xs = filter (all (\ ys -&gt; sum ys &lt;= n)) . partition' $ xs

answer :: Double -&gt; [Double] -&gt; [[Double]]
answer n xs = minimumBy (comparing score) $ candidates n xs


With some test cases

import Text.PrettyPrint.Boxes

testCases :: [(Double, [Double])]
testCases = [(6 , [2,5])
            ,(4 , [1,1,1,1,1])
            ,(6 , [2,3,2])
            ,(6 , [2,3,2,3])
            ,(6 , [2,3,2,3,2])
            ,(12, [10,8,6,4,2])
            ,(6 , [4,4,4])
            ,(12, [12,7,6,6])]

runTests tests = transpose 
                 $ ["n", "Bookings", "Output"]
                 : map (\(n, t) -&gt; [ show . floor $ n
                                   , show . map floor $ t
                                   , show . map (map floor) $ a n t]) tests

test = printBox 
     . hsep 3 left . map (vcat top) . map (map text) . runTests $ testCases


Where test yields

n    Bookings       Output
6    [2,5]          [[2],[5]]
4    [1,1,1,1]      [[1,1],[1,1,1]]
6    [2,3,2]        [[2,2],[3]]
6    [2,3,2,3]      [[2,3],[2,3]]
6    [2,3,2,3,2]    [[2,2,2],[3,3]]
12   [10,8,6,4,2]   [[10],[8,2],[6,4]]
6    [4,4,4]        [[4],[4],[4]]
12   [12,7,6,6]     [[12],[7],[6,6]]


Edit

Thanks to @flawr and @nimi for advice.

Squashed p a bit.

Shaved off a couple bytes.