[Question]
  [
## Introduction:
A few days ago I read [this post with the same title](https://skeptics.stackexchange.com/questions/44245/do-the-26-richest-billionaires-own-as-much-wealth-as-the-poorest-3-8-billion-peo) when I came across it in the HNQ. It asks if this claim of US presidential candidate Bernie Sanders is true or not:
> 
> Today the world's richest 26 billionaires, 26, now own as much wealth as the poorest 3.8 billion people on the planet, half of the world's population.  
> 
> [Link to video](https://www.youtube.com/watch?v=QThknQs-gIc&feature=youtu.be&t=655)
> 
> 
> 
Please go to the question itself for answers and discussions there.
As for the actual challenge based on this claim:
## Challenge:
**Two inputs:** a descending sorted number-list \$L\$ and a number \$n\$ (where \$n\$ is \$1\leq n\lt \text{length of }L\$).  
**Output:** the longest possible suffix sub-list of \$L\$ for which the total sum is \$\leq\$ the sum of the first \$n\$ values in list \$L\$.
**Example:**
Inputs: \$L\$ = `[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]` and \$n=2\$.  
Output: `[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]`
*Why?*
The first \$n=2\$ values of the list \$L\$ (`[500,200]`) sum to `700`. If we take all suffixes of the remaining numbers, as well as their sums:
```
Suffix:                                                                  Sum:
[-3]                                                                     -3
[-2,-3]                                                                  -5
[0,-2,-3]                                                                -5
[1,0,-2,-3]                                                              -4
[2,1,0,-2,-3]                                                            -2
[2,2,1,0,-2,-3]                                                          0
[3,2,2,1,0,-2,-3]                                                        3
[5,3,2,2,1,0,-2,-3]                                                      8
[5,5,3,2,2,1,0,-2,-3]                                                    13
[5,5,5,3,2,2,1,0,-2,-3]                                                  18
[5,5,5,5,3,2,2,1,0,-2,-3]                                                23
[10,5,5,5,5,3,2,2,1,0,-2,-3]                                             33
[10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                          43
[20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                       63
[30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                    93
[30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                 123
[40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                              163
[50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                           213
[55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                        268
[75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                     343
[75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                  418
[100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]              518
[125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]          643
[150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]      793
[150,150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]  943
```
The longest suffix which has a sum lower than or equal to `700` is `[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]` with a sum of `643`, so that is our result.
## Challenge rules:
* Values in the first \$n\$ prefix aren't counted towards the output-suffix. I.e. inputs \$L\$ = `[10,5,5,3]` and \$n=2\$ would result in `[5,3]`, and not `[5,5,3]`.
* I/O is flexible. You can input \$L\$ as a list/stream/array of integers/decimals/strings, a single delimited string, one by one through STDIN, etc. You can output as a list/stream/array of integers/decimals/strings as well, print/return a delimited string, print a number on each newline, etc. Your call.
* The output is guarantees to be non-empty. So you won't have to deal with test cases like \$L\$ = `[-5,-10,-13]` and \$n=2\$ resulting in `[]`.
* Both (or either) the input and/or output may also be in ascending order instead of descending order if you choose to.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer with [default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/), so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code (i.e. [TIO](https://tio.run/#)).
* Also, adding an explanation for your answer is highly recommended.
## Test cases:
```
Inputs: L=[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3], n=2
Output: [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]
Inputs: L=[10,5,5,3], n=2
Output: [5,3]
Inputs: L=[7,2,1,-2,-4,-5,-10,-12], n=7
Output: [-12]
Inputs: L=[30,20,10,0,-10,-20,-30], n=1
Output: [20,10,0,-10,-20,-30]
Inputs: L=[100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5], n=1
Output: [15,5,5,5,5,5,5,5,5,5,5,5,5,5]
Inputs: L=[0,-5,-10,-15], n=2
Output: [-10,-15]
Inputs: L=[1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250], n=2
Output: [525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250]
Inputs: L=[10,5,5], n=1
Output: [5,5]
```
  
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~88~~ ~~81~~ ~~69~~ ~~68~~ 63 bytes
*-4 bytes thanks to [LiefdeWen](https://codegolf.stackexchange.com/users/68917/liefdewen)*
```
a=>b=>a.Skip(b).Where((x,i)=>a.Skip(i+b).Sum()<a.Take(b).Sum())
```
[Try it online!](https://tio.run/##lU9Na8MwDL3nV5ieZKYYx5nZoIlvLXT01kIPYwcnuJvo6o580MHYb89Usw22W9ET6OnB01Pb521P03KMbbWmfqgoDg4T5QlXizgeQ@eb15AU58S@nnztmtp5tTnQGzRS7V5CFwDekeTvmm5Y2IxHkJVXW38I8MPlNM/@@woStdgDxHAWj08fVms03IX9bmOxYH5nL7AMjbcaywTDesI92lQlGq4CNeYG8/JTqu3p8hufBiPn2a6jIawpBuiHjuKzejhRhBnOOD/LWfY3DDsn1yt9pi8 "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [EXAPUNKS](https://store.steampowered.com/app/716490/EXAPUNKS/) (2 EXAs, 30 Instructions, 594-byte solution file)
I've wanted to try a code golf challenge in EXAPUNKS for a while, and you looked like the best fit I could find, so, congrats!
Input via files 200 and 201, for L and n respectively. Output via a new file. L and the output are in ascending order.
Basically, XA sums the last n values in L, then sends it to XB. It then seeks to the beginning of L and sends each value one-by-one to XB. XB first receives the total from XA and stores it in register X. It then receives values one-by-one from XA, deducting the new value from X, and writing those values to the output file until X < 0.
### XA
```
GRAB 201
SUBI T F T
DROP
GRAB 200
SEEK 9999
SEEK T
MARK FIRST_SUM
ADDI F X X
ADDI T 1 T
SEEK -1
VOID F
TJMP FIRST_SUM
COPY X M
SEEK -9999
MARK SECOND_SUM
COPY F M
TEST EOF
FJMP SECOND_SUM
KILL
```
### XB
```
MAKE
COPY M X
MARK LOOP
COPY M T
COPY T F
SUBI X T X
TEST X > 0
TJMP LOOP
SEEK -1
VOID F
KILL
```
JavaScript for the level [here](https://tio.run/##tVbtbts2FP3vp7gwMMDGKFuSrdjxFgxGsqABvLRog/3xgoCW6YirTKokZaUd@gB7jz3ZXiS7JOXEdpSgRTuLjEXynPtF8jh/0g3VqeKFCTbj@/t@H86lApMxyKlh2sD0jss1/M6VKWl@yUwl1fsfwVO4uIWlTMs1E4YaLgWBFloockY1gw3X3EwgM6aY9PtVVfU@0TQzSgqe6l4q1/2Ntyq81b7lXoiiNHoCs5N5EoYkxh4ldY8TEuF4lNiWYAvJMCQD12Jcd21MEvcMSIxPREISxCQYXBMQJ7H18Lo06GIC82@zZ00dBIxoh2zwZWcbGCNn0hockiAhAVoIotjxR3t8O9vAfwg09FwcBIPQ8aM9fhOqMQNMPiG2MAl59mmw/yK8wVH4mG7SUK7tSnOIITk@PsY@Jsf4PrZbeHREEoza9qHNYWiPC3a7gbg8IoMBTrgCoN8h9jgJm/bp6408exAayuSq0VqVIrW3BW6ZueImZ50u/NUC/ChmSiWgbe@MxkuTyiW7lfmqpw1N37O7NKPilrm786HE24lGdD8aj5Io7C9lgNc2iI8CxdMMF4MFz3NEUK6YDmQlAqqDdZlmQcVobjI7tIxCSmXhg2C8pQQFk@2fWp/3Y31XLkxjuE@hZ6xWCCmeoM@k05f4COpAYTdQwECBarCBgg/UDi2jDhQGvfGWAhgoys0vfwg4zWieMyzPBK4qCbzeDgpaKsOWIMr1gqkg52hhBp0VzzGGMOwCFUtE@WUQDytRFzpVxhTDOa4h@vfvf8TP1gEGJFcw6/Ye9tXJpUTXaLqQWvMFWigUW/E70OXC@7QcWKG4Vhmm7ThGGpojYm0doH03aYeIta8rrpAoYENz3G1MCXz0vYOCc8ENpzn/xK4whLel6Bj/vS39hip4M307/e0dnMDcTc3n311grXB9o6pek21wO2Lq7NrXx9VnhXNksfb1EfusSEYW27S0G8UXCqKz9SLm0eiB@MU@ZD/cc/0dhc7X8OuZhxuyTdVl5Jb8X3vgUvzVvymoomuNx8yft3l9EuGHeqLnr5BnzRB3wJyH19h6im2Y0ig1DieacZG3It01bIBEh3aKnH5k6iaT2sJRp964iVc4rhGpYvh/z6VUa5qfoxB0dijEqgKB84vZrzcXp68vb86mV1Oshbj@Mm74lDvr1tL4oUTxO3UGnlJ9ggTaLwqOLlf/n@DsZujK1TZUYQHbBBICmNkAW3dPlaQ4/ZjmmI7gOmNL9zvwuXV//x8)
[Answer]
# [Python 2](https://docs.python.org/2/), 60 bytes
```
l,n=input()
s=sum(l[:n])
while sum(l[n:])>s:n+=1
print l[n:]
```
[Try it online!](https://tio.run/##pVHbboMwDH1uviKCl7I5Ui64XCT2IxFPHVKRWIoGVbuvZ3aYSh@2SdOwj0SOT@yTZPyYT@dgl@P5tWuSJFkGCE0fxsu8z8TUTJe3/eDr0GbieuqHTq5EqNvsZarDc2PE@N6HWUZuoQZCdLfuKLnfUyEWj1qDJRj8gkUwtC6QEyk15BpcTEv1mCVgDAeWwoAGZUG5FqTdpdL/r4nwVIyF2O/@pZ4p4YuoZm0OCkGRWhlL2mJTMiH8fZpeVbRQTpPSyE36nYItkFkEPgjCj/HQKvW/CoXXm1neZ@Xu0e5Kx7kaqqoilFDRf8n3eDgAkhVGzsZyfigC3yKVC3COiHgImpETLOp1CN3a33d@Ag "Python 2 – Try It Online")
---
**Explanation:**
First takes the sum of the first `n` items.
Then the sum of each sublist is compared to this sum. As soon as one is not larger, we stop.
Then the resulting (longest) sublist is printed.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~14~~ 12 bytes
Saved 2 bytes thanks to *Grimy*
```
.$ΔDOI¹£O›.$
```
[Try it online!](https://tio.run/##yy9OTMpM/f9fT@XcFBd/z0M7Dy32f9SwS0/l/38jrmhDAwMDHUtLSyC20LEEsi2A2NzMTMfUyBSMTYB8YxMDHUMjIDYEyeuYm@sYGwMFdAx0dA1NdXRNgNjI1CAWAA "05AB1E – Try It Online")
**Explanation**
```
.$               # drop the first n entries of the list
  Δ              # repeat the following code until the result doesn't change
   DO            # duplicate and sum the copy
     I¹£O        # calculate the sum of the first n items of the input
         ›.$     # if the current sum is greater than the sum of the first n items
                 # remove the first item of the current list
```
[Answer]
# [J](http://jsoftware.com/), 18 bytes
```
}.#~+/@{.>:+/\.@}.
```
[Try it online!](https://tio.run/##dVC7CgJBDOz9ikELEXXdV7wHKIJgZWUtbCEeYuMHiP76OdkTTwtJBjaZMJnstR2acYNVjTFmsKiJucH2sN@1DzN6Thebu1nX08XRbB6mnQwwOJ8uN3g0EGvhCSdveIFjXYimMC2iRcjpyecsITkCNTwc9yWPFHpZzmS@6xTsFHlQxyKSIHEiOd/xjvxH3nYcixRsz6upIFB7gr/RO7D9Fvn2RZmqqogSFd@l3rpcQiisiLom6j8QeinpAiGwkZ1RMxJefqzp6vYF "J – Try It Online")
## Explanation:
A dyadic verb, taking `n` as its left argument and `L` - as its right argument. 
```
                }.  drop the first n items from L 
               @    and
             \.     for each suffix (starting from the longest)
           +/       find its sum
         >.         is this sum smaller or equal than (results in a boolean vector)
    +/              the sum 
      @             of
       {.           the first n items of L
  #~                use the 1s in the boolean vector to copy the respective
}.                  elements of L (without the first n)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~47~~ 43 bytes
Takes an ascending list as input. Removes \$n\$ items from the end of the array to get the initial sum, then continue removing items until the remaining elements' sum is less than the initial sum.
-4 bytes by reading the spec more closely.
```
->a,n{s=a.pop(n).sum;a.pop while a.sum>s;a}
```
[Try it online!](https://tio.run/##dU/basMwDH3PV5iyhxZk49hRkxDSHwmjeJvbBbw0xGnHGPv2THJ2exk6Bywd6Viarg9vy6ld5MHB8B5bp8bLuB12Kl5fmpSI1@c@eOG4coiN@1jWwtnPMRM0JVpxd1RxDP0sNs0mE6M4qUcXgvA3F7ZupyZ/81P0IAY1X4595oenpUOtwRBz/KJByCkvkYEEDYUGm2BIT6gAU1gwFDlokAakvW@EyTrSk7ZmZWpguQCJIEmVuSGtzLofS73WKZFWk5azC32JwOsg/Btrr/51xu8daLyua2IFNb0rvmm/ByRDZsH2Bd9L5ItILsFaKqRtyK8gGtR/j@LvPgE "Ruby – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 53 ~~55~~ bytes
@Giuseppe saved me 2 bytes changing the way remove was done
```
function(n,L,Y=rev(L[0:-n]))Y[cumsum(Y)<=sum(L[1:n])]
```
[Try it online!](https://tio.run/##dVDLasMwELz3SyQYweqxsR3qP/APGJOTqaGHuJDG/X13VgluLmV3kLSzzM7qti/9vmzrfP/8Wt2KAWN/@/hxwyTnsF68H6d5u35vVzf6997OYYpnEpd9cQmzUxEkIuoTSRH5btRSmYIiyDUT@ZottEZGYkQIQkLI3r89VNlS6VpoWGhqmzUVBEVgQ4ip0pH0oS0Pio@Q5aDNUFaYNcW/cUyXvxH6YokiXdcRLTreW9vydIJS1lBsSLEfIGxH0g1yZqHaomQhkr76es7dfwE "R – Try It Online")
Takes the input as descending and outputs in ascending as allowed by rule 4.
* `Y` is the rev of `L` with 1:n removed using `0:-n`
* returns from `Y` where cumulative sum is less then equal to the sum of `L[X]`
[Answer]
# JavaScript (ES6), 66 bytes
Takes input as `(a)(n)` with the list in ascending order.
```
a=>n=>(g=s=>n?g(s+a.pop(n--)):eval(a.join`+`)>s?g(s,a.pop()):a)(0)
```
[Try it online!](https://tio.run/##dU/RboMwDHzvV/DWRLVREkgDk8I@ZJrUqKOoFUpQg/r7zKZdtz5MtiHKXe58l3AL@Xg9TzPG9NUvJ78E30XficFnOrwPIu9COaVJREQp3/pbGEUoL@kcD7uD7DIz4M4gOEih5DL3eS58EQrfFZE/xxRzGvtyTIM4CSJFuUqILWyl3Gz4gfjACtCAAg2GqgK7VgNacRsF1dq1Akttwa2tFcGG/nTJYxTj6lMKIx/Cdyn9cofaAJIsWsCafdnVEcM9GeSF5Mqs3w2IoX8YFv4rbYFWqtbt/r5AAh6ur9sY2hxrBi2bUfwKnIOGzhyfrWuOTtlImMft9wQraHnahqZltxfZZ2wtl28 "JavaScript (Node.js) – Try It Online")
### Commented
```
a => n =>               // a[] = list, n = number of richest guys
  ( g = s =>            // g is a recursive function taking a sum s
    n ?                 // if n is not equal to 0:
      g(s + a.pop(n--)) //   recursive call: add the last entry to s and decrement n
    :                   // else:
      eval(a.join`+`)   //   if the sum of the remaining entries
      > s ?             //   is greater than s:
        g(s, a.pop())   //     recursive call with the last entry removed
      :                 //   else:
        a               //     stop recursion and return a[]
  )(0)                  // initial call to g with s = 0
```
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
Also compatible with Python 3
```
f=lambda l,n:l[n:]*(sum(l)/2>=l.pop(n)+sum(l[n:]))or f(l,n)
```
[Try it online!](https://tio.run/##pVHbTsMwDH0eXxFpLw04kJvXdtL4kWoPQ2gCqWurMR74@nKcTk2RAAlR@0iNfY5jO8PH5aXv/Dged@3h9PR8UC1127bptvvb4u39VLT6wT/u2vuhH4pO36WQZLXuz@pYgK3H4fzaXXBo2FrygOMrPJPDuWRxhluKlkJyj3zyijhZIA9zZMl4MmFPyuvVuvlfkZu5OZASYao7f@tGYplWJrmIIxkmA5lxHqJSZ4lEsmTuw050HEywkDitsuY7yrI7zMMkszL9aMua2MxvzFza5jk4Da9Wy0mm@JdOLNV1DVRU47@S5W82xGhOEKXVKK8LyOqRLikEBNJ4uCwCnu31Nqz479LxEw "Python 2 – Try It Online")
---
**Explanation**
The sum of the suffix is compared to half of the sum of the whole list. If the sum of the suffix is smaller or equal, the suffix is returned. If not, the function is called recursively with the first item of the suffix popped out.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~16~~ 15 bytes
```
efgs>vzQsT._<vz
```
[Try it online!](https://tio.run/##K6gsyfj/PzUtvdiurCqwOEQv3qas6v//aF1jHQVdIx0FAx0FQx0FIzACCpnCkAVQ3ACCjYDYGIpNgNgUhIFKzKHY0ACk0AjEAkmBCSMDsEKDWC4jAA "Pyth – Try It Online")
The input list is expected to be sorted in ascending order, rather than descending as is used in the examples.
It's at times like this when I really wish Pyth had a single token operator to access the second input more than once (`E` evaluates the next line of input, but repeated calls discard the previous value read).
```
efgs>vzQsT._<vzQ   Implicit: Q=eval(input()), z=input() - that is, Q is list, z is string n
                   Trailing Q inferred
             vz    Evaluate z as integer
            <  Q   Remove the above number of elements from the end of Q
          ._       Generate a list of all prefixes of the above
 f                 Filter keep elements of the above, as T, where:
    >vzQ             Take the last z elements of Q
   s                 Sum
  g                  Is the above greater than or equal to...
        sT           ... the sum of T?
e                  Take the last remaining element, implicit print
```
*Edit: saved 1 byte thanks to MrXcoder*
[Answer]
# JavaScript, 64 bytes
```
f=(a,n,s=0,[h,...t]=a)=>n<1?f(a)>s?f(t,0,s):a:1/h?f(t,n-1,s+h):s
```
[Try it online!](https://tio.run/##lVHLbsIwELzzFdyI1XHqR5Y8VNMf4A8QB4sSAkJOVUf9/XTtVu2pUtDuyF5bs7OPm//08fRxfZ9kGN/O89y7wiMgOoXDgLIsp6Pzwu3Ci37tCy92kY8JClF0vtPPQw6D1IhPg@jivHcHUgqGoekHhqA5rik5sStUCja74f/sDSibhWHTLCENpD1iHZxZncYQx/u5vI@Xoi/2CKK8jddQbLDeCLFasSznyPzljDoLJZkKkiA5g9Qm8@sl/N/y1TeXA2lV5utlFfMICGk8hH9teT711wU9Mjcuo21bRoOW703a1XYL4sISqlRmlfbISJvi7xrW8kPunDUrhiH16LIWtjZ/AQ "JavaScript (Node.js) – Try It Online")
```
f=(
  a,               // remaining array
  n,               // if n >= 0: we try to find suffix <= s + a[0..n]
                   // if n is NaN (or undefined): we calculate sum(a) + s
  s = 0,           // previous sum
  [h, ...t] = a    // split array (a) into head (h) and tail (t)
) => (n < 1 ?      // if n == 0
  f(a) > s ?       //   if sum(a) > s
    f(t,0,s) :     //     drop head and test tail again
    a :            //   otherwise, a is the answer
  1 / h ?          // if a is not empty
    f(t,n-1,s+h) : //   add head to sum and recurse
    s              //   we only reach here if n is NaN, return the sum
)
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 12 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
îo╧╫Σ↑>'qµΣº
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=8c6fcfd7e4183e2771e6e4a7&i=[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]+2%0A[10+5+5+3]+2%0A[7,2,1,-2,-4,-5,-10,-12]+7%0A[30,20,10,0,-10,-20,-30]+1%0A[100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5]+1%0A[0,-5,-10,-15]+2%0A[1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250]+2%0A[10,5,5]+1&a=1&m=2)
[Nicer version](https://staxlang.xyz/#c=%3A%2F%7C]%7B%7C%2Bn%7C%2B%3E%21%7Djm&i=[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]+2%0A[10+5+5+3]+2%0A[7,2,1,-2,-4,-5,-10,-12]+7%0A[30,20,10,0,-10,-20,-30]+1%0A[100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5]+1%0A[0,-5,-10,-15]+2%0A[1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250]+2%0A[10,5,5]+1&a=1&m=2)
### Unpacked (14 bytes) and explanation:
```
:/|]{|+n|+>!}j
:/                Split array at index.
  |]              Suffixes. The bit after the split (the poor) is on top for this.
    {       }j    First item in array that yields truthy under the block:
     |+             Sum array (collective wealth of the many).
       n            Copy second item to top of stack.
        |+          Sum again. Wasted computation, but this location saves a byte.
          >!        Second item on stack less than or equal to first?
```
By [consensus](https://codegolf.meta.stackexchange.com/a/8507/73884), I can leave this result on the stack. Stax will attempt an implicit print, which might fail, but appending an `m` to the unpacked program lets you see the output nicely.
Looks like `{ ... }j` is the same as `{ ... fh`. Huh. Edit: That's not quite the case; the only the former will stop when it gets a truthy result, possibly avoiding side effects or a fatal error later on.
[Answer]
# APL+WIN, 27 bytes
Prompts for input of L then n.
```
⌽((+/n↑v)≥+\m)/m←⌽(n←⎕)↓v←⎕
```
[Try it online! Courtesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4/6tmroaGtn/eobWKZ5qPOpdoxuZr6uUB5kEQeiO6bqvmobXIZhPkfqOl/GpehgYGBgqWlJRBbKFgC2RZAbG5mpmBqZArGJkC@sYmBgqEREBuC5BXMzRWMjYECCgYKh9YbmgIJExBhZGrAZcQFNlLB2FQBqBcohxNyGYKVQpkA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 16 bytes
```
£sV+YÃæ_x §U¯V x
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=o3NWK1nD5l94IKdVr1YgeA&input=WzUwMCwyMDAsMTUwLDE1MCwxMjUsMTAwLDc1LDc1LDU1LDUwLDQwLDMwLDMwLDIwLDEwLDEwLDgsNSw1LDUsMywyLDIsMSwwLC0yLC0zXQoy)
```
£sV+YÃæ_x §U¯V x     :Implicit input of U=L and V=n
£                    :Map U, with Y being the 0-based indices
 sV+Y                :  Slice U from index V+Y
     Ã               :End map
      æ              :First element that returns true
       _             :When passed through the following function
        x            :  Reduce by addition
          §          :  Less than or equal to
           U¯V       :    Slice U to index V
               x     :    Reduce by addition
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~13~~ 12 bytes
```
ṫḊÐƤS>¥ÞḣS¥Ḣ
```
[Try it online!](https://tio.run/##y0rNyan8///hztUPd3QdnnBsSbDdoaWH5z3csTj40NKHOxb9//8/2tTAQMcIiA1NodjIVMcQyDc3BSFTIDLQMTHQMQYjI6A8GFnomIKhsY4REBrqGOjoGunoGsf@NwIA "Jelly – Try It Online")
Thanks to @JonathanAllan for saving a byte!
A dyadic link taking the list of values \$L\$ as left argument and the number \$n\$ as right. 
## Explanation
```
ṫ            | Tail: take all values of L from the nth onwards (which is actually one too many; dealt with below)
 ḊÐƤ         | Take all suffixes, removing the first value from each. This will yield a list of all possible suffixes of L that exclude the first n values
       Þ     | Sort by:
    S>¥ ḣS¥  | - The sum is greater than the sum of the first n values of L
           Ḣ | Take the first resulting list and return from link (implicitly output when called as a full program)
```
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), 12 bytes
```
eSe¤Σ¤┅⟪Σ⊃⟫∇
```
[Try it online!](https://tio.run/##ASwA0/9nYWlh//9lU2XCpM6jwqTilIXin6rOo@KKg@Kfq@KIh///WzEwIDUgNV0KMQ "Gaia – Try It Online")
I think there's a byte I can golf if I get the stack just right.
```
e	| eval first input as Gaia code
S	| Split into a list of ["first n elements" "rest of elements"]
e	| dump onto stack
¤Σ	| swap and take the sum (sum of first n elements)
¤┅	| swap and take suffixes
⟪  ⟫∇	| return the first element of suffixes where:
 Σ⊃	| the sum(first n elements) ≥ sum(suffix)
```
[Answer]
# [Haskell](https://www.haskell.org/), 46 bytes
Displeased with how this looks; hope I’m just missing some obvious golfs.
```
n#l=until(((sum$take n l)>=).sum)tail$drop n l
```
[Try it online!](https://tio.run/##pVJNb4JAEL37KybqAeJil48VMcFb0zRp0kN7Ix6IrIGIQNg19t/TmUXFJtpD6@7AzLy3O29w8lTtZVl21sSG1QpeKw3OGhJ8b65OV03K@FjporQsSx0PU53uJVRQ2uvYnmPC1mlRTrO2bijbHdKiMpe9g2WPTBRDVo8AGvAgEZwzD80VZ/MEczEOBW2Bm7OAM99sD3Gzl0yY5TMPl8s4czzm@BtI/nf@ogopBsYL6WnSISShIRM1YI5gDtIc10MSPQ3JheRah/cEDByfI@le9nKIJPuCkXjBHi7q7zf4Ip8P6oRR13tDd1gtiiK0JYvQX9IHWyyYwPpkAakJ6M9Ao8@FcMh8HxNGP14eoHmC2vrDoaHrc1dn8adcthLfBD@aP3L6Wep5OGPQSoVDVewwmGD4FFPG4D9/OpcVNEf9odu3CqYw/pRKww7nVWZzMME2VXIFY5jNQOX1CW9DbzyH569GbrXMbjEq26Mvtb4FLKPDvqNAlkoOCvr6TaoU1h933w "Haskell – Try It Online")
I tried getting the prefix and suffix using `splitAt` and pattern matching in a guard, but that turned out to be 3 bytes more.
Planning on trying to convert to a recursive function with guards later to see if that lowers the byte count.
# Explanation
```
n # l = until (((sum $ take n l) >= ) . sum) tail $ drop n l
n # l =                                                        -- define infix operator
n                                                              --  the number of elements
    l                                                          --  the list
        until                                                  -- until
                                        sum                    --  the sum of the suffix
               ((sum $ take n l) >=)                           --  is <= the sum of the prefix
                                             tail              --  remove the first element
                                                    drop n l   -- the suffix
```
What I refer to as "the prefix" is the first `n` elements and "the suffix" is the rest of the list.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~23~~ 21 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous prefix lambda, taking \$n\$ as left argument and \$L\$ as right argument.
```
{⍵↓⍨⍺⌈⊥⍨(+/⍺↑⍵)<+\⌽⍵}
```
[Try it online!](https://tio.run/##hVCxTgJBEO35iutOZRb2dm@5u0QqGzEqidhxFESCFgRJPApDqEyIIUA0hk8wsbOyMbHxU/ZHzjcL0QYwM7OZ2Zk3b2bag57o3Ld7t9d5rT8YZnd28jSy0wc7/3T6VvbTZukgbfmen3Z8u1g2RnhOGvVzO/8onbWzq5sxvHGhPsyAB3ydzkf4tpMX9OBOs0c7fYW/VyxzOHlGdv@wmNrZF8PzLiPnC4BrdfB/v2uuAd3FEd7L41ojXzF4XW81qX9abRopScECszZlKEAcGVYDlRRK0k4V8k5jMk40KUhAkoQioVvk9avKL2zgAcgBdpRErhU3CkkYEoCIQDlAtBHwO5FcFSMQWjpAsGUIrGGIVzS0VXY0kH@DmZ3LgihJElhMCfyYL1qpkAE1W8iDhHxtGN8T6Yi0xodbBiQhTBn570nX0/4A "APL (Dyalog Unicode) – Try It Online")
`{`…`}` "dfn"; \$n\$ is `⍺` (leftmost Greek letter) and \$L\$ is `⍵` (rightmost Greek letter):
 `⌽⍵` reverse \$L\$
 `+\` prefix sums of that
 `(`…`)<` Boolean mask where less than:
  `⍺↑⍵` take the first \$n\$ elements of \$L\$
  `+/` sum those
 `⊥⍨` [count trailing truths](https://codegolf.stackexchange.com/a/98764/43319)
 `⍺⌈` the maximum of \$n\$ and that
 `⍵↓⍨` drop that many elements from the front of \$L\$
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~13~~ 12 bytes
*1 byte saved thanks to [@Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe), based on the answer by [@MickyT](https://codegolf.stackexchange.com/users/31347/mickyt)*.
```
:&)PtYsbs>~)
```
Output is in ascending order.
[Try it online!](https://tio.run/##y00syfn/30pNM6Aksjip2K5O8/9/I65oUwMDHSMgNjSFYiNTHUMg39wUhEyByEDHxEDHGIyMgPJgZKFjCobGOkZAaKhjoKNrpKNrHAsA) Or [verify all test cases](https://tio.run/##dY@xCgIxDIb3PohwkEKaNterg5MP4OAiR0GddbqbffX6px46SfJDk4/@SZ639dGubb8bTutluS@H19CO5yZuVmYSKOgmUQqos1oqkikxxZ4C3nMi7RFJEIGYvJCP1cERuKPqsptzxwYTeSUP6INUF9z89eNPG4WP3JEtEJVsFaW/0afxz1a38fhcSoEmKnhPds04ksLOlMw82aWQ3QKcKUY0@iqwS5Ao1zc).
### Explanation
Consider inputs `2` and `[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]`.
```
:      % Implicit input: n. Push [1 2 ... n]
       % STACK: [1 2]
&)     % Implicit input: array. Two-output indexing: pushes the subarray
       % indexed by [1 2 ... n] and the remaining subarray
       % STACK: [500 200], [150 150 125 ... -2 -3]
P      % Flip
       % STACK: [500 200], [-3 -2 ... 125 150 150]
t      % Duplicate top of the stack
       % STACK: [500 200], [-3 -2 ... 125 150 150], [-3 -2 ... 125 150 150]
Ys     % Cumulative sum
       % STACK: [500 200], [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946]
b      % Bubble up in the stack
       % STACK: [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946], [500 200]
s      % Sum
       % STACK: [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946], 7
>~     % Greater than, negate; element-wise
       % STACK: [-3 -2 ... 125 150 150], [1 1 ... 1 0 0]
)      % Index. Implicit display
       % STACK: [-3 -2 ... 125]
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~99~~ 97 bytes
```
param($n,$l)do{$a+=$l[$i++]}until($a-gt($l[-1..-$n]-join'+'|iex)-or$i-gt$l.count-$n)$l[($i-2)..0]
```
[Try it online!](https://tio.run/##dZHRboMwDEXf@xWo8kaiOCgJpJRV/Yu9VWhCHd2YGFQt0yZRvp3ZULV7mWIHdK/xscWx/S5P5/eyrkc4bPvxWJyKTwENQi1f2x4KtYV6B5VS@fDVdFUtoNBvnSBR2yjS0OT6o62aUIWXqvyRuj1BRQVQR/uWPqACSbWCRCejyOTjsBAL4TAQOkbt0KBFRydGP501WsPhDMZTJAY9hcd0CmvIdvQkkdMZ9o2UOHed@9hZSBljHWpqqD3qhInMSyfbTlOQRTAuuYNvtsf/jvVIY8TTRDe6JvUK@yM6mlMn7Hhm0LIxpimu6Z2XZWLCi9Im1JIzXa3INphxZmvKjDn3ua4gKRfy8tAvn8tz9xQsFeyV2ohHOATwsjM53zaX8x/CcBOE4TD@Ag "PowerShell – Try It Online")
Takes list in ascending order, output is descending (because it was easier to compare to the test cases :^))
Goes through the list ~~backwards~~ forwards, comparing the accumulator to the last `n` entries added together (via gluing them together with `+`s and passing the resulting string to `invoke-expression`). The Until loop needed additional logic to handle going into the Rich Neighborhood because it wouldn't stop if we're still not richer than the Rich Guys until we churn through the entire list. 
Unrolled:
```
param($n,$list)
do{
  $acc+=$list[$i++]
}until($acc -gt ($list[-1..-$n] -join '+'|invoke-expression) -or ($i -eq $list.count-$n))
$list[($i-2)..0]
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 99 bytes
```
\d+
$*
^
;,
+`;,(1+)(,.*)1$
$1;$2
,
;$'¶$`,
;.*(;.*)
$1$1
T`,`_`.*;
1G`(1+);\1;
.*;
(1*),
$.1,
,$
```
[Try it online!](https://tio.run/##dUxBCgIxELvPO0Zsu6F0ug4KfcB@wOOiFfTgxYP4Nh/gx@p0WY@SBCYTkuftdX9c2sZNtc3XgTjQiQpoqAVOBu8QgxcmlsKZQIW3nzdXO2JwJm8JCx0r6rnGUEim2ntllkLdk5PgQRwFBKbWNCVkk@iqrBDze@1UY8IuYVyYLV94gC4YkQ0Ci8je64v6wKjoU4r/kF9Hvg "Retina 0.8.2 – Try It Online") Link only includes some test cases; I could get it to [work in some cases with negative numbers](https://tio.run/##dU8xbsMwDNz5DhWV7JMhSlZiQygy5hNB4QLt0KVD0Lf1AfmYcxTSbgXvAJInHqnrx/fn19v@5M/bfnkfxQ3yKg0ybg1ex@AxDUGdOG0uC6S559uP25hMgycDFacCf3qZhhaEgxpHlSh6vm4XbV6HEE9NqIpYAXGTQuBk32tKyKTWB3OFsj5WQyUS5oTSkal3LKg9CjJDkRAzIiuh@BDkb4Cq2guSPRXzLxW2qeL/0F@zPpGwriu5YGW@2ImHAypNjLNZznY@aQdSPqIUNvr6ijiTmb/Jdw "Retina 0.8.2 – Try It Online") at a cost of 12 bytes (in particular the first `n` entries in `L` still need to be positive; theoretically I could probably only require the sum of the first `n` entries to be positive). Explanation:
```
\d+
$*
```
Convert to unary.
```
^
;,
```
Insert a marker at the start of `L`.
```
+`;,(1+)(,.*)1$
$1;$2
```
Move it down the list `n` times, summing as we go. This deletes `n` but its comma remains.
```
,
;$'¶$`,
```
Create an entry for each suffix of `L`.
```
;.*(;.*)
$1$1
```
Replace the middle with a copy of the suffix.
```
T`,`_`.*;
```
Sum the copy of the suffix.
```
1G`(1+);\1;
```
Take the first entry where the suffix sum does not exceed the prefix sum.
```
.*;
```
Delete the sums.
```
(1*),
$.1,
```
Convert to decimal.
```
.,$
```
Delete the trailing comma that came before `n`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 17 bytes
```
ＩΦθ¬∨‹κη‹Σ…θηΣ✂θκ
```
[Try it online!](https://tio.run/##LYrBCsIwEER/pcctTCFJDQoeA55EhR5LDyUEUhpbTaPg18ckdOcN7M6stqPX6@hifPhpCaTGLdBlcsF4eqO6rYHunq5m22hGZWtUZe8@T1I/7Yyy6ys/2jpVOe3cpE1O5nqfc4x9LxmDSOZyt5Dg6T7KjEwwHBjagkh94QRZ1EIkcTA0Ak07QAyx@bo/ "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
  θ                 Input `L`
 Φ ¬                Filter out elements where
      κ             Current index
     ‹              Is less than
       η            Input `n`
    ∨               Logical Or
           θ        Input `L`
          … η       First `n` terms
         Σ          Summed
        ‹           Is less than
              ✂θκ   Remainder of `L`
             Σ      Summed
Ｉ                   Cast to string
                    Implicitly print on separate lines
```
[Answer]
# [Red](http://www.red-lang.org), 63 bytes
```
func[L n][s: sum take/part L n forall L[if s >= sum L[break]]L]
```
[Try it online!](https://tio.run/##dVDLTsMwELz3K@YHLPzaJqkEX5ATV8uHQGOpakkrJ/3@MDaopQi0O5K9O56ddR736@u4D3GTdljTdXoPPaYY5h3m6weW4Tg@XYa8gFWkcx5OJ/ThkDDj5blS@vCWx@EYYx/XSz5MCxKCaA1LGPmGFRjeGykpTA2v4Wpa9mu2kBoOlmGgoSyUi7CbmzJplfJQbCq9kD2UQJGkjI1o7pTbHP3V5kU5HWF@StOOoFgV/BsPT/R9nPyySbGu64gWHc9t2X67hVC@wJdhvvwMUXZnu4FzLFSLlPWEFf3H@vSwfgI "Red – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 86 bytes
```
param($n,$l)$l|?{$k++-ge$n}|?{(&{$l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]};$s})-ge0}
```
[Try it online!](https://tio.run/##pVPvToMwEP/ep2jIbWnDNSmFDtAs7j2MWRatugznHDOaMJ4dr7ABMdMPSu8C9/93d2X3@uH25bMrigYe@ZxXzW61X70I2CIUEorjTQWbMFRPDrY1CWJakXJSQRnOBSxRo4KlvCV/VThYy1CEIay9@0be1ddQ1pIEXTc1YwvBGAp6RRotnVgiM8g5XwgvMHkyW63REEf2xMZiRHJqPVkijYnGuCVD9payNiclQkMn8sgMqr7G6CEA/8rYA01btVcmqCwqilGRoYrpt4ptUW/qQ/s6ugsjQcWaQiMk10umPtQDjy36Fiz@eLpUQ8e/ufap9dCGHZZzVowRaMzznDjDnL4zP8vZDC2B8px4iInfHLGfJJlTjGNStF1RkYTYWH1hPaOR/SHfCOQwBn/BOvySH/mEV8znhwI53XMO7nPn7g/uge4/LDvT3pXvxYEUU/otYEu@rT4AEZxsgXJvQR8ayKtzUMDq5gs "PowerShell – Try It Online")
Unrolled:
```
param($n,$list)
$list|?{$k++-ge$n}|?{                               # tail elements after $n only
    $sumLeftSegmentMinusSumRightSgement = &{        # calc in a new scope to reinit variables $s, $i
        $l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]} # sum(list[0..n-1]) - sum(list[k-1..list.Count-1])
        $s                                          # output sum to the outer scope
    }
    $sumLeftSegmentMinusSumRightSgement -ge 0       # output elements where sum >= 0
}
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 13 bytes
```
(‼≥≤Σ\æ╞`Σ≥▼Þ
```
[Try it online!](https://tio.run/##dU85DsJADOzzipQUXmkv53hLiAQSAgoQDQ@gzQOgTBPgFXT0PCIfWcbmqpBnpLVHOx5v5/v1ardZpjQZD7exu4zd@TFM79fx2M8egwxOt3ufks8btpY86PhNz@TQlyxgwFK0FBQeuqIi1grkUY4sGU8mtBkcIavUZmXelCqLGMkwGYjG@TZzefP1s68xGhOsShIgMEkUpr@l2@zPlt/r8bmua7CiGu9KrikKYtgJo5hHuRSUWyCXFAIGGgV2EfT8yaK7klk8AQ "MathGolf – Try It Online")
## Explanation
Takes input as `n L`
```
(               pops n and decrements (TOS is n-1)
 ‼              apply next two operators to stack simultaneously
  ≥             slice L[n-1:] (gets all elements with index >= n-1)
   ≤            slice L[:n] (gets all elements with index <= n-1)
    Σ           get sum of topmost list (this is the sum of n largest elements)
     \          swap top elements
      æ    ▼    do while false with pop using block of length 4
       ╞        discard from left of string/array
        `       duplicate the top two items on the stack
         Σ      sum the list which is on top
          ≥     is the sum of the partial list >= the desired sum?
            Þ   discard everything but TOS
```
The reason why this works is that in the first step, we actually divide the list into two overlapping parts. As an example, `L = [4, 3, 2, 1], n = 2` will split up the list as `[3, 2, 1]` and `[4, 3]`. The reason for having an extra element in the first list is that in the loop, the first thing that happens is a discard. If an extra element was not prepended, the cases where the output should be the entire rest of the list would fail. 
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 40 bytes
```
Drop@##//.{a_,b__}/;a+b>Tr@Take@##:>{b}&
```
[Try it online!](https://tio.run/##dU/LasMwELznNwy5ZFTr4Y3tlBod@gE95FaKkUtCQ0lbjG9G3@6O1KShh7IzoNUMs7vnML0dzmE6vYbl@LA8jp9fvijK8m4OPYa@j@V92AzdfvT78H6gtOvmIa6Xp/H0MT0Xqjt6X7ysSz@v5lm0hiWNXGgFhn0tCUJoVBouw1LPaCC5HCzLQENZKBdhIxhKR1avfZ1NyVJBCRR1ZSjVWf0N1j8KG@V0hLlkcbQgrSX4t65ufcuX2zaMaNuWbNDy3aT7tlsIQxOrNKJKt5PpOso1nONH3omJFWlF/z0wDV3F5Rs "Wolfram Language (Mathematica) – Try It Online")
```
Drop@##                     (*don't include the first n values*)
 //.{a_,b__}/;a+b>Tr@Take@##(*while the remaining values sum to greater than the sum of the first n*)
     :>{b}&                 (*drop the first element*)
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 11 bytes
```
Ẏ∑£ȯÞK≬∑¥≤∵
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuo7iiJHCo8ivw55L4oms4oiRwqXiiaTiiLUiLCIiLCJbMTAsIDUsIDUsIDNdXG4yIl0=) Fixed thanks to one of the Sʨɠɠans.
```
 ∑          # Sum
Ẏ           # Of first n
  £         # Stored to register
   ȯÞK      # Suffixes of rest
          ∵ # Maxmimum by...
      ≬---  # Next 3 as lambda...
       ∑    # Sum
         ≤  # Is less than (or equal to)
        ¥   # Register?
```
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 10 bytes (20 nibbles)
```
/|.`,,$>$>_@++<_@-~+
```
```
  .                     # map over
   `,                   # range from zero up to 
     ,$                 # length of arg1 minus 1
       >$               #   drop that many elements from
           @            #   arg1
         >_             #   with arg2 elements already dropped
 |                      # now filter only those lists whose
                   +    #   sum
                 -~     #   subtracted from one
            +           #   added to 
             +          #   the sum of
              <_        #   the first arg2 elements
                @       #   of arg1
                        #   is truthy = greater than zero
/                       # fold over this list of lists from right
                        #   returning the left arg each time
                        #   (so, output the first filtered list)
```
[![enter image description here](https://i.stack.imgur.com/o6rez.png)](https://i.stack.imgur.com/o6rez.png)
[Answer]
## Clojure, ~~66~~ 75 bytes
```
#(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v))
```
Sadly there doesn't seem to be a shorter idiom for the total sum of a sequence.
**Edit**: Oh when adding examples to the [Try it online!](https://tio.run/##fY7BCoMwDIbvPkVgDFKWQq0bgoc9wd5AehCt4BTbVR2M4bO7qOw2loSQH74PUnbuPgW7LFjZGmo4YOecz59YBefhqOEoDDY1XrHwvnvBCZ7ie@JYtHZnhMBgyynwHkZGBI@IoggrN9gH5O@sta8B8hv0Zl7jDfJY0YU7MZD1oOcIftfGpqQpJqlJnkleSLIrY72Z6X8zUaQVMa92i4NM1GbGszHsog9NP3Y9YA383/r4snwA "Clojure – Try It Online") link I noticed that the original answer gave wrong results when many negative numbers were present.
The `doseq` uses "keys" [destructuring](https://clojure.org/guides/destructuring) so it should be somewhat clear which data ends up in which symbol. `#(...)` is an anonymous function, here I'm binding it to the symbol `f`:
```
(def f #(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v)))
(doseq [{:keys [L n]} [{:L [10,5,5,3] :n 2}
                       {:L [7,2,1,-2,-4,-5,-10,-12] :n 7}
                       {:L [30,20,10,0,-10,-20,-30] :n 1}]]
  (println (f L n)))
```
Output:
```
(5 3)
(-12)
(20 10 0 -10 -20 -30)
```
[Answer]
# APL(NARS), 32 chars, 64 bytes
```
{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
```
test and comments:
```
  q←{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
  2 q 500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,¯2,¯3
125 100 75 75 55 50 40 30 30 20 10 10 8 5 5 5 3 2 2 1 0 ¯2 ¯3 
  2 q 10,5,5,3
5 3 
  ⎕fmt  7 q 7,2,1,¯2,¯4,¯5,¯10,¯12
┌1───┐
│ ¯12│
└~───┘
  2 q 0,¯5,¯10,¯15
¯10 ¯15 
  ⎕fmt 1 q 100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5
┌14───────────────────────────┐
│ 15 5 5 5 5 5 5 5 5 5 5 5 5 5│
└~────────────────────────────┘
  2 q 1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,¯15,¯45,¯250
525 525 400 340 120 110 80 77 33 12 0 ¯15 ¯45 ¯250 
  1 q 10,5,5
5 5 
  ⎕fmt  2 q ¯5,¯10,¯13
┌0─┐
│ 0│
└~─┘
  ⎕fmt  1 q 30,20,10,0,¯10,¯20,¯30
┌6───────────────────┐
│ 20 10 0 ¯10 ¯20 ¯30│
└~───────────────────┘
   {v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
                             v←⍺↓⍵   v is ⍵[(⍺+1)..≢⍵] 
                  {⍵↓v}¨¯1+⍳≢v        build the array of array cut v of 0..((≢v)-1) elements
               +/¨                   sum each of these element of array above
      (+/⍺↑⍵)≥                       compare ≥ with the sum of ⍵[1..⍺] obtain one bolean array
                                     has the same lenght of v
   v/⍨                               return the element of v that are 1 of the boolean array above
```
I reported wrongly the byte length...
]