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 dan angka (di mana adalah ).
Output: mungkin akhiran sub-daftar terpanjang yang jumlah total adalah jumlah pertama nilai-nilai dalam daftar .
Contoh:
Input: = [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 .
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 pertama dari daftar ( [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 700
adalah [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 pertama tidak dihitung ke akhiran-keluaran. Yaitu input =
[10,5,5,3]
dan akan menghasilkan[5,3]
, dan tidak[5,5,3]
. - I / O fleksibel. Anda dapat memasukkan 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 =
[-5,-10,-13]
dan 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]
[131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]
:: halL = [-5,-10,-13]
dann=2
menghasilkan[]
. " 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).Jawaban:
C # (Visual C # Interactive Compiler) ,
8881696863 byte-4 byte terima kasih kepada LiefdeWen
Cobalah online!
sumber
+b
dalamSkip
panggilan; itu berlebihan untuk memeriksan
daftar pertama , tapi saya pikir itu masih benar.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
XB
JavaScript untuk level di sini
sumber
Python 2 , 60 byte
Cobalah online!
Penjelasan:
Pertama mengambil jumlah
n
item pertama .Kemudian jumlah masing-masing sublist dibandingkan dengan jumlah ini. Begitu seseorang tidak lebih besar, kita berhenti.
Kemudian sublist yang dihasilkan (terpanjang) dicetak.
sumber
05AB1E ,
1412 byteDisimpan 2 byte berkat Grimy
Cobalah online!
Penjelasan
sumber
.$.sʒO²¹£O>‹}θ
. :)|
menimpalast-input
, menarik.|
sini menjadikan hasil|
menjadi input terakhir dan bukan apa yang sebenarnya merupakan input terakhir.J , 18 byte
Cobalah online!
Penjelasan:
Kata kerja diad, dengan
n
argumen kiri danL
- sebagai argumen kanan.sumber
Ruby ,
4743 byteMengambil 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.
Cobalah online!
sumber
R , 53
55byte@ Giuseppe menyelamatkan saya 2 byte mengubah cara menghapus dilakukan
Cobalah online! Mengambil input sebagai turun dan output naik seperti yang diizinkan oleh aturan 4.
Y
adalah revL
dengan 1: n dihapus menggunakan0:-n
Y
tempat jumlah kumulatif kurang dari sama dengan jumlahL[X]
sumber
X
menggunakan-(1:n)
tetapi tentu saja itu ukuran yang sama, jadi biarkanJavaScript (ES6), 66 byte
Mengambil input seperti
(a)(n)
daftar dalam urutan menaik.Cobalah online!
Berkomentar
sumber
Python 2 , 59 byte
Juga kompatibel dengan Python 3
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.
sumber
Pyth ,
1615 byteCobalah 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 (
E
mengevaluasi baris input berikutnya, tetapi panggilan berulang-ulang membuang nilai yang dibaca sebelumnya).Sunting: disimpan 1 byte berkat MrXcoder
sumber
JavaScript, 64 byte
Cobalah online!
sumber
Stax , 12 byte
Jalankan dan debug di staxlang.xyz!
Versi yang lebih bagus
Dibongkar (14 byte) dan penjelasan:
Dengan konsensus , saya dapat meninggalkan hasil ini di tumpukan. Stax akan mencoba cetakan implisit, yang mungkin gagal, tetapi menambahkan
m
ke program yang dibongkar memungkinkan Anda melihat hasilnya dengan baik.Sepertinya
{ ... }j
sama 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.sumber
APL + WIN, 27 byte
Meminta input L lalu n.
Cobalah online! Atas perkenan Dyalog Classic
sumber
Japt , 16 byte
Cobalah
sumber
Jelly ,
1312 byteCobalah online!
Terima kasih kepada @JonathanAllan karena telah menghemat satu byte!
Link diad mengambil daftar nilaiL. sebagai argumen kiri dan nomor n sebagai benar.
Penjelasan
sumber
ṫḊÐƤS>¥ÞḣS¥Ḣ
Gaia , 12 byte
Cobalah online!
Saya pikir ada byte saya bisa bermain golf jika saya mendapatkan tumpukan yang tepat.
sumber
Haskell , 46 byte
Tidak suka dengan tampilannya; harap saya hanya melewatkan beberapa golf yang jelas.
Cobalah online!
Saya mencoba mendapatkan awalan dan akhiran menggunakan
splitAt
dan 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
Apa yang saya sebut sebagai "awalan" adalah
n
elemen pertama dan "akhiran" adalah sisa dari daftar.sumber
APL (Dyalog Unicode) ,
2321 byte SBCSLambda awalan anonim, mengambiln sebagai argumen kiri dan L. sebagai argumen yang benar.
Cobalah online!
{
...}
"dfn";⍺
(huruf Yunani paling kiri) dan⍵
(huruf Yunani paling kanan):⌽⍵
membalikkan+\
jumlah awalan itu(
...)<
Topeng Boolean di mana kurang dari:⍺↑⍵
ambil yang pertama+/
jumlahkan itu⊥⍨
hitung kebenaran yang tertinggal⍺⌈
maksimum⍵↓⍨
menjatuhkan banyak elemen dari depansumber
MATL ,
1312 byte1 byte disimpan berkat @Giuseppe , berdasarkan jawaban oleh @MickyT .
Output dalam urutan menaik.
Cobalah online! Atau verifikasi semua kasus uji .
Penjelasan
Pertimbangkan input
2
dan[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]
.sumber
PowerShell ,
9997 byteCobalah online!
Mengambil daftar dalam urutan menaik, output menurun (karena lebih mudah dibandingkan dengan kasus uji: ^))
Telusuri daftar
mundurke depan, membandingkan akumulator dengann
entri 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:
sumber
Retina 0.8.2 , 99 byte
Cobalah online! Tautan hanya mencakup beberapa kasus uji; Saya bisa membuatnya bekerja dalam beberapa kasus dengan angka negatif dengan biaya 12 byte (khususnya
n
entri pertamaL
masih perlu positif; secara teoritis saya mungkin hanya membutuhkan jumlahn
entri pertama menjadi positif). Penjelasan:Konversikan ke unary.
Masukkan penanda di awal
L
.Pindahkan ke bawah daftar
n
kali, menjumlahkan saat kita pergi. Ini menghapusn
tetapi koma tetap.Buat entri untuk setiap sufiks
L
.Ganti bagian tengah dengan salinan akhiran.
Jumlahkan salinan akhiran.
Ambil entri pertama di mana jumlah akhiran tidak melebihi jumlah awalan.
Hapus jumlahnya.
Konversikan ke desimal.
Hapus koma jejak yang datang sebelumnya
n
.sumber
r
opsi, jadi saya sekarang menghubungkannya dengan beberapa kasus uji.Arang , 17 byte
Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:
sumber
Merah , 63 byte
Cobalah online!
sumber
PowerShell , 86 byte
Cobalah online!
Belum dibuka:
sumber
MathGolf , 13 byte
Cobalah online!
Penjelasan
Mengambil input sebagai
n L
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 = 2
akan 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.sumber
Bahasa Wolfram (Mathematica) , 40 byte
Cobalah online!
sumber
Clojure,
6675 byteSayangnya 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
doseq
penggunaan "kunci" destrukturisasi jadi harus agak jelas mana data ujungnya sampai di mana simbol.#(...)
adalah fungsi anonim, di sini saya mengikatnya ke simbolf
:Keluaran:
sumber
APL (NARS), 32 karakter, 64 byte
tes dan komentar:
Saya melaporkan panjang byte yang salah ...
sumber
MS SQL Server 2017 , 271 byte
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_SPLIT
fungsinya, saya mendapatkanBuild Schema
bagian yang lebih pendek :)Versi yang lebih mudah dibaca:
Cobalah di SQL Fiddle !
sumber
Python 3.8 (pra-rilis) , 59 byte
Output dalam urutan menaik
Cobalah online!
sumber