[Question]
  [
You have a bunch of heavy boxes and you want to stack them in the fewest number of stacks possible. The issue is that you can't stack more boxes on a box than it can support, so heavier boxes must go on the bottom of a stack.
## The Challenge
**Input**: A list of weights of boxes, in whole kg.
**Output**: A list of lists describing the stacks of boxes. This must use the fewest number of stacks possible for the input. To be a valid stack, the weight of each box in the stack must be greater than or equal to the sum of the weight of all boxes above it.
### Examples of Valid stacks
(In bottom to top order)
* [3]
* [1, 1]
* [3, 2, 1]
* [4, 2, 1, 1]
* [27, 17, 6, 3, 1]
* [33, 32, 1]
* [999, 888, 99, 11, 1]
### Examples of Invalid stacks
(In order from bottom to top)
* [1, 2]
* [3, 3, 3]
* [5, 5, 1]
* [999, 888, 777]
* [4, 3, 2]
* [4321, 3000, 1234, 321]
## Example Test Cases
### 1
```
IN: [1, 2, 3, 4, 5, 6, 9, 12]
OUT: [[12, 6, 3, 2, 1], [9, 5, 4]]
```
### 2
```
IN: [87, 432, 9999, 1234, 3030]
OUT: [[9999, 3030, 1234, 432, 87]]
```
### 3
```
IN: [1, 5, 3, 1, 4, 2, 1, 6, 1, 7, 2, 3]
OUT: [[6, 3, 2, 1], [7, 4, 2, 1], [5, 3, 1, 1]]
```
### 4
```
IN: [8, 5, 8, 8, 1, 2]
OUT: [[8, 8], [8, 5, 2, 1]]
```
## Rules and Assumptions
* Standard I/O rules and banned loopholes apply
* Use any convenient format for I/O
	+ Stacks may be described top to bottom or bottom to top, as long as you are consistent.
	+ The order of stacks (rather than boxes within those stacks) does not matter.
	+ You may also take input boxes as a presorted list. Order is not particularly important for the input, so long as the general problem isn't being solved by the sorting itself.
* If there is more than one optimal configuration of stacks, you may output any one of them
* You may assume that there is at least one box and that all boxes weigh at least 1 kg
* You must support weights up to 9,999 kg, at minimum.
* You must support up to 9,999 total boxes, at minimum.
* Boxes with the same weight are indistinguishable, so there is no need to annotate which box was used where.
Happy golfing! Good luck!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 bytes
```
Œ!ŒṖ€ẎṖÄ>ḊƲ€¬ȦƊƇLÞḢ
```
[Try it online!](https://tio.run/##y0rNyan8///oJMWjkx7unPaoac3DXX1AxuEWu4c7uo5tAgocWnNi2bGuY@0@h@c93LHo/@F2kMoZ//9HW5jrKJgYG@koWAKBjoKhkbGJjoKxgbFBLAA "Jelly – Try It Online")
Obvious -3 thanks to [Nick Kennedy](https://codegolf.stackexchange.com/users/42248/nick-kennedy)...
Top to bottom.
Explanation:
```
Œ!ŒṖ€ẎṖÄ>ḊƲ€¬ȦƊƇLÞḢ  Arguments: S (e.g. [1, 2, 3, 4, 5])
Œ!                   Permutations (e.g. [..., [4, 1, 5, 2, 3], ...])
    €                Map link over left argument (e.g. [..., [..., [[4, 1], [5], [2, 3]], ...], ...])
  ŒṖ                  Partitions (e.g. [..., [[4, 1], [5], [2, 3]], ...])
     Ẏ               Concatenate elements (e.g. [..., ..., [[4, 1], [5], [2, 3]], ..., ...])
               Ƈ     Filter by link (e.g. [..., [[1, 3], [2], [4], [5]], ...])
              Ɗ       Create >=3-link monadic chain (e.g. [[1], [], [0]])
           €           Map link over left argument (e.g. [[1], [], [0]])
          Ʋ             Create >=4-link monadic chain (e.g. [1])
      Ṗ                  Remove last element (e.g. [4])
       Ä                 Cumulative sum (e.g. [4])
         Ḋ               [Get original argument] Remove first element (e.g. [1])
        >                Greater than (vectorizes) (e.g. [1])
            ¬          Logical NOT (vectorizes) (e.g. [[0], [], [1]])
             Ȧ         Check if non-empty and not containing zeroes after flattening (e.g. 0)
                 Þ   Sort by link (e.g. [[[1, 2, 3], [4, 5]], ..., [[5], [4], [3], [2], [1]]])
                L     Length (e.g. 4)
                  Ḣ  Pop first element (e.g. [[1, 2, 3], [4, 5]])
```
[Answer]
# JavaScript (Node.js), ~~139 122~~ 116 bytes
Expects the input sorted in ascending order.
```
f=(A,s=[],[n,...a]=A,r)=>n?s.some((b,i,[...c])=>n<eval(b.join`+`)?0:f(A,c,a,c[i]=[n,...b]))?S:r?0:f(A,[...s,[]]):S=s
```
[Try it online!](https://tio.run/##bY3NCsIwEITvPkWOCa6hTdRqMRafwWMImMZWKjWRRvr6desfIi5z2vlm5mx7G13XXG8zH47VMNSK7iAqbUB74Jxbo3bQMbX1ReQxXCpKS2hAo@XM@N5UvW1pyc@h8YfpgRVJXmOFAwtON0Y9a0rDWLHPu5c7xiNoY1i@V3FwwcfQVrwNJ1pTnQIRQCSQOZAFkCWQNZBUYMXkh1xlCEkxuhJhmcgEYbw/LLZ@JN4L3yPZ/5B4@KunEBnu "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (                        // f is a recursive function taking:
  A,                         //   A[] = input array
  s = [],                    //   s[] = list of stacks, initially empty
  [n,                        //   n   = next weight to process
      ...a] = A,             //   a[] = array of remaining weights
  r                          //   r   = recursion flag
) =>                         //
  n ?                        // if n is defined:
    s.some((b, i,            //   for each stack b[] at position i in s[],
                  [...c]) => //   using c[] as a copy of s[]:
      n < eval(b.join`+`) ?  //     if n is not heavy enough to support all values in b[]:
        0                    //       abort
      :                      //     else:
        f(                   //       do a recursive call:
          A, c, a,           //         using A[], c[] and a[]
          c[i] = [n, ...b]   //         with n prepended to c[i]
        )                    //       end of recursive call
    ) ?                      //   end of some(); if successful:
      S                      //     return S[]
    :                        //   else:
      r ?                    //     if this is a recursive call:
        0                    //       do nothing
      :                      //     else:
        f(A, [...s, []])     //       try again with an additional stack
  :                          // else:
    S = s                    //   success: save the solution in S[]
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 178 bytes
```
f=lambda b,s=[[]]:(a for i in range(len(s))if b[0]>=sum(s[i])for a in f(b[1:],s[:i]+[[b[0]]+s[i]]+s[i+1:]+[[]]))if b else[s]
g=lambda a:(c:=sorted(f(a),key=len)[0])[:c.index([])]
```
[Try it online!](https://tio.run/##dY7daoQwEIXvfYqB3kwwlNXsjw3YFxlyEddow7pRjIXu09sktqWlu5MwDMz5zpnptryNTlTTvK5dPehr02pouK@JlJKooRtnsGAdzNr1Bgfj0DNmO2hop15r/35FT1axqNNR12FDhVTck7QqJ4o6lUdN6nnY5dF8MwEzeENeZf13uJZ4lrUf58W02KFm/GJudchlwYiRPD9b15oPJMXUOs3WLdjjYP2CXwxVJw57UXJ4CcWhKMWeg9iJgIfK7jIFhwCIAHI4cDgGOJJ/iaD699Sv/c8ByaNKPxpHl@wJHgUfUnCRsss0HFM/bTdtN6yf "Python 3.8 (pre-release) – Try It Online")
Now works on all possible inputs. *(It times out on TIO with more than ten or so boxes, but it calculates a correct answer)*
]