소개:

며칠 전 HNQ에서이 제목을 읽었을 때 같은 제목의이 게시물을 읽었습니다 . 이 질문에서 다음을 주장한 후보 후보 베르니 샌더스의 주장이 논의되고있다.

오늘날, 세계에서 가장 부유 한 26 억 명의자인 26 명이 현재 세계 인구의 절반 인 지구상에서 가장 가난한 38 억 인구만큼 많은 부를 소유하고 있습니다.
^{비디오 링크}

사실인지 아닌지. 답변과 토론은 질문 자체로 이동하십시오.

이 주장에 근거한 실제 도전에 관해서는 :

도전:

두 개의 입력 : 내림차순으로 정렬 된 번호 목록 과 숫자 (여기서 n 은 1 \ leq n \ lt \ text {length of} L )입니다. 출력 : 가장 긴 가능한 접미사 서브리스트 L 총합되는 당량 \ 제의 합계 N 개의 리스트의 값 L .$L$$n$$n$$1\leq n\lt \text{length of }L$
$L$$\leq$$n$$L$

예:

입력 : $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]

왜?

목록 L ( ) 의 첫 번째 $n=2$ 값은에 합산됩니다 . 나머지 수의 모든 접미사와 그 합계를 취하면 :$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

합보다 낮거나 같은 갖는다 긴 접미사 700인 [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]의 합과 643그 결과가 우리 그래서.

도전 규칙 :

• 첫 번째 $n$ 접두사의 값 은 출력 접미사에 포함되지 않습니다. 즉, 입력 $L$ = [10,5,5,3]및 $n=2$ 는 [5,3]이고 그렇지 않습니다 [5,5,3].
• I / O는 유연합니다. 을 정수 / 소수 / 문자열의 목록 / 스트림 / 배열로, STDIN을 통해 하나씩 구분 된 문자열로 입력 할 수 있습니다. 정수 / 소수 / 문자열의 목록 / 스트림 / 배열로도 출력 할 수 있습니다. 구분 된 문자열을 인쇄 / 반품하고, 개행마다 번호를 인쇄합니다.$L$
• 출력은 비어 있지 않은 것이 보장됩니다. 당신은 같은 테스트 케이스를 처리 할 필요가 없습니다 그래서 = 및 의 결과 . $L$n = 2[-5,-10,-13]$n=2$[]
• 원하는 경우 입력 및 / 또는 출력 모두 내림차순 대신 오름차순으로 정렬 될 수 있습니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 I / O 규칙으로 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 반환 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트와 링크를 추가하십시오 (예 : TIO ).
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 :

Inputs: L=[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3], n=2
Output: [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

Inputs: L=[10,5,5,3], n=2
Output: [5,3]

Inputs: L=[7,2,1,-2,-4,-5,-10,-12], n=7
Output: [-12]

Inputs: L=[30,20,10,0,-10,-20,-30], n=1
Output: [20,10,0,-10,-20,-30]

Inputs: L=[100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5], n=1
Output: [15,5,5,5,5,5,5,5,5,5,5,5,5,5]

Inputs: L=[0,-5,-10,-15], n=2
Output: [-10,-15]

Inputs: L=[1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250], n=2
Output: [525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250]

Inputs: L=[10,5,5], n=1
Output: [5,5]

C # (Visual C # Interactive Compiler) , 88 81 69 68 63 바이트

LiefdeWen 덕분에 -4 바이트

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

온라인으로 사용해보십시오!

EXAPUNKS (2 개의 EXA, 30 개의 명령어, 594 바이트 솔루션 파일)

EXAPUNKS에서 코드 골프 챌린지를 한동안 시도해보고 싶었습니다. 축하합니다!

L과 n에 대해 각각 파일 200과 201을 통해 입력하십시오. 새로운 파일을 통한 출력. L과 출력은 오름차순입니다.

기본적으로 XA는 L의 마지막 n 값을 합한 다음 XB로 보냅니다. 그런 다음 L의 시작 부분을 찾고 각 값을 하나씩 XB로 보냅니다. XB는 먼저 XA에서 총계를 수신하여 레지스터 X에 저장합니다. 그런 다음 XA에서 하나씩 값을 수신하여 X에서 새 값을 빼고 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

수준에 대한 자바 스크립트 여기

파이썬 2 , 60 바이트

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

온라인으로 사용해보십시오!

설명:

먼저 첫 번째 n항목 의 합계를 가져옵니다 .

그런 다음 각 하위 목록의 합계가이 합계와 비교됩니다. 하나가 크지 않으면 우리는 멈 춥니 다.

그런 다음 결과 (가장 긴) 하위 목록이 인쇄됩니다.

05AB1E , 14 12 바이트

Grimy 덕분에 2 바이트 절약

.$ΔDOI¹£O›.$

온라인으로 사용해보십시오!

설명

.$               # 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 바이트

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

온라인으로 사용해보십시오!

설명:

n왼쪽 인수로, 그리고 L오른쪽 인수로 사용 하는 이완 동사 .

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

루비 , 47 43 바이트

오름차순 목록을 입력으로 사용합니다. 배열의 끝에서 항목을 제거 하여 초기 합계를 얻은 다음 나머지 요소의 합계가 초기 합계보다 작을 때까지 항목을 계속 제거합니다.$n$

스펙을보다 자세히 읽으면 -4 바이트

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

온라인으로 사용해보십시오!

R , 53 55 바이트

@Giuseppe는 제거가 완료되는 방식을 변경하여 2 바이트를 절약했습니다.

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

온라인으로 사용해보십시오! 규칙 4에서 허용하는대로 입력을 내림차순으로 가져오고 오름차순으로 출력합니다.

• Y를 L사용하여 제거 된 1 : n0:-n
• Y누적 합이 다음의 합보다 작은 곳 에서 반환L[X]

자바 스크립트 (ES6), 66 바이트

(a)(n)목록을 오름차순으로 입력 합니다.

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

온라인으로 사용해보십시오!

댓글

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

파이썬 2 , 59 바이트

Python 3 과도 호환

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

온라인으로 사용해보십시오!

설명

접미사 합계는 전체 목록 합계의 절반과 비교됩니다. 접미사 합계가 작거나 같으면 접미사가 반환됩니다. 그렇지 않으면 접미사의 첫 번째 항목이 튀어 나와서 함수가 재귀 적으로 호출됩니다.

Pyth , 16 15 바이트

efgs>vzQsT._<vz

온라인으로 사용해보십시오!

입력 목록은 예제에서 사용 된 것과 같이 내림차순이 아니라 오름차순으로 정렬됩니다.

Pyth가 단일 토큰 연산자로 두 번째 입력에 두 번 이상 액세스 할 수 있기를 원할 때가 있습니다 ( E다음 입력 행을 평가하지만 반복 호출은 이전 값을 무시합니다).

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

편집 : MrXcoder 덕분에 1 바이트 절약

자바 스크립트, 64 바이트

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

온라인으로 사용해보십시오!

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 바이트

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

staxlang.xyz에서 실행하고 디버그하십시오!

더 좋은 버전

압축 해제 (14 바이트) 및 설명 :

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

에 의해 합의 , 나는 스택에이 결과를 남길 수 있습니다. Stax는 암시 적 인쇄를 시도하지만 실패 할 수 있지만 m압축이 풀린 프로그램에를 추가 하면 출력을 멋지게 볼 수 있습니다.

와 { ... }j같은 것 같습니다 { ... fh. 허. 편집 : 그것은 사실이 아닙니다. 전자는 진실한 결과를 얻었을 때 멈추고 나중에 부작용이나 치명적인 오류를 피할 수 있습니다.

APL + WIN, 27 바이트

L을 입력하고 n을 입력하라는 프롬프트를 표시합니다.

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

온라인으로 사용해보십시오! Dyalog Classic 제공

Japt , 16 바이트

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

시도 해봐

£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

젤리 , 13 12 바이트

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

온라인으로 사용해보십시오!

바이트를 저장해 준 @JonathanAllan에게 감사합니다!

$L$$n$

설명

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

가이아 , 12 바이트

eSe¤Σ¤┅⟪Σ⊃⟫∇

온라인으로 사용해보십시오!

스택을 올바르게 얻으면 골프를 칠 수있는 바이트가 있다고 생각합니다.

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)

하스켈 , 46 바이트

이것이 어떻게 보이는지에 대해 불쾌한; 나는 분명한 골프를 놓치고 있기를 바랍니다.

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

온라인으로 사용해보십시오!

splitAt가드에서 패턴 일치를 사용하여 접두사와 접미사를 가져 오려고 시도했지만 3 바이트가 더 많았습니다. 나중에 가드를 사용하여 재귀 함수로 변환하려고 시도하면 바이트 수가 줄어 듭니다.

설명

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

"접두사"라고하는 것은 첫 번째 n요소이고 "접미사"는 나머지 목록입니다.

APL (Dyalog Unicode) , 23 21 바이트 ^SBCS

$n$$L$

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

온라인으로 사용해보십시오!

{}$n$⍺$L$⍵

 ⌽⍵$L$

 +\ 그 접두사 합계

 (… 다음 )< 보다 작은 부울 마스크 :

  ⍺↑⍵  의 처음 취하십시오$n$$L$

  +/ 그것들을 합하다

 ⊥⍨ 후행 진실을 세다

 ⍺⌈$n$

 ⍵↓⍨  앞에서 많은 요소를 떨어 뜨립니다$L$

MATL , 13 12 바이트

@MickyT 의 답변에 따라 @Giuseppe 덕분에 1 바이트가 절약 되었습니다 .

:&)PtYsbs>~)

출력이 오름차순입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

입력 2과를 고려하십시오 [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 바이트

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]

온라인으로 사용해보십시오!

목록을 오름차순으로 가져오고 출력이 내림차순입니다 (테스트 케이스와 비교하기 쉽기 때문에 : ^)

어큐뮬레이터를 함께 추가 된 마지막 항목과 s를 함께 붙이고 결과 문자열을을 통해 전달 하여 목록을 거꾸로 진행n 합니다 . Until 루프는 Rich Neighborhood로 들어가는 것을 처리하기 위해 추가 로직이 필요했습니다. 왜냐하면 우리가 전체 목록을 넘길 때까지 Rich Guy보다 부자가 아닌 경우 멈추지 않기 때문입니다.+invoke-expression

풀림 :

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]

레티 나 0.8.2 , 99 바이트

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

(1*),
$.1,
,$

온라인으로 사용해보십시오! 링크에는 일부 테스트 사례 만 포함됩니다. 12 바이트의 비용 으로 음수로 일부 경우 작동하도록 할 수 있습니다 (특히 첫 번째 n항목은 L여전히 양수이어야합니다. 이론적으로 첫 번째 n항목 의 합계는 양수 여야합니다). 설명:

\d+
$*

단항으로 변환합니다.

^
;,

시작 부분에 마커를 삽입하십시오 L.

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

목록 n시간을 아래로 이동하면 합산됩니다. 삭제 n되지만 쉼표는 남아 있습니다.

,
;$'¶$`,

의 각 접미사에 대한 항목을 작성하십시오 L.

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

중간 부분을 접미사 사본으로 교체하십시오.

T`,`_`.*;

접미사 사본을 합산하십시오.

1G`(1+);\1;

접미사 합계가 접두사 합계를 초과하지 않는 첫 번째 항목을 가져옵니다.

.*;

합계를 삭제하십시오.

(1*),
$.1,

십진수로 변환합니다.

.,$

앞에 온 후행 쉼표를 삭제하십시오 n.

숯 , 17 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

  θ                 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

빨강 , 63 바이트

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

온라인으로 사용해보십시오!

PowerShell , 86 바이트

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

온라인으로 사용해보십시오!

풀림 :

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 바이트

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

온라인으로 사용해보십시오!

설명

다음과 같이 입력을받습니다. 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 = [4, 3, 2, 1], n = 2목록을 [3, 2, 1]and 로 분할합니다 [4, 3]. 첫 번째 목록에 추가 요소가있는 이유는 루프에서 가장 먼저 발생하는 것은 폐기이기 때문입니다. 추가 요소가 앞에 추가되지 않은 경우 출력이 목록의 나머지 전체 여야하는 경우가 실패합니다.

Wolfram Language (Mathematica) , 40 바이트

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

온라인으로 사용해보십시오!

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

클로저, 66 75 바이트

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

슬프게도 시퀀스의 총합에 대한 짧은 관용구가없는 것 같습니다.

편집 : 오 온라인으로 사용해보십시오! link 나는 많은 음수가 존재할 때 원래의 대답이 잘못된 결과를 주었다는 것을 알았습니다.

doseq사용 "키" destructuring 하는 기호에 최대 데이터 끝 다소 명확해야하므로. #(...)익명 함수입니다. 여기에서 심볼에 바인딩하고 있습니다 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)))

산출:

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

APL (NARS), 32 자, 64 바이트

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

테스트 및 의견 :

  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

바이트 길이를 잘못보고했습니다 ...

MS SQL Server 2017 , 271 바이트

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

입력 데이터를 저장하기 위해 관계형 테이블을 사용하면 코드가 더 간결해질 수 있지만 문자 목록을 사용하여 숫자 목록과 STRING_SPLIT함수 를 저장 하면 Build Schema부분 이 짧아집니다

.

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 에서 사용해보십시오 !

Python 3.8 (시험판) , 59 바이트

출력이 오름차순

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

온라인으로 사용해보십시오!