Giới thiệu:

Vài ngày trước tôi đã đọc bài đăng này với cùng tiêu đề khi tôi bắt gặp nó trong HNQ. Trong câu hỏi này, nó đang được thảo luận nếu tuyên bố của ứng cử viên tổng thống Bernie Sanders, người đã tuyên bố như sau:

Ngày nay, 26 tỷ phú giàu nhất thế giới, 26 tuổi, hiện đang sở hữu nhiều tài sản như 3,8 tỷ người nghèo nhất hành tinh, một nửa dân số thế giới.
^{Liên kết với video}

có đúng hay không. Hãy đi đến câu hỏi cho câu trả lời và thảo luận ở đó.

Đối với thử thách thực tế dựa trên yêu cầu này:

Thử thách:

Hai đầu vào: một danh sách số được sắp xếp giảm dần $L$ và một số $n$ (trong đó $n$ là $1\leq n\lt \text{length of }L$ ).
Output: dài nhất có thể hậu tố danh sách phụ của $L$ mà tổng số tiền là tổng các đầu tiên giá trị trong danh sách .$\leq$$n$$L$

Thí dụ:

Đầu vào: = và . Đầu ra:$L$[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]$n=2$
[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

Tại sao?

Giá trị $n=2$ đầu tiên của danh sách $L$ ( [500,200]) tính tổng 700. Nếu chúng ta lấy tất cả các hậu tố của các số còn lại, cũng như tổng của chúng:

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

Các hậu tố dài nhất trong đó có một số tiền thấp hơn hoặc bằng với 700là [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]với một khoản 643, vì vậy đó là kết quả của chúng tôi.

Quy tắc thử thách:

• Các giá trị trong tiền tố $n$ đầu tiên không được tính vào hậu tố đầu ra. Tức là đầu vào $L$ = [10,5,5,3]và $n=2$ sẽ dẫn đến [5,3], và không [5,5,3].
• I / O là linh hoạt. Bạn có thể nhập $L$ dưới dạng danh sách / luồng / mảng số nguyên / số thập phân / chuỗi, một chuỗi được phân tách đơn lẻ, từng chuỗi một qua STDIN, v.v. Bạn cũng có thể xuất dưới dạng danh sách / luồng / mảng số nguyên / số thập phân / chuỗi, in / trả về một chuỗi phân tách, in một số trên mỗi dòng mới, vv Cuộc gọi của bạn.
• Đầu ra được đảm bảo không trống. Vì vậy, bạn sẽ không phải đối phó với các trường hợp thử nghiệm như $L$ = [-5,-10,-13]và $n=2$ dẫn đến [].
• Cả (hoặc một trong hai) đầu vào và / hoặc đầu ra cũng có thể theo thứ tự tăng dần thay vì thứ tự giảm dần nếu bạn chọn.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ: TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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 # (Trình biên dịch tương tác Visual C #) , 88 81 69 68 63 byte

-4 byte nhờ LiefdeWen

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

Hãy thử trực tuyến!

EXAPUNKS (2 EXA, 30 Hướng dẫn, tệp giải pháp 594 byte)

Tôi đã muốn thử một thử thách golf mã trong EXAPUNKS một thời gian và bạn trông giống như người phù hợp nhất tôi có thể tìm thấy, vì vậy, xin chúc mừng!

Nhập qua tệp 200 và 201, tương ứng cho L và n. Đầu ra thông qua một tập tin mới. L và đầu ra theo thứ tự tăng dần.

Về cơ bản, XA tính tổng n giá trị cuối cùng trong L, sau đó gửi nó đến XB. Sau đó, nó tìm đến điểm bắt đầu của L và gửi từng giá trị từng cái một cho XB. Đầu tiên XB nhận tổng số từ XA và lưu nó vào thanh ghi X. Sau đó, nó nhận từng giá trị từ XA, trừ giá trị mới từ X và ghi các giá trị đó vào tệp đầu ra cho đến khi 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 cho cấp độ ở đây

Python 2 , 60 byte

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

Hãy thử trực tuyến!

Giải trình:

Đầu tiên lấy tổng của các nmục đầu tiên .

Sau đó, tổng của mỗi danh sách con được so sánh với tổng này. Ngay khi một cái không lớn hơn, chúng tôi dừng lại.

Sau đó, danh sách con kết quả (dài nhất) được in.

05AB1E , 14 12 byte

Đã lưu 2 byte nhờ Grimy

.$ΔDOI¹£O›.$

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Giải trình:

Một động từ dyadic, lấy nlàm đối số bên trái của nó và L- làm đối số bên phải của nó.

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

$n$

-4 byte bằng cách đọc thông số kỹ hơn.

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

Hãy thử trực tuyến!

R , 53 55 byte

@Giuseppe đã lưu cho tôi 2 byte thay đổi cách xóa đã được thực hiện

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

Hãy thử trực tuyến! Đưa đầu vào giảm dần và đầu ra tăng dần theo sự cho phép của quy tắc 4.

• Ylà rev của Lvới 1: n được loại bỏ bằng cách sử dụng0:-n
• trả về từ Ynơi tổng tích lũy nhỏ hơn bằng tổng củaL[X]

JavaScript (ES6), 66 byte

Đưa đầu vào như (a)(n)với danh sách theo thứ tự tăng dần.

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

Hãy thử trực tuyến!

Đã bình luận

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

Cũng tương thích với Python 3

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

Hãy thử trực tuyến!

Giải trình

Tổng của hậu tố được so sánh với một nửa tổng của toàn bộ danh sách. Nếu tổng của hậu tố nhỏ hơn hoặc bằng nhau, hậu tố được trả về. Nếu không, hàm được gọi đệ quy với mục đầu tiên của hậu tố bật ra.

Bình thường , 16 15 byte

efgs>vzQsT._<vz

Hãy thử trực tuyến!

Danh sách đầu vào dự kiến ​​sẽ được sắp xếp theo thứ tự tăng dần, thay vì giảm dần như được sử dụng trong các ví dụ.

Vào những thời điểm như thế này khi tôi thực sự muốn Pyth có một toán tử mã thông báo duy nhất truy cập vào đầu vào thứ hai nhiều lần ( Eđánh giá dòng đầu vào tiếp theo, nhưng các cuộc gọi lặp lại sẽ loại bỏ giá trị đã đọc trước đó).

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

Chỉnh sửa: đã lưu 1 byte nhờ 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

Hãy thử trực tuyến!

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

Chạy và gỡ lỗi nó tại staxlang.xyz!

Phiên bản Nicer

Giải nén (14 byte) và giải thích:

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

Bằng sự đồng thuận , tôi có thể để kết quả này trên ngăn xếp. Stax sẽ thử một bản in ngầm, có thể thất bại, nhưng việc thêm một mchương trình giải nén cho phép bạn thấy đầu ra độc đáo.

Hình như { ... }jlà giống như { ... fh. Huh. Chỉnh sửa: Đó không phải là trường hợp; điều duy nhất trước đây sẽ dừng lại khi nó nhận được một kết quả trung thực, có thể tránh các tác dụng phụ hoặc một lỗi nghiêm trọng về sau.

APL + THẮNG, 27 byte

Nhắc nhở đầu vào của L thì n.

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Japt , 16 byte

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

Thử nó

£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

Thạch , 13 12 byte

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

Hãy thử trực tuyến!

Cảm ơn @Jonathan ALLan vì đã tiết kiệm một byte!

$L$$n$

Giải trình

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

Hãy thử trực tuyến!

Tôi nghĩ rằng có một byte tôi có thể chơi golf nếu tôi có được ngăn xếp vừa phải.

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

Không hài lòng với cách nhìn này; hy vọng tôi chỉ thiếu một số golf rõ ràng.

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

Hãy thử trực tuyến!

Tôi đã thử lấy tiền tố và hậu tố bằng cách sử dụng splitAt và khớp mẫu trong một bộ bảo vệ, nhưng hóa ra là thêm 3 byte. Kế hoạch cố gắng chuyển đổi thành một hàm đệ quy với các bộ bảo vệ sau để xem liệu điều đó có làm giảm số lượng byte không.

Giải trình

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

Những gì tôi gọi là "tiền tố" là các nyếu tố đầu tiên và "hậu tố" là phần còn lại của danh sách.

APL (Dyalog Unicode) , 23 21 byte ^SBCS

$n$$L$

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

Hãy thử trực tuyến!

{}$n$⍺$L$⍵

 ⌽⍵$L$

 +\ tiền tố của đó

 (... )< mặt nạ Boolean nơi ít hơn:

  ⍺↑⍵$n$$L$

  +/ tổng hợp những

 ⊥⍨ đếm sự thật

 ⍺⌈$n$

 ⍵↓⍨$L$

MATL , 13 12 byte

Lưu 1 byte nhờ @Giuseppe , dựa trên câu trả lời của @MickyT .

:&)PtYsbs>~)

Đầu ra theo thứ tự tăng dần.

Hãy thử trực tuyến! Hoặc là xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào 2và [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]

Hãy thử trực tuyến!

Đưa danh sách theo thứ tự tăng dần, đầu ra giảm dần (vì dễ so sánh với các trường hợp kiểm tra: ^))

Đi qua danh sách về phía trước về phía trước, so sánh bộ tích lũy với các nmục cuối cùng được thêm vào với nhau (thông qua việc dán chúng cùng với+ s và chuyển chuỗi kết quả đếninvoke-expression ). Vòng lặp Until cần logic bổ sung để xử lý việc đi vào Vùng lân cận giàu vì nó sẽ không dừng nếu chúng ta vẫn không giàu hơn Người giàu cho đến khi chúng ta lướt qua toàn bộ danh sách.

Chưa được kiểm soát:

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]

Võng mạc 0.8.2 , 99 byte

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

(1*),
$.1,
,$

Hãy thử trực tuyến! Liên kết chỉ bao gồm một số trường hợp thử nghiệm; Tôi có thể làm cho nó hoạt động trong một số trường hợp có số âm với chi phí 12 byte (đặc biệt là các nmục đầu tiên Lvẫn cần phải tích cực; về mặt lý thuyết tôi có thể chỉ yêu cầu tổng các nmục đầu tiên là dương). Giải trình:

\d+
$*

Chuyển đổi sang unary.

^
;,

Chèn một điểm đánh dấu ở đầu L.

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

Di chuyển nó xuống danh sách nlần, tổng hợp khi chúng ta đi. Điều này xóa nnhưng dấu phẩy của nó vẫn còn.

,
;$'¶$`,

Tạo một mục nhập cho mỗi hậu tố của L.

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

Thay thế giữa bằng một bản sao của hậu tố.

T`,`_`.*;

Tính tổng các bản sao của hậu tố.

1G`(1+);\1;

Lấy mục đầu tiên trong đó tổng hậu tố không vượt quá tổng tiền tố.

.*;

Xóa các khoản tiền.

(1*),
$.1,

Chuyển đổi thành số thập phân.

.,$

Xóa dấu phẩy xuất hiện trước đó n.

Than , 17 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  θ                 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

Màu đỏ , 63 byte

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

Hãy thử trực tuyến!

PowerShell , 86 byte

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

Hãy thử trực tuyến!

Chưa được kiểm soát:

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

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

Hãy thử trực tuyến!

Giải trình

Đưa đầu vào là 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

Lý do tại sao điều này hoạt động là trong bước đầu tiên, chúng tôi thực sự chia danh sách thành hai phần chồng chéo. Ví dụ, L = [4, 3, 2, 1], n = 2sẽ chia ra danh sách như [3, 2, 1]và [4, 3]. Lý do để có một yếu tố phụ trong danh sách đầu tiên là trong vòng lặp, điều đầu tiên xảy ra là loại bỏ. Nếu một yếu tố bổ sung không được chuẩn bị trước, các trường hợp đầu ra sẽ là toàn bộ phần còn lại của danh sách sẽ thất bại.

Ngôn ngữ Wolfram (Mathicala) , 40 byte

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

Hãy thử trực tuyến!

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

Đáng buồn thay, dường như không có một thành ngữ ngắn hơn cho tổng số của một chuỗi.

Chỉnh sửa : Oh khi thêm ví dụ vào Dùng thử trực tuyến!Tôi nhận thấy rằng câu trả lời ban đầu cho kết quả sai khi có nhiều số âm.

Việc doseqsử dụng "khóa" phá hủy để có thể rõ ràng phần nào dữ liệu kết thúc trong biểu tượng nào. #(...)là một hàm ẩn danh, ở đây tôi ràng buộc nó với biểu tượng 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)))

Đầu ra:

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

APL (NARS), 32 ký tự, 64 byte

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

kiểm tra và bình luận:

  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

Tôi đã báo cáo sai độ dài byte ...

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

Tôi biết rằng sử dụng bảng giống như quan hệ hơn để lưu trữ dữ liệu đầu vào có thể làm cho mã ngắn gọn hơn, nhưng sử dụng kiểu dữ liệu ký tự để lưu danh sách số và STRING_SPLIThàm, tôi sẽ rút ngắn Build Schemaphần :)

Phiên bản dễ đọc hơn:

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

Hãy thử nó trên SQL Fiddle !

Python 3.8 (tiền phát hành) , 59 byte

Đầu ra theo thứ tự tăng dần

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

Hãy thử trực tuyến!