Introduzione:

Qualche giorno fa ho letto questo post con lo stesso titolo quando l'ho trovato nell'HNQ. In questa domanda si sta discutendo se la richiesta del presidente candidato Bernie Sanders, che ha affermato quanto segue:

Oggi i 26 miliardari più ricchi del mondo, 26, ora possiedono la stessa ricchezza dei 3,8 miliardi più poveri del pianeta, metà della popolazione mondiale.
^{Link al video}

è vero o no. Per favore vai alla domanda stessa per risposte e discussioni lì.

Per quanto riguarda la vera sfida basata su questa affermazione:

Sfida:

Due input: una lista numerica $L$ decrescente e un numero $n$ (dove $n$ è $1\leq n\lt \text{length of }L$ ).
Output: il sottoelenco del suffisso più lungo possibile di $L$ per cui la somma totale è $\leq$ la somma della prima$n$ valori nella lista .$L$

Esempio:

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

Perché?

I primi valori dell'elenco$n=2$$L$ ( [500,200]) si sommano a 700. Se prendiamo tutti i suffissi dei numeri rimanenti, nonché le loro somme:

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

Il suffisso più lungo che ha una somma inferiore o uguale a 700è [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 somma di 643, quindi questo è il nostro risultato.

Regole della sfida:

• I valori nel primo prefisso non vengono conteggiati nel suffisso di output. Cioè input L = e n = 2$n$$L$[10,5,5,3]$n=2$ comporterebbe [5,3], e non [5,5,3].
• L'I / O è flessibile. Puoi inserire$L$ come elenco / flusso / array di numeri interi / decimali / stringhe, una singola stringa delimitata, uno a uno tramite STDIN, ecc. È anche possibile eseguire l'output come elenco / flusso / array di numeri interi / decimali / stringhe, stampa / restituisce una stringa delimitata, stampa un numero su ogni nuova riga, ecc. La tua chiamata.
• L'output è garantito per non essere vuoto. Quindi non dovrai occuparti di casi di test come $L$ = [-5,-10,-13]e $n=2$ risultanti [].
• Entrambi (o uno) l'ingresso e / o l'output possono anche essere in ordine crescente anziché in ordine decrescente se lo si desidera.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta si applicano le regole standard I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Scappatoie predefiniteSono vietate le .
• Se possibile, aggiungi un link con un test per il tuo codice (ad es TIO ).
• Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

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 # (compilatore interattivo Visual C #) , 88 81 69 68 63 byte

-4 byte grazie a LiefdeWen

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

Provalo online!

EXAPUNKS (2 EXAs, 30 istruzioni, file soluzione 594 byte)

Ho voluto provare una sfida di golf in codice in EXAPUNKS per un po ', e tu mi sei sembrata la soluzione migliore che ho trovato, quindi complimenti!

Immettere tramite i file 200 e 201, rispettivamente per L e n. Uscita tramite un nuovo file. L e l'uscita sono in ordine crescente.

Fondamentalmente, XA somma gli ultimi n valori in L, quindi li invia a XB. Quindi cerca l'inizio di L e invia ciascun valore uno a uno a XB. XB riceve prima il totale da XA e lo memorizza nel registro X. Quindi riceve i valori uno a uno da XA, sottraendo il nuovo valore da X e scrivendo tali valori nel file di output fino a 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 per il livello qui

Python 2 , 60 byte

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

Provalo online!

Spiegazione:

Prima prende la somma dei primi noggetti.

Quindi la somma di ciascun elenco secondario viene confrontata con questa somma. Non appena uno non è più grande, ci fermiamo.

Quindi viene stampato l'elenco secondario (più lungo) risultante.

05AB1E , 14 12 byte

Salvato 2 byte grazie a Grimy

.$ΔDOI¹£O›.$

Provalo online!

Spiegazione

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

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

Provalo online!

Spiegazione:

Un verbo diadico, prendendo ncome argomento di sinistra e L- come argomento di destra.

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

rubino , 47 43 byte

$n$ elementi dalla fine dell'array per ottenere la somma iniziale, quindi continua a rimuovere gli elementi fino a quando la somma degli elementi rimanenti è inferiore alla somma iniziale.

-4 byte leggendo le specifiche più da vicino.

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

Provalo online!

R , 53 55 byte

@Giuseppe mi ha salvato 2 byte cambiando il modo in cui è stata rimossa

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

Provalo online! Prende l'input come decrescente e gli output in ordine crescente come consentito dalla regola 4.

• Y è il giro di L con 1: n rimosso usando0:-n
• ritorna da Ydove la somma cumulativa è inferiore alla somma diL[X]

JavaScript (ES6), 66 byte

Accetta input come (a)(n)con l'elenco in ordine crescente.

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

Provalo online!

Commentate

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 byte

Compatibile anche con Python 3

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

Provalo online!

Spiegazione

La somma del suffisso viene confrontata con la metà della somma dell'intero elenco. Se la somma del suffisso è più piccola o uguale, viene restituito il suffisso. In caso contrario, la funzione viene chiamata in modo ricorsivo con il primo elemento del suffisso spuntato.

Pyth , 16 15 byte

efgs>vzQsT._<vz

Provalo online!

L'elenco di input dovrebbe essere ordinato in ordine crescente, anziché decrescente come viene usato negli esempi.

È a volte come questo quando vorrei davvero che Pyth avesse un singolo operatore token per accedere al secondo input più di una volta ( Evaluta la riga successiva di input, ma le chiamate ripetute scartano il valore precedente letto).

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

Modifica: salvato 1 byte grazie a MrXcoder

JavaScript, 64 byte

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

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

Stax , 12 byte

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

Eseguilo e esegui il debug su staxlang.xyz!

Versione più bella

Spacchettato (14 byte) e spiegazione:

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

Per consenso , posso lasciare questo risultato in pila. Stax tenterà una stampa implicita, che potrebbe non riuscire, ma l'aggiunta di un mprogramma decompresso consente di visualizzare correttamente l'output.

Sembra che { ... }jsia lo stesso di { ... fh. Huh. Modifica: non è proprio così; l'unico si fermerà quando otterrà un risultato veritiero, evitando eventualmente effetti collaterali o errori fatali in seguito.

APL + WIN, 27 byte

Richiede l'immissione di L, quindi n.

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

Provalo online! Per gentile concessione di Dyalog Classic

Japt , 16 byte

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

Provalo

£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

Gelatina , 13 12 byte

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

Provalo online!

Grazie a @JonathanAllan per aver salvato un byte!

Un collegamento diadico che prende l'elenco dei valori $L$ come argomento sinistro e il numero $n$ come giusto.

Spiegazione

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

eSe¤Σ¤┅⟪Σ⊃⟫∇

Provalo online!

Penso che ci sia un byte che posso giocare a golf se ottengo lo stack giusto.

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 byte

Scontento di come appare; spero mi manchi qualche golf ovvio.

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

Provalo online!

Ho provato a ottenere il prefisso e il suffisso usando splitAte il pattern matching in una guardia, ma quello si è rivelato essere 3 byte in più. Pianificazione di provare a convertire in una funzione ricorsiva con guardie in seguito per vedere se ciò riduce il conteggio dei byte.

Spiegazione

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

Quello che chiamo "prefisso" sono i primi nelementi e "il suffisso" è il resto dell'elenco.

APL (Dyalog Unicode) , 23 21 byte ^SBCS

Prefisso anonimo lambda, prendendo $n$ come argomento sinistro e $L$ come argomento giusto.

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

Provalo online!

{... } "dfn";$n$è ⍺(lettera greca più a sinistra) e$L$è ⍵(lettera greca più a destra):

 ⌽⍵ inverso $L$

 +\ il prefisso ne somma

 (... )< Maschera booleana dove meno di:

  ⍺↑⍵ prendi il primo $n$ elementi di $L$

  +/ sommare quelli

 ⊥⍨ contare le verità finali

 ⍺⌈ il massimo di $n$ e quello

 ⍵↓⍨ rilasciare molti elementi dalla parte anteriore di $L$

MATL , 13 12 byte

1 byte salvato grazie a @Giuseppe , basato sulla risposta di @MickyT .

:&)PtYsbs>~)

L'output è in ordine crescente.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considerare input 2e [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 byte

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]

Provalo online!

Visualizza l'elenco in ordine crescente, l'output è in ordine decrescente (poiché era più semplice confrontarlo con i casi di test: ^))

Scorre l'elenco in avanti all'indietro , confrontando l'accumulatore con le ultime nvoci aggiunte insieme (incollandole insieme a se +passando la stringa risultante ainvoke-expression ). Il ciclo Until aveva bisogno di una logica aggiuntiva per gestire l'ingresso nel Rich Neighbourhood perché non si fermerebbe se non fossimo ancora più ricchi dei Rich Guy finché non sfogliamo l'intero elenco.

srotolato:

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 byte

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

(1*),
$.1,
,$

Provalo online! Il collegamento include solo alcuni casi di test; Potrei farlo funzionare in alcuni casi con numeri negativi al costo di 12 byte (in particolare le prime nvoci inL devono ancora essere positive; in teoria probabilmente potrei richiedere solo che la somma delle prime nvoci sia positiva). Spiegazione:

\d+
$*

Converti in unario.

^
;,

Inserire un marcatore all'inizio di L .

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

Spostalo in basso nell'elenco nvolte, sommando mentre procediamo. Questo cancellan ma la sua virgola rimane.

,
;$'¶$`,

Crea una voce per ogni suffisso di L .

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

Sostituisci il centro con una copia del suffisso.

T`,`_`.*;

Somma la copia del suffisso.

1G`(1+);\1;

Prendi la prima voce in cui la somma del suffisso non supera la somma del prefisso.

.*;

Elimina le somme.

(1*),
$.1,

Converti in decimale.

.,$

Elimina la virgola finale precedente n.

Carbone , 17 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  θ                 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

Rosso , 63 byte

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

Provalo online!

PowerShell , 86 byte

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

Provalo online!

srotolato:

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 byte

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

Provalo online!

Spiegazione

Accetta input come 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

Il motivo per cui funziona è che, nel primo passaggio, dividiamo effettivamente l'elenco in due parti sovrapposte. Ad esempio, L = [4, 3, 2, 1], n = 2suddividerà l'elenco come [3, 2, 1]e [4, 3]. La ragione per avere un elemento in più nel primo elenco è che nel loop, la prima cosa che succede è uno scarto. Se un elemento aggiuntivo non fosse anteposto, i casi in cui l'output dovrebbe essere l'intero resto dell'elenco fallirebbero.

Wolfram Language (Mathematica) , 40 byte

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

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

Clojure, 66 75 byte

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

Purtroppo non sembra esserci un linguaggio più breve per la somma totale di una sequenza.

Modifica : Oh quando aggiungi esempi a Provalo online! link Ho notato che la risposta originale ha dato risultati errati quando erano presenti molti numeri negativi.

Le doseq"chiavi" usi destrutturazione quindi dovrebbe essere in qualche modo chiaro fini che di trasferimento dati fino a che il simbolo. #(...)è una funzione anonima, qui la sto legando al simbolo 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)))

Produzione:

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

APL (NARS), 32 caratteri, 64 byte

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

test e commenti:

  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

Ho riportato erroneamente la lunghezza del byte ...

MS SQL Server 2017 , 271 byte

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

So che l'utilizzo di una tabella più simile a una relazione per memorizzare i dati di input può rendere il codice più conciso, ma utilizzando il tipo di dati carattere per memorizzare l'elenco numerico e la STRING_SPLITfunzione, accorciamo la Build Schemaparte :)

Versione più leggibile:

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

Provalo su SQL Fiddle !

Python 3.8 (pre-release) , 59 byte

L'output è in ordine crescente

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

Provalo online!