Einführung:

Vor ein paar Tagen habe ich diesen Beitrag mit demselben Titel gelesen, als ich ihn im HNQ gefunden habe. In dieser Frage wird diskutiert, ob die Behauptung der Präsidentschaftskandidatin Bernie Sanders, die folgendes behauptete:

Heute besitzen die 26 reichsten Milliardäre der Welt, 26, so viel Wohlstand wie die ärmsten 3,8 Milliarden Menschen auf dem Planeten, die Hälfte der Weltbevölkerung.
^{Link zum Video}

ist wahr oder nicht. Bitte gehen Sie zur Frage selbst, um dort Antworten und Diskussionen zu erhalten.

Was die eigentliche Herausforderung betrifft, die auf dieser Behauptung basiert:

Herausforderung:

Zwei Eingänge: ein absteigend sortiert Zahlenliste und eine Anzahl (wobei ist ). Ausgabe: Die längste mögliche Suffix-Teilliste von für die die Gesamtsumme die Summe der ersten Werte in Liste .$L$$n$$n$$1\leq n\lt \text{length of }L$L ≤ n L
$L$$\leq$$n$$L$

Beispiel:

Eingänge: = und . Ausgabe:$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$
[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

Warum?

Die ersten Werte der Liste ( ) summieren sich zu . Wenn wir alle Suffixe der verbleibenden Zahlen sowie deren Summen nehmen:$n=2$$L$[500,200]700

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

Das längste Suffix mit einer Summe kleiner oder gleich 700ist [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]mit einer Summe von 643, also ist das unser Ergebnis.

Herausforderungsregeln:

• Werte im ersten Präfix werden nicht zum Ausgabesuffix gezählt. Dh Eingaben = und würden dazu führen , und nicht .$n$$L$n = 2[10,5,5,3]$n=2$[5,3][5,5,3]
• I / O ist flexibel. Sie können als Liste / Stream / Array von Ganzzahlen / Dezimalzahlen / Zeichenfolgen, eine einzelne durch Trennzeichen getrennte Zeichenfolge, eine nach der anderen durch STDIN usw. eingeben. Sie können als Liste / Stream / Array von Ganzzahlen / Dezimalzahlen / Zeichenfolgen ausgeben. Drucken / Zurückgeben einer begrenzten Zeichenfolge, Drucken einer Nummer in jeder neuen Zeile usw. Ihr Anruf.$L$
• Die Ausgabe ist garantiert nicht leer. Sie werden also nicht mit Testfällen wie zu tun haben = und führt . $L$n = 2[-5,-10,-13]$n=2$[]
• Sowohl (als auch) die Eingabe und / oder Ausgabe kann auch in aufsteigender Reihenfolge statt in absteigender Reihenfolge erfolgen, wenn Sie dies wünschen.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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 # (Visual C # Interactive Compiler) , 88 81 69 68 63 Byte

-4 Bytes dank LiefdeWen

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

Probieren Sie es online!

EXAPUNKS (2 EXAs, 30 Anweisungen, 594-Byte-Lösungsdatei)

Ich wollte eine Weile eine Code-Golf-Herausforderung in EXAPUNKS ausprobieren, und Sie sahen so aus, als würden Sie am besten zu mir passen, also herzlichen Glückwunsch!

Eingabe über die Dateien 200 und 201 für L bzw. n. Ausgabe über eine neue Datei. L und die Ausgabe sind in aufsteigender Reihenfolge.

Grundsätzlich summiert XA die letzten n Werte in L und sendet sie dann an XB. Es sucht dann nach dem Anfang von L und sendet jeden Wert einzeln an XB. XB empfängt zuerst die Summe von XA und speichert sie in Register X. Anschließend empfängt XA nacheinander die Werte, zieht den neuen Wert von X ab und schreibt diese Werte in die Ausgabedatei, bis X <0 ist.

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 für das Level hier

Python 2 , 60 Bytes

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

Probieren Sie es online!

Erläuterung:

Zuerst wird die Summe der ersten nElemente genommen.

Dann wird die Summe jeder Unterliste mit dieser Summe verglichen. Sobald einer nicht größer ist, hören wir auf.

Dann wird die resultierende (längste) Unterliste gedruckt.

05AB1E , 14 12 Bytes

2 Bytes dank Grimy gespart

.$ΔDOI¹£O›.$

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Erläuterung:

Ein dyadisches Verb, das nals linkes Argument und L- als rechtes Argument verwendet.

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

Übernimmt eine aufsteigende Liste als Eingabe. Entfernt Elemente vom Ende des Arrays, um die anfängliche Summe zu erhalten, und setzt dann das Entfernen der Elemente fort, bis die Summe der verbleibenden Elemente kleiner als die anfängliche Summe ist.$n$

-4 Bytes durch genaueres Lesen der Spezifikation.

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

Probieren Sie es online!

R , 53 55 Bytes

@ Giuseppe hat mir 2 Bytes gespart und die Art und Weise geändert, wie das Entfernen durchgeführt wurde

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

Probieren Sie es online! Nimmt die Eingabe als absteigend und gibt sie in aufsteigender Reihenfolge aus, wie in Regel 4 zulässig.

• Ywird die Drehzahl von Lmit 1: n mit entfernt0:-n
• Gibt zurück, Ywo die kumulative Summe kleiner ist als die Summe vonL[X]

JavaScript (ES6), 66 Byte

Nimmt die Eingabe wie (a)(n)bei der Liste in aufsteigender Reihenfolge vor.

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

Probieren Sie es online!

Kommentiert

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

Auch kompatibel mit Python 3

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

Probieren Sie es online!

Erläuterung

Die Summe des Suffixes wird mit der Hälfte der Summe der gesamten Liste verglichen. Wenn die Summe des Suffix kleiner oder gleich ist, wird das Suffix zurückgegeben. Wenn nicht, wird die Funktion rekursiv aufgerufen, wobei das erste Element des Suffixes herausspringt.

Pyth , 16 15 Bytes

efgs>vzQsT._<vz

Probieren Sie es online!

Es wird erwartet, dass die Eingabeliste in aufsteigender Reihenfolge sortiert wird und nicht in absteigender Reihenfolge, wie dies in den Beispielen verwendet wird.

In solchen Situationen wünschte ich mir wirklich, ein einzelner Token-Operator könnte mehr als einmal auf die zweite Eingabe zugreifen ( Ewertet die nächste Eingabezeile aus, wiederholte Aufrufe verwerfen jedoch den zuvor gelesenen Wert).

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

Bearbeiten: 1 Byte dank MrXcoder gespeichert

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

Probieren Sie es 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 Bytes

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

Führen Sie es aus und debuggen Sie es unter staxlang.xyz!

Schönere Version

Entpackt (14 Bytes) und Erklärung:

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

Aus Konsens kann ich dieses Ergebnis auf dem Stapel belassen. Stax versucht einen impliziten Druckvorgang, der möglicherweise fehlschlägt. Wenn Sie jedoch ein man das entpackte Programm anhängen , sehen Sie die Ausgabe gut.

Sieht aus wie { ... }jist das gleiche wie { ... fh. Huh. Edit: Das ist nicht ganz der Fall; Erstere hören auf, wenn das Ergebnis wahr ist, und vermeiden möglicherweise später Nebenwirkungen oder einen schwerwiegenden Fehler.

APL + WIN, 27 Bytes

Fordert zur Eingabe von L und dann n auf.

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

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Japt , 16 Bytes

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

Versuch es

£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

Jelly , 13-12 Bytes

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

Probieren Sie es online!

Vielen Dank an @ JonathanAllan für das Speichern eines Bytes!

$L$$n$

Erläuterung

ṫ            | 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¤Σ¤┅⟪Σ⊃⟫∇

Probieren Sie es online!

Ich denke, es gibt ein Byte, das ich spielen kann, wenn ich den richtigen Stack bekomme.

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

Unzufrieden damit, wie das aussieht; Ich hoffe, ich vermisse nur ein paar offensichtliche Golfplätze.

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

Probieren Sie es online!

Ich habe versucht, das Präfix und das Suffix mit splitAtund Pattern Matching in einem Guard abzurufen, aber das waren 3 Bytes mehr. Sie möchten später versuchen, mithilfe von Guards in eine rekursive Funktion zu konvertieren, um festzustellen, ob dies die Anzahl der Bytes verringert.

Erläuterung

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

Was ich als "das Präfix" bezeichne, sind die ersten nElemente und "das Suffix" ist der Rest der Liste.

APL (Dyalog Unicode) , 23 21 Byte ^SBCS

$n$$L$

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

Probieren Sie es online!

{}$n$⍺$L$⍵

 ⌽⍵$L$

 +\ Präfixsummen davon

 (… )< Boolesche Maske, bei der weniger als:

  ⍺↑⍵$n$$L$

  +/ summiere diese

 ⊥⍨ Hinterwahrheiten zählen

 ⍺⌈$n$

 ⍵↓⍨$L$

MATL , 13 - 12 Bytes

1 Byte gespart dank @Giuseppe , basierend auf der Antwort von @MickyT .

:&)PtYsbs>~)

Die Ausgabe erfolgt in aufsteigender Reihenfolge.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie Eingaben 2und [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 bis 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]

Probieren Sie es online!

Nimmt Liste in aufsteigender Reihenfolge, Ausgabe ist absteigend (weil es einfacher war, mit den Testfällen zu vergleichen: ^))

Geht die Liste rückwärts vorwärts durch und vergleicht den Akkumulator mit den zuletzt nhinzugefügten Einträgen (durch Zusammenkleben mit +s und Übergeben der resultierenden Zeichenfolge an invoke-expression). Die Until-Schleife benötigte zusätzliche Logik, um in die Rich Neighborhood zu gelangen, da sie nicht aufhören würde, wenn wir immer noch nicht reicher sind als die Rich Guys, bis wir die gesamte Liste durchgearbeitet haben.

Abgerollt:

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,
,$

Probieren Sie es online! Link enthält nur einige Testfälle; Ich könnte es in einigen Fällen mit negativen Zahlen zu einem Preis von 12 Bytes zum Laufen bringen (insbesondere müssen die ersten nEinträge Lnoch positiv sein; theoretisch könnte ich wahrscheinlich nur die Summe der ersten nEinträge als positiv verlangen ). Erläuterung:

\d+
$*

In Unary konvertieren.

^
;,

Fügen Sie am Anfang von eine Markierung ein L.

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

Verschiebe es nmal die Liste runter und summiere wie wir gehen. Dies wird gelöscht, naber das Komma bleibt erhalten.

,
;$'¶$`,

Erstellen Sie einen Eintrag für jedes Suffix von L.

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

Ersetzen Sie die Mitte durch eine Kopie des Suffixes.

T`,`_`.*;

Summiere die Kopie des Suffix.

1G`(1+);\1;

Nehmen Sie den ersten Eintrag, bei dem die Suffixsumme die Präfixsumme nicht überschreitet.

.*;

Löschen Sie die Summen.

(1*),
$.1,

In Dezimalzahl konvertieren.

.,$

Löschen Sie das vorangegangene Komma n.

Kohle , 17 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

  θ                 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

Rot , 63 Bytes

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

Probieren Sie es online!

PowerShell , 86 Byte

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

Probieren Sie es online!

Abgerollt:

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

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

Probieren Sie es online!

Erläuterung

Übernimmt die Eingabe als 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

Der Grund, warum dies funktioniert, ist, dass wir im ersten Schritt die Liste tatsächlich in zwei überlappende Teile aufteilen. Als Beispiel L = [4, 3, 2, 1], n = 2wird die Liste als [3, 2, 1]und aufgeteilt [4, 3]. Der Grund für ein zusätzliches Element in der ersten Liste ist, dass in der Schleife als Erstes ein Verwerfen erfolgt. Wenn kein zusätzliches Element vorangestellt wird, schlagen die Fälle fehl, in denen die Ausgabe der gesamte Rest der Liste sein soll.

Wolfram Language (Mathematica) , 40 Byte

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

Probieren Sie es 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 Bytes

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

Leider scheint es kein kürzeres Idiom für die Gesamtsumme einer Sequenz zu geben.

Edit : Oh beim Hinzufügen von Beispielen zum Try it online! link Mir ist aufgefallen, dass die ursprüngliche Antwort bei vielen negativen Zahlen zu falschen Ergebnissen führte.

Die doseqverwendet "Schlüssel" -Destrukturierung, so dass etwas klar sein sollte, welche Daten in welchem ​​Symbol landen. #(...)ist eine anonyme Funktion, hier binde ich sie an das 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)))

Ausgabe:

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

APL (NARS), 32 Zeichen, 64 Byte

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

Test und Kommentare:

  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

Ich habe die Bytelänge falsch angegeben ...

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

Ich weiß, dass die Verwendung einer mehr beziehungsähnlichen Tabelle zum Speichern der Eingabedaten den Code prägnanter machen kann, aber wenn STRING_SPLITich den Zeichendatentyp zum Speichern der numerischen Liste und der Funktion verwende, wird der Build SchemaTeil kürzer :)

Mehr lesbare Version:

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

Probieren Sie es auf SQL Fiddle !

Python 3.8 (Vorabversion) , 59 Byte

Die Ausgabe erfolgt in aufsteigender Reihenfolge

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

Probieren Sie es online!