Introducción:

Hace unos días leí esta publicación con el mismo título cuando la encontré en el HNQ. En esta pregunta se está discutiendo si el reclamo del presidente candidato Bernie Sanders, quien afirmó lo siguiente:

Hoy, los 26 multimillonarios más ricos del mundo, 26, poseen ahora tanta riqueza como los 3,8 mil millones de personas más pobres del planeta, la mitad de la población mundial.
^{Enlace al video}

es cierto o no Vaya a la pregunta en sí para obtener respuestas y discusiones allí.

En cuanto al desafío real basado en esta afirmación:

Reto:

Dos entradas: una lista de números ordenada descendente $L$ y un número $n$ (donde $n$ es $1\leq n\lt \text{length of }L$ ).
Salida: la posible sufijo sub-lista más larga de $L$ para los que la suma total es $\leq$ la suma de los primeros $n$ valores en la lista $L$ .

Ejemplo:

Entradas: $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]y $n=2$ .
Salida:[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

¿Por qué?

Los primeros $n=2$ valores de la lista $L$ ( [500,200]) suman 700. Si tomamos todos los sufijos de los números restantes, así como sus sumas:

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

El sufijo más largo que tiene una suma menor o igual a 700es [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]con una suma de 643, así que ese es nuestro resultado.

Reglas de desafío:

• Los valores en el primer $n$ prefijo no se cuentan para el sufijo de salida. Es decir, las entradas $L$ = [10,5,5,3]y $n=2$ se traduciría en [5,3], y no [5,5,3].
• I / O es flexible. Puede ingresar $L$ como una lista / secuencia / matriz de enteros / decimales / cadenas, una sola cadena delimitada, una por una a través de STDIN, etc. También puede generar una lista / secuencia / matriz de enteros / decimales / cadenas, imprima / devuelva una cadena delimitada, imprima un número en cada línea nueva, etc. Su llamada.
• La salida garantiza que no está vacía. Por lo que no tendrá que hacer frente a los casos de prueba como $L$ = [-5,-10,-13]y $n=2$ dando como resultado [].
• Tanto (como cualquiera) la entrada y / o salida también pueden estar en orden ascendente en lugar de orden descendente si lo desea.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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]

C # (compilador interactivo de Visual C #) , 88 81 69 68 63 bytes

-4 bytes gracias a LiefdeWen

a=>b=>a.Skip(b).Where((x,i)=>a.Skip(i+b).Sum()<a.Take(b).Sum())

Pruébalo en línea!

EXAPUNKS (2 EXA, 30 instrucciones, archivo de solución de 594 bytes)

Quería probar un desafío de código de golf en EXAPUNKS por un tiempo, y parecías el mejor ajuste que pude encontrar, ¡felicidades!

Entrada a través de los archivos 200 y 201, para L yn respectivamente. Salida a través de un nuevo archivo. L y la salida están en orden ascendente.

Básicamente, XA suma los últimos n valores en L, luego lo envía a XB. Luego busca el comienzo de L y envía cada valor uno por uno a XB. XB primero recibe el total de XA y lo almacena en el registro X. Luego recibe valores uno por uno de XA, deduciendo el nuevo valor de X y escribiendo esos valores en el archivo de salida hasta 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 para el nivel aquí

Python 2 , 60 bytes

l,n=input()
s=sum(l[:n])
while sum(l[n:])>s:n+=1
print l[n:]

Pruébalo en línea!

Explicación:

Primero toma la suma de los primeros nelementos.

Luego, la suma de cada sublista se compara con esta suma. Tan pronto como uno no es más grande, nos detenemos.

Luego se imprime la sublista resultante (la más larga).

05AB1E , 14 12 bytes

Guardado 2 bytes gracias a Grimy

.$ΔDOI¹£O›.$

Pruébalo en línea!

Explicación

.$               # 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

J , 18 bytes

}.#~+/@{.>:+/\.@}.

Pruébalo en línea!

Explicación:

Un verbo diádico, tomando ncomo argumento izquierdo y L- como argumento derecho.

                }.  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)

Ruby , 47 43 bytes

$n$

-4 bytes leyendo la especificación más de cerca.

->a,n{s=a.pop(n).sum;a.pop while a.sum>s;a}

Pruébalo en línea!

R , 53 55 bytes

@Giuseppe me ahorró 2 bytes cambiando la forma en que se realizó la eliminación

function(n,L,Y=rev(L[0:-n]))Y[cumsum(Y)<=sum(L[1:n])]

Pruébalo en línea! Toma la entrada como descendente y las salidas en ascendente según lo permitido por la regla 4.

• Yes la revolución de Lwith 1: n eliminado usando0:-n
• vuelve de Ydonde la suma acumulativa es menor que igual a la suma deL[X]

JavaScript (ES6), 66 bytes

Toma la entrada como (a)(n)con la lista en orden ascendente.

a=>n=>(g=s=>n?g(s+a.pop(n--)):eval(a.join`+`)>s?g(s,a.pop()):a)(0)

Pruébalo en línea!

Comentado

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

Python 2 , 59 bytes

También compatible con Python 3

f=lambda l,n:l[n:]*(sum(l)/2>=l.pop(n)+sum(l[n:]))or f(l,n)

Pruébalo en línea!

Explicación

La suma del sufijo se compara con la mitad de la suma de la lista completa. Si la suma del sufijo es menor o igual, se devuelve el sufijo. Si no, la función se llama recursivamente con el primer elemento del sufijo desplegado.

Pyth , 16 15 bytes

efgs>vzQsT._<vz

Pruébalo en línea!

Se espera que la lista de entrada se ordene en orden ascendente, en lugar de descender como se usa en los ejemplos.

Es en momentos como este cuando realmente desearía que Pyth tuviera un solo operador de token para acceder a la segunda entrada más de una vez ( Eevalúa la siguiente línea de entrada, pero las llamadas repetidas descartan la lectura del valor anterior).

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

Editar: guardado 1 byte gracias a MrXcoder

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

Pruébalo en línea!

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
)

Stax , 12 bytes

îo╧╫Σ↑>'qµΣº

¡Ejecútelo y depúrelo en staxlang.xyz!

Versión más bonita

Desempaquetado (14 bytes) y explicación:

:/|]{|+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?

Por consenso , puedo dejar este resultado en la pila. Stax intentará una impresión implícita, que podría fallar, pero agregar un archivo mal programa desempaquetado le permite ver la salida muy bien.

Parece que { ... }jes lo mismo que { ... fh. Huh Editar: Ese no es el caso; lo primero se detendrá cuando obtenga un resultado verdadero, posiblemente evitando efectos secundarios o un error fatal más adelante.

APL + WIN, 27 bytes

Solicita la entrada de L y luego n.

⌽((+/n↑v)≥+\m)/m←⌽(n←⎕)↓v←⎕

Pruébalo en línea! Cortesía de Dyalog Classic.

Japt , 16 bytes

£sV+YÃæ_x §U¯V x

Intentalo

£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

Jalea , 13 12 bytes

ṫḊÐƤS>¥ÞḣS¥Ḣ

Pruébalo en línea!

¡Gracias a @JonathanAllan por guardar un byte!

$L$$n$

Explicación

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

Gaia , 12 bytes

eSe¤Σ¤┅⟪Σ⊃⟫∇

Pruébalo en línea!

Creo que hay un byte que puedo jugar al golf si obtengo la pila correcta.

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)

Haskell , 46 bytes

Disgustado con cómo se ve esto; Espero que solo me falten algunos campos de golf obvios.

n#l=until(((sum$take n l)>=).sum)tail$drop n l

Pruébalo en línea!

Intenté obtener el prefijo y el sufijo usando splitAtuna coincidencia de patrones en una protección, pero resultó ser 3 bytes más. Planeando intentar convertir a una función recursiva con guardias más tarde para ver si eso reduce el recuento de bytes.

Explicación

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

A lo que me refiero como "el prefijo" son los primeros nelementos y "el sufijo" es el resto de la lista.

APL (Dyalog Unicode) , 23 21 bytes ^SBCS

$n$$L$

{⍵↓⍨⍺⌈⊥⍨(+/⍺↑⍵)<+\⌽⍵}

Pruébalo en línea!

{}$n$⍺$L$⍵

 ⌽⍵$L$

 +\ sumas de prefijo de eso

 (... )< Máscara booleana donde menos de:

  ⍺↑⍵$n$$L$

  +/ suma esos

 ⊥⍨ contar las verdades finales

 ⍺⌈$n$

 ⍵↓⍨$L$

MATL , 13 12 bytes

1 byte guardado gracias a @Giuseppe , basado en la respuesta de @MickyT .

:&)PtYsbs>~)

La salida está en orden ascendente.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere las entradas 2y [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]

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]

Pruébalo en línea!

Toma la lista en orden ascendente, la salida es descendente (porque fue más fácil de comparar con los casos de prueba: ^))

Recorre la lista hacia atrás y hacia adelante, comparando el acumulador con las últimas nentradas agregadas (pegándolas con+ sy pasando la cadena resultante a invoke-expression). El ciclo Hasta necesitaba lógica adicional para manejar el acceso al Barrio Rico porque no se detendría si aún no somos más ricos que los Hombres Ricos hasta que recorramos toda la lista.

Desenrollado:

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]

Retina 0.8.2 , 99 bytes

\d+
$*
^
;,
+`;,(1+)(,.*)1$
$1;$2
,
;$'¶$`,
;.*(;.*)
$1$1
T`,`_`.*;
1G`(1+);\1;
.*;

(1*),
$.1,
,$

Pruébalo en línea! El enlace solo incluye algunos casos de prueba; Podría hacer que funcione en algunos casos con números negativos a un costo de 12 bytes (en particular, las primeras nentradas Laún deben ser positivas; en teoría, probablemente solo podría requerir que la suma de las primeras nentradas sea positiva). Explicación:

\d+
$*

Convierte a unario.

^
;,

Inserte un marcador al comienzo de L.

+`;,(1+)(,.*)1$
$1;$2

Muévalo hacia abajo en la lista de ntiempos, sumando a medida que avanzamos. Esto se elimina npero su coma permanece.

,
;$'¶$`,

Cree una entrada para cada sufijo de L.

;.*(;.*)
$1$1

Reemplace el medio con una copia del sufijo.

T`,`_`.*;

Suma la copia del sufijo.

1G`(1+);\1;

Tome la primera entrada donde la suma del sufijo no excede la suma del prefijo.

.*;

Eliminar las sumas.

(1*),
$.1,

Convierte a decimal.

.,$

Elimine la coma final que vino antes n.

Carbón , 17 bytes

ＩΦθ¬∨‹κη‹Σ…θηΣ✂θκ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ                 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

Rojo , 63 bytes

func[L n][s: sum take/part L n forall L[if s >= sum L[break]]L]

Pruébalo en línea!

PowerShell , 86 bytes

param($n,$l)$l|?{$k++-ge$n}|?{(&{$l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]};$s})-ge0}

Pruébalo en línea!

Desenrollado:

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
}

MathGolf , 13 bytes

(‼≥≤Σ\æ╞`Σ≥▼Þ

Pruébalo en línea!

Explicación

Toma entrada como 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

La razón por la que esto funciona es que en el primer paso, en realidad dividimos la lista en dos partes superpuestas. Como ejemplo, L = [4, 3, 2, 1], n = 2dividirá la lista como [3, 2, 1]y [4, 3]. La razón para tener un elemento adicional en la primera lista es que en el bucle, lo primero que sucede es un descarte. Si no se antepuso un elemento adicional, los casos en los que la salida debería ser el resto de la lista fallarían.

Wolfram Language (Mathematica) , 40 bytes

Drop@##//.{a_,b__}/;a+b>Tr@Take@##:>{b}&

Pruébalo en línea!

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

Clojure, 66 75 bytes

#(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v))

Lamentablemente, no parece haber un modismo más corto para la suma total de una secuencia.

Editar : ¡Oh, cuando agregue ejemplos al Probar en línea! Enlace Noté que la respuesta original daba resultados incorrectos cuando había muchos números negativos.

Los dosequsos "claves" desestructurantes por lo que debe ser algo claro extremos que existen datos en la que el símbolo. #(...)es una función anónima, aquí la estoy vinculando al símbolo 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)))

Salida:

(5 3)
(-12)
(20 10 0 -10 -20 -30)

APL (NARS), 32 caracteres, 64 bytes

{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}

prueba y comentarios:

  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

Informé erróneamente la longitud del byte ...

MS SQL Server 2017 , 271 bytes

create function f(@L nvarchar(max),@ int)returns table return
select v
from(select*,sum(iif(n<=@,v,0))over()r,sum(v)over(order by v)p
from(select row_number()over(order by-v)n,v
from STRING_SPLIT(@L,',')cross apply(select
try_parse(value as int)v)t)t)t
where p<=r and @<n

Sé que usar una tabla más parecida a una relación para almacenar los datos de entrada puede hacer que el código sea más conciso, pero usando el tipo de datos de caracteres para almacenar la lista numérica y la STRING_SPLITfunción, acorto la Build Schemaparte :)

Versión más legible:

CREATE FUNCTION f(@L NVARCHAR(MAX), @n INT)
  RETURNS TABLE AS RETURN (
    SELECT
      v
    FROM (
      SELECT
        *,
        SUM(IIF(n<=@n, v, 0)) OVER() AS r,
        SUM(v) OVER(ORDER BY v) AS p
      FROM(
        SELECT ROW_NUMBER() OVER(ORDER BY -v) AS n, v
        FROM STRING_SPLIT(@L, ',')
        CROSS APPLY(
          SELECT TRY_PARSE(value AS INT) AS v
        ) AS t
      ) AS t
    ) AS t
    WHERE p <= r AND @n < n
  );

Pruébalo en SQL Fiddle !

Python 3.8 (prelanzamiento) , 59 bytes

La salida está en orden ascendente

def f(l,n):
 s=sum(l[:n])
 while(w:=l.pop())<s:yield w;s-=w

Pruébalo en línea!