Pengantar:

Beberapa hari yang lalu saya membaca posting ini dengan judul yang sama ketika saya menemukannya di HNQ. Dalam pertanyaan ini sedang dibahas jika klaim calon presiden-Bernie Sanders, yang mengklaim sebagai berikut:

Saat ini 26 miliarder terkaya di dunia, 26, sekarang memiliki kekayaan sebanyak 3,8 miliar orang termiskin di planet ini, setengah dari populasi dunia.
^{Tautan ke video}

benar atau tidak. Silakan buka pertanyaan itu sendiri untuk jawaban dan diskusi di sana.

Adapun tantangan aktual berdasarkan klaim ini:

Tantangan:

Dua input: daftar angka yang diurutkan menurun $L$ dan angka $n$ (di mana $n$ adalah $1\leq n\lt \text{length of }L$ ).
Output: mungkin akhiran sub-daftar terpanjang $L$ yang jumlah total adalah $\leq$ jumlah pertama $n$ nilai-nilai dalam daftar $L$ .

Contoh:

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

Mengapa?

Nilai $n=2$ pertama dari daftar $L$ ( [500,200]) dijumlahkan 700. Jika kita mengambil semua sufiks dari angka yang tersisa, serta jumlah mereka:

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

Akhiran terpanjang yang memiliki jumlah lebih rendah dari atau sama dengan 700adalah [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]dengan jumlah 643, jadi itu adalah hasil kami.

Aturan tantangan:

• Nilai dalam awalan $n$ pertama tidak dihitung ke akhiran-keluaran. Yaitu input $L$ = [10,5,5,3]dan $n=2$ akan menghasilkan [5,3], dan tidak [5,5,3].
• I / O fleksibel. Anda dapat memasukkan $L$ sebagai daftar / aliran / array bilangan bulat / desimal / string, string tunggal yang dibatasi, satu per satu melalui STDIN, dll. Anda dapat menampilkan sebagai daftar / aliran / array bilangan bulat / desimal / string juga, cetak / kembalikan string yang dibatasi, cetak angka pada setiap baris baru, dll. Panggilan Anda.
• Outputnya dijamin tidak kosong. Jadi Anda tidak perlu berurusan dengan kasus uji seperti $L$ = [-5,-10,-13]dan $n=2$ menghasilkan [].
• Baik (atau salah satu) input dan / atau output mungkin juga dalam urutan naik daripada urutan menurun jika Anda memilih untuk.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa yang bukan kode. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

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 byte terima kasih kepada LiefdeWen

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

Cobalah online!

EXAPUNKS (2 EXA, 30 Instruksi, file solusi 594-byte)

Saya ingin mencoba tantangan golf kode di EXAPUNKS untuk sementara waktu, dan Anda tampak sangat cocok untuk saya, jadi, selamat!

Input melalui file 200 dan 201, untuk L dan n masing-masing. Keluaran melalui file baru. L dan output dalam urutan menaik.

Pada dasarnya, XA menjumlahkan nilai n terakhir dalam L, kemudian mengirimkannya ke XB. Kemudian mencari ke awal L dan mengirim setiap nilai satu-per-satu ke XB. XB pertama menerima total dari XA dan menyimpannya di register X. Kemudian menerima nilai satu-per-satu dari XA, mengurangi nilai baru dari X, dan menulis nilai-nilai itu ke file output hingga 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 untuk level di sini

Python 2 , 60 byte

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

Cobalah online!

Penjelasan:

Pertama mengambil jumlah nitem pertama .

Kemudian jumlah masing-masing sublist dibandingkan dengan jumlah ini. Begitu seseorang tidak lebih besar, kita berhenti.

Kemudian sublist yang dihasilkan (terpanjang) dicetak.

05AB1E , 14 12 byte

Disimpan 2 byte berkat Grimy

.$ΔDOI¹£O›.$

Cobalah online!

Penjelasan

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

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

Cobalah online!

Penjelasan:

Kata kerja diad, dengan nargumen kiri dan L- sebagai argumen kanan.

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

Mengambil daftar naik sebagai masukan. Menghapus$n$ item dari akhir array untuk mendapatkan jumlah awal, kemudian lanjutkan menghapus item sampai jumlah elemen yang tersisa kurang dari jumlah awal.

-4 byte dengan membaca spec lebih dekat.

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

Cobalah online!

R , 53 55 byte

@ Giuseppe menyelamatkan saya 2 byte mengubah cara menghapus dilakukan

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

Cobalah online! Mengambil input sebagai turun dan output naik seperti yang diizinkan oleh aturan 4.

• Yadalah rev Ldengan 1: n dihapus menggunakan0:-n
• kembali dari Ytempat jumlah kumulatif kurang dari sama dengan jumlahL[X]

JavaScript (ES6), 66 byte

Mengambil input seperti (a)(n)daftar dalam urutan menaik.

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

Cobalah online!

Berkomentar

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

Juga kompatibel dengan Python 3

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

Cobalah online!

Penjelasan

Jumlah akhiran dibandingkan dengan setengah dari jumlah seluruh daftar. Jika jumlah akhiran lebih kecil atau sama, akhiran dikembalikan. Jika tidak, fungsi ini dipanggil secara rekursif dengan item pertama dari suffix muncul.

Pyth , 16 15 byte

efgs>vzQsT._<vz

Cobalah online!

Daftar input diharapkan untuk disortir dalam urutan menaik, bukan turun seperti yang digunakan dalam contoh.

Ini pada saat-saat seperti ini ketika saya benar-benar berharap Pyth memiliki operator token tunggal untuk mengakses input kedua lebih dari satu kali ( Emengevaluasi baris input berikutnya, tetapi panggilan berulang-ulang membuang nilai yang dibaca sebelumnya).

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

Sunting: disimpan 1 byte berkat 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

Cobalah 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µΣº

Jalankan dan debug di staxlang.xyz!

Versi yang lebih bagus

Dibongkar (14 byte) dan penjelasan:

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

Dengan konsensus , saya dapat meninggalkan hasil ini di tumpukan. Stax akan mencoba cetakan implisit, yang mungkin gagal, tetapi menambahkanm ke program yang dibongkar memungkinkan Anda melihat hasilnya dengan baik.

Sepertinya { ... }jsama dengan { ... fh. Hah. Sunting: Bukan itu masalahnya; satu-satunya yang akan berhenti ketika mendapatkan hasil yang benar, mungkin menghindari efek samping atau kesalahan fatal di kemudian hari.

APL + WIN, 27 byte

Meminta input L lalu n.

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

Cobalah online! Atas perkenan Dyalog Classic

Japt , 16 byte

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

Cobalah

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

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

Cobalah online!

Terima kasih kepada @JonathanAllan karena telah menghemat satu byte!

Link diad mengambil daftar nilai $L$ sebagai argumen kiri dan nomor $n$ sebagai benar.

Penjelasan

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

Cobalah online!

Saya pikir ada byte saya bisa bermain golf jika saya mendapatkan tumpukan yang tepat.

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

Tidak suka dengan tampilannya; harap saya hanya melewatkan beberapa golf yang jelas.

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

Cobalah online!

Saya mencoba mendapatkan awalan dan akhiran menggunakan splitAtdan pencocokan pola dalam penjaga, tetapi ternyata menjadi 3 byte lebih. Berencana mencoba mengkonversi ke fungsi rekursif dengan penjaga nanti untuk melihat apakah itu menurunkan jumlah byte.

Penjelasan

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

Apa yang saya sebut sebagai "awalan" adalah nelemen pertama dan "akhiran" adalah sisa dari daftar.

APL (Dyalog Unicode) , 23 21 byte ^SBCS

Lambda awalan anonim, mengambil $n$ sebagai argumen kiri dan $L$ sebagai argumen yang benar.

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

Cobalah online!

{... } "dfn";$n$adalah ⍺(huruf Yunani paling kiri) dan$L$adalah ⍵(huruf Yunani paling kanan):

 ⌽⍵ membalikkan $L$

 +\ jumlah awalan itu

 (... )< Topeng Boolean di mana kurang dari:

  ⍺↑⍵ ambil yang pertama $n$ elemen dari $L$

  +/ jumlahkan itu

 ⊥⍨ hitung kebenaran yang tertinggal

 ⍺⌈ maksimum $n$ dan itu

 ⍵↓⍨ menjatuhkan banyak elemen dari depan $L$

MATL , 13 12 byte

1 byte disimpan berkat @Giuseppe , berdasarkan jawaban oleh @MickyT .

:&)PtYsbs>~)

Output dalam urutan menaik.

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Pertimbangkan input 2dan [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]

Cobalah online!

Mengambil daftar dalam urutan menaik, output menurun (karena lebih mudah dibandingkan dengan kasus uji: ^))

Telusuri daftar mundur ke depan, membandingkan akumulator dengan nentri terakhir yang ditambahkan bersama-sama (dengan menempelkannya bersama+ s dan meneruskan string yang dihasilkan keinvoke-expression ). Loop Hingga membutuhkan logika tambahan untuk menangani masuk ke Lingkungan Kaya karena itu tidak akan berhenti jika kita masih tidak lebih kaya daripada Orang Kaya sampai kita mengaduk seluruh daftar.

Belum dibuka:

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

Cobalah online! Tautan hanya mencakup beberapa kasus uji; Saya bisa membuatnya bekerja dalam beberapa kasus dengan angka negatif dengan biaya 12 byte (khususnya nentri pertama Lmasih perlu positif; secara teoritis saya mungkin hanya membutuhkan jumlah nentri pertama menjadi positif). Penjelasan:

\d+
$*

Konversikan ke unary.

^
;,

Masukkan penanda di awal L.

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

Pindahkan ke bawah daftar nkali, menjumlahkan saat kita pergi. Ini menghapus ntetapi koma tetap.

,
;$'¶$`,

Buat entri untuk setiap sufiks L.

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

Ganti bagian tengah dengan salinan akhiran.

T`,`_`.*;

Jumlahkan salinan akhiran.

1G`(1+);\1;

Ambil entri pertama di mana jumlah akhiran tidak melebihi jumlah awalan.

.*;

Hapus jumlahnya.

(1*),
$.1,

Konversikan ke desimal.

.,$

Hapus koma jejak yang datang sebelumnya n.

Arang , 17 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

  θ                 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

Merah , 63 byte

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

Cobalah online!

PowerShell , 86 byte

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

Cobalah online!

Belum dibuka:

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

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

Cobalah online!

Penjelasan

Mengambil input sebagai 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

Alasan mengapa ini berhasil adalah pada langkah pertama, kami sebenarnya membagi daftar menjadi dua bagian yang tumpang tindih. Sebagai contoh, L = [4, 3, 2, 1], n = 2akan membagi daftar sebagai [3, 2, 1]dan [4, 3]. Alasan untuk memiliki elemen tambahan dalam daftar pertama adalah bahwa dalam loop, hal pertama yang terjadi adalah membuang. Jika elemen tambahan tidak ditambahkan, kasus-kasus di mana output harus seluruh sisa daftar akan gagal.

Bahasa Wolfram (Mathematica) , 40 byte

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

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

Sayangnya sepertinya tidak ada idiom yang lebih pendek untuk jumlah total suatu urutan.

Sunting : Oh ketika menambahkan contoh ke Coba online! tautan Saya perhatikan bahwa jawaban awal memberikan hasil yang salah ketika banyak angka negatif ada

The doseqpenggunaan "kunci" destrukturisasi jadi harus agak jelas mana data ujungnya sampai di mana simbol. #(...)adalah fungsi anonim, di sini saya mengikatnya ke simbol 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)))

Keluaran:

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

APL (NARS), 32 karakter, 64 byte

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

tes dan komentar:

  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

Saya melaporkan panjang byte yang salah ...

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

Saya tahu bahwa menggunakan tabel yang lebih mirip relasi untuk menyimpan data input dapat membuat kode lebih ringkas, tetapi menggunakan tipe data karakter untuk menyimpan daftar angka dan STRING_SPLITfungsinya, saya mendapatkan Build Schemabagian yang lebih pendek :)

Versi yang lebih mudah dibaca:

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

Cobalah di SQL Fiddle !

Python 3.8 (pra-rilis) , 59 byte

Output dalam urutan menaik

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

Cobalah online!