Besitzen die 26 reichsten Milliardäre so viel Vermögen wie die ärmsten 3,8 Milliarden Menschen?

37

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 .Lnn1n<length of LL n L
LnL

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=2L[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 .nLn = 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 . Ln = 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 , 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]
Kevin Cruijssen
quelle
Kann ich eine Antwort schreiben, die nur mit positiven (oder möglicherweise nicht negativen; ich habe sie noch nicht geschrieben) Ganzzahlen funktioniert, da in der Sprache kein ganzzahliger Typ vorhanden ist?
Neil,
3
@Neil Ich nehme an, du redest hier über Retina? Sie können jedoch davon ausgehen, dass in diesem Fall alle Werte nicht negativ sind. Wenden Sie sich am besten auch an eine zweite Version, die für negative Werte geeignet ist, da ich das Gefühl habe, dass dies tatsächlich erreichbar sein könnte (mit einer enormen Zunahme der Byteanzahl und einigen Workarounds). Dies ist eher ein allgemeines Gefühl als eine tatsächliche Tatsache, nicht sicher, ob es tatsächlich möglich ist, den negativen Werteteil zu umgehen.
Kevin Cruijssen
6
Der reale Testfall würde so aussehen [131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]
Arnauld
2
Was ist mit dem Szenario, in dem keiner der Werte die Kriterien erfüllt: [1,2,3] n = 1? Was willst du für die Ausgabe?
1.
@ouflak Siehe die dritte Herausforderungsregel: " Die Ausgabe ist garantiert nicht leer. Sie müssen sich also nicht mit ähnlichen L = [-5,-10,-13]und n=2resultierenden Testfällen befassen []. " Außerdem ist die Eingabeliste garantiert absteigend sortiert (oder Aufsteigend, wenn Sie möchten), [1,2,3]ist also zunächst keine gültige Eingabeliste (es sei denn, Sie wählen eine aufsteigende Eingabe, in diesem Fall [1,2]wäre dies das Ergebnis).
Kevin Cruijssen

Antworten:

17

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!

Abgelaufene Daten
quelle
Ich denke, Sie könnten zwei weitere abschneiden, indem Sie +bdas SkipGespräch beenden. Es ist überflüssig, die erste nListe zu überprüfen , aber ich denke, es ist immer noch richtig.
TheRubberDuck
3
@TheRubberDuck Nein, ich musste es für den Fall hinzufügen, dass sich das Präfix und das Suffix überlappen. Dh [10,5,5,3], n = 2
Abgelaufene Daten
64 Bytes
LiefdeWen
@LiefdeWen nett! Es ist eigentlich auch weniger, wenn wir eine Curry-Funktion verwenden
abgelaufene Daten
@ExpiredData Oh ja, habe vergessen, dass ich es entfernt habe.
LiefdeWen
12

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

ymbirtt
quelle
Exapunks können mit IIRC keine Lösungen speichern? In diesem Fall sollten Sie die Byteanzahl anstelle der Spielanweisungen verwenden.
Weizen-Zauberer
1
@ SriotchilismO'Zaic, yep, ich dachte nicht, dass die Dateien leicht zugänglich sein sollten, aber ich habe sie gerade gefunden. Ich werde die Größe auf der Festplatte hinzufügen. Eine Reihe von Metadaten, die ich nicht geschrieben habe, werden daneben gespeichert, aber ich denke, dies ist der beste Weg, um tatsächlich eine einzelne "Byteanzahl" aus diesem Spiel herauszuholen.
Ymbirtt
Ich würde mir gerne die Zeit nehmen, diese Dateien anzusehen und zu prüfen, ob es eine Möglichkeit gibt, die Metadaten nach unten zu sortieren. Ich frage mich auch, ob einige Anweisungen mehr Speicher benötigen als andere.
Weizen-Assistent
@ SriotchilismO'Zaic, das tun sie tatsächlich. Alle Anweisungen werden als Klartext gespeichert, sodass wir zunächst alle Markierungen in Einzelbuchstaben-IDs umwandeln können. Dort steht der Name Ihrer Lösung, sodass wir einige Bytes entfernen können, indem wir die Lösung 'a' aufrufen. Einige Teile davon scheinen jedoch auch mit dem virtuellen Netzwerk zu tun zu haben, das Sie für den EXA erstellt haben. Ehrlich gesagt denke ich, dass der "fairste" Weg, EXAPUNKS-Lösungen zu bewerten, darin besteht, entweder die Byteanzahl des tatsächlichen Codes oder die Anzahl der Anweisungen zu verwenden. Dies könnte einen Meta-Post wert sein ...
ymbirtt
2
@ymbirtt Ich nehme an, die Frage lautet dann: Könntest du einen Dolmetscher schreiben, der die Anweisungen ansieht und in die gespeicherten Daten konvertiert? Nun ja, einfach ein Programm schreiben, das für Sie von der Quelle eingibt. Es würde jedoch als eine andere Sprache gelten.
Abgelaufene Daten
11

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.

TFeld
quelle
2
eigentlich die am besten lesbare +1
Kryštof Řeháček
10

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
Emigna
quelle
2
"Genau" das gleiche wie das, was ich als Lösung vorbereitet hatte. Und mit "genau" meine ich meinen .$.sʒO²¹£O>‹}θ. :)
Kevin Cruijssen
2
@ KevinCruijssen hier ist 12
Grimmy
1
Nur ASCII 12 (unter Verwendung einer anderen Eingabemethode).
Grimmy
1
@ Grimy: Huh. Ich wusste nie, |überschrieb die last-input, interessant.
Emigna
2
@Grimy: Siehe das gegen das . Normalerweise wird, wenn alle Eingaben belegt sind, die letzte Eingabe implizit für alle Instanzen der nächsten Eingabe verwendet. Wenn Sie |hier verwenden, wird das Ergebnis |zur letzten Eingabe anstelle der letzten Eingabe.
Emigna
7

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)
Galen Ivanov
quelle
7

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!

Wert Tinte
quelle
7

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]
MickyT
quelle
@ Giuseppe wie immer danke. Versucht, die XVerwendung zu entfernen , -(1:n)aber das war natürlich die gleiche Größe, so ließ es
MickyT
6

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
Arnauld
quelle
1
@ KevinCruijssen Scheint, als hätte ich die Anforderung falsch verstanden. Sollte jetzt behoben sein.
Arnauld
5

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.

Jitse
quelle
4

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

Sok
quelle
@ Mr.Xcoder Meine Güte, was für eine offensichtliche Rettung! Danke 👍
Sok
4

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
)
tsh
quelle
4

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.

Khuldraeseth na'Barya
quelle
3

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
Zottelig
quelle
3

Jelly , 13-12 Bytes

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

Probieren Sie es online!

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

Ln

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)
Nick Kennedy
quelle
Sie können ein Byte speichern, indem Sie Folgendes sortieren statt filtern:ṫḊÐƤS>¥ÞḣS¥Ḣ
Jonathan Allan,
3

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)
Giuseppe
quelle
3

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.

cole
quelle
3

APL (Dyalog Unicode) , 23 21 Byte SBCS

nL

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

Probieren Sie es online!

{}nL

⌽⍵L

+\ Präfixsummen davon

()< Boolesche Maske, bei der weniger als:

  ⍺↑⍵nL

  +/ summiere diese

⊥⍨Hinterwahrheiten zählen

⍺⌈n

⍵↓⍨L

Adam
quelle
1
@ KevinCruijssen Schön entdeckt. Fest.
Adám
3

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]
Luis Mendo
quelle
3

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]
Veskah
quelle
3

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.

Neil
quelle
n
1
@KevinCruijssen Meine Version mit negativen Zahlen erwies sich als unerschwinglich langsam, aber ich habe es geschafft, dies mithilfe der rOption zu beheben. Deshalb habe ich sie jetzt mit einigen Testfällen verknüpft.
Neil
2

Kohle , 17 Bytes

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

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
I                   Cast to string
                    Implicitly print on separate lines
Neil
quelle
2

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
}
mazzy
quelle
2

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.

maxb
quelle
2

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*)
attinat
quelle
1

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)
NikoNyrh
quelle
1
Würde es Ihnen etwas ausmachen, ein TIO mit Testcode hinzuzufügen (ich sehe Clojure in der Liste)? Wenn dies nicht möglich ist (Versionsinkongruenz oder Verwendung von integrierten Funktionen, die nicht in TIO verfügbar sind), können Sie einen Screenshot mit einigen Testfällen als Bestätigung für die Funktionsfähigkeit einfügen?
Kevin Cruijssen
1

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

RosLuP
quelle
1

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 !

Andrei Odegov
quelle