Giriş:

Birkaç gün önce , HNQ'da karşılaştığımda bu yazıyı aynı başlıkla okudum. Bu soruda, başkan adayı Bernie Sanders'in iddiasının aşağıdakileri iddia ettiği iddia ediliyor:

Bugün dünyanın en zengin 26 milyarderinden 26'ı, şimdi dünya nüfusunun yarısı, dünyadaki en fakir 3,8 milyar insan kadar servet sahibi.
^{Videoya bağlantı}

doğru ya da değil. Lütfen orada cevaplar ve tartışmalar için sorunun kendisine gidin.

Bu talebe dayanarak gerçekleşen zorluklara gelince:

Meydan okuma:

İki giriş: azalan sıralanmış bir numara listesi $L$ ve bir sayı $n$ (burada $n$ , $1\leq n\lt \text{length of }L$ ).
Çıktı: Toplam toplam ≤ L listesindeki ilk n değerlerinin toplamı olan $L$ mümkün olan en uzun soneki alt listesi .$\leq$$n$$L$

Örnek:

Girişler: $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]ve $n=2$ .
Çıktı:[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

Niye ya?

L ( ) listesinin ilk $n=2$ değeri toplanır . Kalan sayıların tüm eklerini ve bunların toplamlarını alırsak:$L$[500,200]700

Suffix:                                                                  Sum:

[-3]                                                                     -3
[-2,-3]                                                                  -5
[0,-2,-3]                                                                -5
[1,0,-2,-3]                                                              -4
[2,1,0,-2,-3]                                                            -2
[2,2,1,0,-2,-3]                                                          0
[3,2,2,1,0,-2,-3]                                                        3
[5,3,2,2,1,0,-2,-3]                                                      8
[5,5,3,2,2,1,0,-2,-3]                                                    13
[5,5,5,3,2,2,1,0,-2,-3]                                                  18
[5,5,5,5,3,2,2,1,0,-2,-3]                                                23
[10,5,5,5,5,3,2,2,1,0,-2,-3]                                             33
[10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                          43
[20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                       63
[30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                    93
[30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                 123
[40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                              163
[50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                           213
[55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                        268
[75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                     343
[75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                  418
[100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]              518
[125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]          643
[150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]      793
[150,150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]  943

Bir miktar daha düşük ya da eşit olan en uzun eki 700olan [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]bir miktar ile 643bu sonuç olan, bu yüzden.

Meydan okuma kuralları:

• İlk $n$ öneki değerler çıkış-sonekine sayılmaz. Yani $L$ = [10,5,5,3]ve $n=2$ girişleri sonuçlanır [5,3]ve sonuçlanmaz [5,5,3].
• G / Ç esnektir. Sen girdi can $L$ vb STDIN'den aracılığıyla birer tamsayı / ondalık / dizeleri, tek sınırlandırılmış dize, tek bir liste / dere / dizi olarak yapabilirsiniz tamsayılar / ondalık / dizeleri bir liste / dere / dizi olarak çıktı hem de ayrılmış bir dize yazdırın / iade edin, her yeni satırda bir sayı yazdırın, vb.
• Çıkışın boş olmadığı garantilidir. Eğer böyle test durumları ile uğraşmak zorunda olmayacak Yani $L$ = [-5,-10,-13]ve $n=2$ ile sonuçlanan [].
• Hem (veya her ikisi de) hem girdi hem de çıktı, eğer isterseniz, azalan düzen yerine artan sırada olabilir.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

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 # Etkileşimli Derleyici) , 88 81 69 68 63 bayt

LiefdeWen sayesinde -4 bayt

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

Çevrimiçi deneyin!

EXAPUNKS (2 EXA, 30 Talimat, 594 bayt çözüm dosyası)

Bir süredir EXAPUNKS'te bir kod golf mücadelesini denemek istedim, ve bulabileceğim en iyi şey gibi görünüyordum, tebrikler!

Sırasıyla L ve n için dosyalar 200 ve 201 ile giriş yapın. Yeni bir dosya üzerinden çıktı. L ve çıkış artan sıradadır.

Temel olarak, XA, L'deki son n değerlerini toplar, ardından XB'ye gönderir. Daha sonra L'nin başlangıcına bakar ve her bir değeri birer birer XB'ye gönderir. XB ilk önce toplamı XA'dan alır ve X kaydında saklar. Daha sonra değerleri XA'dan birer birer alır, yeni değeri X'den düşer ve bu değerleri X <0 olana kadar çıktı dosyasına yazar.

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

Buradaki seviye için JavaScript

Python 2,60 bayt

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

Çevrimiçi deneyin!

Açıklama:

İlk önce ilk nöğelerin toplamını alır .

Daha sonra her bir alt listenin toplamı bu toplamla karşılaştırılır. Biri daha büyük olmazsa dururuz.

Sonra sonuçta (en uzun) alt liste yazdırılır.

05AB1E , 14 12 bayt

Grimy sayesinde 2 bayt kaydedildi

.$ΔDOI¹£O›.$

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Açıklama:

nSol argümanı ve L- sağ argümanı olarak kabul eden bir ikili fiil .

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

$n$

-4 daha fazla okuyarak spec bayt.

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

Çevrimiçi deneyin!

R , 53 55 bayt

@Giuseppe bana 2 bayt kurtardı kaldırmanın yapılma şeklini değiştirdi

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

Çevrimiçi deneyin! Girdiyi azalan olarak alır ve kural 4 tarafından izin verildiği şekilde yukarı çıkar.

• Y'nin revizyonu L1: n kullanılarak kaldırıldı0:-n
• adlı döner Ybirikimli toplam daha az olduğu toplamına eşitL[X]

JavaScript (ES6), 66 bayt

(a)(n)Listedeki gibi artan sırada girdi alır .

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

Python 3 ile de uyumlu

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

Çevrimiçi deneyin!

açıklama

Son ekin toplamı, tüm listenin toplamının yarısı ile karşılaştırılır. Son ekin toplamı daha küçük veya eşitse, son ek döndürülür. Aksi halde, fonksiyon tekrarlanan olarak ekin ilk öğesi çıkarılmış olarak çağrılır.

Pyth , 16 15 bayt

efgs>vzQsT._<vz

Çevrimiçi deneyin!

Giriş listesinin, örneklerde kullanıldığı gibi azalan yerine, artan düzende sıralanması beklenir.

Pyth'in ikinci girişe bir kereden fazla erişmesi için tek bir belirteçli operatör olmasını dilerdim (bir Esonraki giriş satırını değerlendirir, ancak tekrarlanan çağrılar önceki değeri okur.)

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

Düzenleme: MrXcoder sayesinde 1 bayt kaydedildi

JavaScript, 64 bayt

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

Çevrimiçi deneyin!

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 bayt

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

Koşun ve staxlang.xyz de hata ayıklayın!

Güzel sürüm

Ambalajsız (14 bayt) ve açıklama:

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

By uzlaşma , ben yığın bu sonucu bırakabilir. Stax, başarısız olabilecek örtük bir yazdırma girişiminde bulunur, ancak mpaketten çıkarılan programa bir ekleme yapmak çıktıyı güzel bir şekilde görmenizi sağlar.

Görünüşe göre { ... }jaynı { ... fh. Huh. Düzenleme: Durum böyle değil; sadece birincisi, bir truthy sonuç aldığında duracak, daha sonra muhtemelen yan etkilerden veya ölümcül bir hatadan kaçınacak.

APL + WIN, 27 bayt

L girişini sonra n istemi ister.

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

Çevrimiçi deneyin! Dyalog Classic'in İzniyle

Japt , 16 bayt

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

Dene

£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

Jöle , 13 12 bayt

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

Çevrimiçi deneyin!

Bayt tasarrufu için @JonathanAllan teşekkürler!

$L$$n$

açıklama

ṫ            | 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 bayt

eSe¤Σ¤┅⟪Σ⊃⟫∇

Çevrimiçi deneyin!

Yığını tam alırsam golf oynayabileceğim bir bayt var.

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 bayt

Bunun nasıl göründüğünden memnun değil; Umarım sadece bariz golfleri özlüyorumdur.

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

Çevrimiçi deneyin!

splitAtBir muhafazada önek ve sonek kullanarak ve desen eşleştirmeyi almaya çalıştım , ancak 3 bayt daha fazla olduğu ortaya çıktı. Bayt sayısını azaltıp azaltmadığını görmek için daha sonra gardiyanlarla özyinelemeli bir işleve dönüştürmeye çalışmayı planlayın.

açıklama

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

"Önek" dediğim şey ilk nelemanlar ve "sonek" listenin geri kalanı.

APL (Dyalog Unicode) , 23 21 bayt ^SBCS

$n$$L$

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

Çevrimiçi deneyin!

{}$n$⍺$L$⍵

 ⌽⍵$L$

 +\ önek toplamları

 (… )< Boolean maskenin az olduğu yerler:

  ⍺↑⍵$n$$L$

  +/ topla

 ⊥⍨ sondaki gerçekleri say

 ⍺⌈  en fazla$n$

 ⍵↓⍨  önündeki birçok öğeyi bırak$L$

Matl , 13 12 bayt

1 bayt sayesinde kaydedilen @Giuseppe tarafından yanıta göre, @MickyT .

:&)PtYsbs>~)

Çıktı artan düzende.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Girdileri düşünün 2ve [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 bayt

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]

Çevrimiçi deneyin!

Yükselen sırayla liste alır, çıktı iner (çünkü test durumlarıyla karşılaştırmak daha kolaydı: ^))

Akümülatörü birlikte eklenen son girişlerle karşılaştırarak (ileriye doğru s ile yapıştırma ve elde edilen dizgiyi geçerek ) listede geriye doğru gider . Kadar Döngü, Zengin Mahalle'ye girebilmek için ek bir mantığa ihtiyaç duyuyordu, çünkü tüm listeyi çalkalamadıkça Zengin Adamlardan daha zengin olmasak durmazdı.n+invoke-expression

unrolled:

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 bayt

\d+
$*
^
;,
+`;,(1+)(,.*)1$
$1;$2
,
;$'¶$`,
;.*(;.*)
$1$1
T`,`_`.*;
1G`(1+);\1;
.*;

(1*),
$.1,
,$

Çevrimiçi deneyin! Bağlantı sadece bazı test durumlarını içerir; Ben bunu alabilir negatif sayılar ile bazı durumlarda işe (özellikle ilk 12 byte bir maliyetle ngirişler L; teorik olarak muhtemelen sadece ilk toplamını gerektirebilir hala pozitif olması gerekir npozitif olmak girdileri). Açıklama:

\d+
$*

Birliğe dönüştür.

^
;,

Başına bir işaretleyici yerleştirin L.

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

Listede aşağı doğru nilerle, gittiğimiz gibi toplayın. Bu siler nancak virgül kalır.

,
;$'¶$`,

Her eki için bir giriş oluşturun L.

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

Orta eki bir kopyasıyla değiştirin.

T`,`_`.*;

Sonekin kopyasını toplayın.

1G`(1+);\1;

Sonek toplamının önek toplamını geçmediği ilk girişi yapın.

.*;

Toplamları silin.

(1*),
$.1,

Ondalık dönüştür.

.,$

Daha önce gelen son virgül silin n.

Kömür , 17 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

  θ                 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

Kırmızı , 63 bayt

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

Çevrimiçi deneyin!

PowerShell , 86 bayt

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

Çevrimiçi deneyin!

unrolled:

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 bayt

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

Çevrimiçi deneyin!

açıklama

Girişi alır 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

Bunun işe yaramasının nedeni, ilk adımda, listeyi aslında birbiriyle örtüşen iki bölüme ayırmamızdır. Örnek olarak, L = [4, 3, 2, 1], n = 2listeyi [3, 2, 1]ve şeklinde böler [4, 3]. İlk listede fazladan bir elementin olmasının nedeni, döngüde gerçekleşen ilk şeyin bir atın olmasıdır. Fazladan bir eleman hazırlanmadıysa, çıktının listenin geri kalanının tamamı olduğu durumlar başarısız olur.

Wolfram Dili (Mathematica) , 40 bayt

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

Çevrimiçi deneyin!

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 bayt

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

Ne yazık ki, bir dizinin toplamı için daha kısa bir deyim yok gibi görünüyor.

Düzenleme : Ah çevrimiçi deneyin örnekleri eklerken ! bağlantı Çok sayıda negatif sayı bulunduğunda orijinal cevabın yanlış sonuçlar verdiğini fark ettim.

Kullanılan doseq"anahtarlar" tahrip edicidir, bu nedenle hangi verilerin hangi sembolde sona erdiği biraz açık olmalıdır. #(...)adsız bir işlevdir, işte bu simgeyi bağlarım 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)))

Çıktı:

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

APL (NARS), 32 karakter, 64 bayt

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

test ve yorumlar:

  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

Bayt uzunluğu yanlış bildirdim ...

MS SQL Server 2017 , 271 bayt

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

Giriş verilerini depolamak için daha fazla ilişkiye benzeyen bir tablo kullanmanın kodu daha özlü hale getirebileceğini biliyorum, ancak sayısal listeyi ve STRING_SPLITişlevi depolamak için karakter veri türünü kullanarak Build Schemaparçayı kısaldım :)

Daha okunaklı sürüm:

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

SQL Fiddle'da deneyin !

Python 3.8 (yayın öncesi) , 59 bayt

Çıktı artan sırada

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

Çevrimiçi deneyin!