Apakah 26 miliarder terkaya memiliki kekayaan sebanyak 3,8 miliar orang termiskin?

37

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 1n<length of L ).
Output: mungkin akhiran sub-daftar terpanjang L yang jumlah total adalah 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 , 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]
Kevin Cruijssen
sumber
Bisakah saya menulis jawaban yang hanya berfungsi dengan bilangan bulat positif (atau mungkin tidak negatif; saya belum menulisnya) karena kurangnya jenis bilangan bulat dalam bahasa?
Neil
3
@Neil Saya berasumsi Anda sedang berbicara tentang Retina di sini? Tapi tentu saja, Anda dapat mengasumsikan semua nilai non-negatif dalam kasus itu. Meskipun demikian, apakah Anda yang terbaik juga memiliki versi kedua yang berfungsi untuk nilai negatif, karena saya punya perasaan yang mungkin sebenarnya dapat dicapai (dengan peningkatan yang sangat besar dalam byte-count dan beberapa work-arounds); yang lebih merupakan perasaan umum daripada fakta aktual, tidak yakin apakah memang mungkin untuk bekerja di sekitar bagian nilai negatif).
Kevin Cruijssen
6
Kasus tes yang sebenarnya akan terlihat seperti itu [131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]:: hal
Arnauld
2
Bagaimana dengan skenario di mana tidak ada nilai yang memenuhi kriteria: [1,2,3] n = 1? Apa yang Anda inginkan untuk hasil?
ouflak
@ouflak Lihat aturan tantangan ketiga: " Outputnya dijamin tidak kosong. Jadi Anda tidak perlu berurusan dengan kasus uji seperti L = [-5,-10,-13]dan n=2menghasilkan[] . " Juga, daftar input dijamin akan diurutkan menurun (atau naik jika Anda memilih untuk), jadi [1,2,3]bukan daftar input yang valid untuk memulai (kecuali jika Anda memilih input naik, dalam hal [1,2]ini hasilnya).
Kevin Cruijssen

Jawaban:

17

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!

Data Kedaluwarsa
sumber
Aku berpikir Anda bisa mencukur habis dua lagi dengan menghilangkan +bdalam Skippanggilan; itu berlebihan untuk memeriksa ndaftar pertama , tapi saya pikir itu masih benar.
TheRubberDuck
3
@TheRubberDuck tidak, harus menambahkannya untuk kasus di mana awalan dan akhiran tumpang tindih. Yaitu [10,5,5,3], n = 2
Data Kedaluwarsa
64 bytes
LiefdeWen
@LiefdeKetika bagus! sebenarnya kurang juga jika kita menggunakan fungsi kari
Data Kedaluwarsa
@ExpiredData Oh yeah, lupa saya menghapusnya.
LiefdeWen
12

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

ymbirtt
sumber
IIRC tidak exapunks punya cara untuk menyimpan solusi? Jika demikian, Anda harus menggunakan jumlah byte daripada dalam instruksi game.
Wheat Wizard
1
@ SriotchilismO'Zaic, ya, saya tidak berpikir file seharusnya mudah diakses, tapi saya baru saja menemukannya. Saya akan menambahkan ukuran pada disk. Sekelompok metadata yang tidak saya tulis akan disimpan di sampingnya, tapi saya kira ini adalah cara terbaik untuk benar-benar mendapatkan satu "byte byte" dari game ini.
ymbirtt
Saya ingin meluangkan waktu untuk melihat file-file ini dan melihat apakah ada cara untuk mengurutkan golf metadata ke bawah. Saya juga bertanya-tanya apakah beberapa instruksi membutuhkan lebih banyak memori daripada yang lain.
Wheat Wizard
@ SriotchilismO'Zaic, mereka benar-benar melakukannya. Semua instruksi disimpan sebagai plaintext, jadi untuk permulaan kita dapat mengubah semua tanda menjadi pengidentifikasi satu huruf. Nama solusi Anda ada di sana, sehingga kami dapat menghapus beberapa byte dengan memanggil solusi 'a'. Beberapa bagian darinya juga tampaknya terkait dengan jaringan virtual yang Anda buat untuk EXA. Jujur, saya pikir cara "paling adil" untuk mencetak solusi EXAPUNKS adalah dengan menggunakan jumlah byte kode aktual, atau jumlah instruksi. Ini mungkin layak untuk sebuah meta post ...
ymbirtt
2
@ymbirtt Saya kira pertanyaannya kemudian turun ke bisakah Anda menulis juru bahasa yang akan melihat petunjuk dan mengubahnya menjadi data yang disimpan? Yah sepele ya, hanya menulis sebuah program yang input untuk Anda dari sumber .. itu akan dihitung sebagai bahasa yang berbeda.
Data Kedaluwarsa
11

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.

TFeld
sumber
2
sebenarnya yang paling mudah dibaca +1
Kryštof Řeháček
10

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
Emigna
sumber
2
'Persis' sama dengan apa yang telah saya siapkan sebagai solusi. Dan 'tepatnya' yang saya maksud adalah milik saya .$.sʒO²¹£O>‹}θ. :)
Kevin Cruijssen
2
@KevinCruijssen di sini 12
Grimmy
1
Hanya ASCII 12 (menggunakan metode input yang berbeda).
Grimmy
1
@ Grimy: Hah. Saya tidak pernah tahu |menimpa last-input, menarik.
Emigna
2
@ Grimy: Lihat ini vs ini . Biasanya ketika semua input dikonsumsi, input terakhir secara implisit digunakan untuk semua instance input berikutnya. Menggunakan di |sini menjadikan hasil |menjadi input terakhir dan bukan apa yang sebenarnya merupakan input terakhir.
Emigna
7

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

Ruby , 47 43 byte

Mengambil daftar naik sebagai masukan. Menghapusn 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!

Nilai Tinta
sumber
7

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]
MickyT
sumber
@Giuseppe seperti biasa terima kasih. Mencoba menghapus Xmenggunakan -(1:n)tetapi tentu saja itu ukuran yang sama, jadi biarkan
MickyT
6

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
Arnauld
sumber
1
@KevinCruijssen Sepertinya saya salah membaca persyaratan. Harus diperbaiki sekarang.
Arnauld
Dan tidak seperti beberapa jawaban lain yang telah memperbaiki masalah yang sama, tanpa peningkatan byte-count. :) (Dan sebagian buruk saya, seharusnya sudah termasuk test case untukuntuk mulai dengan ..)
Kevin Cruijssen
5

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.

Jitse
sumber
4

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

Sok
sumber
@ Mr.Xcoder Kesedihan yang baik, sungguh simpanan yang jelas! Terima kasih 👍
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

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

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.

Khuldraeseth na'Barya
sumber
3

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
Shaggy
sumber
3

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)
Nick Kennedy
sumber
Anda dapat menyimpan byte dengan menyortir alih-alih memfilter:ṫḊÐƤS>¥ÞḣS¥Ḣ
Jonathan Allan
3

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

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.

cole
sumber
3

APL (Dyalog Unicode) , 23 21 byte SBCS

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

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

Cobalah online!

{... } "dfn";nadalah (huruf Yunani paling kiri) danL.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.

Adm
sumber
1
@KevinCruijssen Terlihat bagus. Tetap.
Adám
3

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

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

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.

Neil
sumber
Jawaban bagus. :) Bisakah Anda menambahkan tautan TIO ke versi yang 12 byte lebih panjang berisi angka negatif. Dan np itu tidak berfungsi saat yang pertamanjumlah dijumlahkan ke nilai negatif. Selama itu bekerja dengan bilangan bulat positif itu masih baik-baik saja. Sudah selesai dilakukan dengan baik.
Kevin Cruijssen
1
@KevinCruijssen Versi angka negatif saya ternyata sangat lambat, tapi saya berhasil memperbaikinya dengan menggunakan ropsi, jadi saya sekarang menghubungkannya dengan beberapa kasus uji.
Neil
2

Arang , 17 byte

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

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

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

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.

maks
sumber
2

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

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)
NikoNyrh
sumber
1
Maukah Anda menambahkan TIO dengan kode uji (saya melihat Clojure dalam daftar)? Jika tidak memungkinkan, entah bagaimana (versi ketidakcocokan, atau menggunakan bawaan yang tidak tersedia di TIO), dapatkah Anda menyertakan tangkapan layar dengan beberapa kasus uji sebagai verifikasi yang berfungsi?
Kevin Cruijssen
1

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

RosLuP
sumber
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

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 !

Andrei Odegov
sumber