บทนำ:

ไม่กี่วันที่ผ่านมาฉันอ่านโพสต์นี้ด้วยชื่อเดียวกันเมื่อฉันเจอใน HNQ ในคำถามนี้จะมีการหารือกันหากการเรียกร้องของประธานาธิบดีเบอร์นีแซนเดอร์สซึ่งอ้างว่าต่อไปนี้:

ทุกวันนี้เศรษฐีที่ร่ำรวยที่สุดในโลก 26 ล้านคนอายุ 26 ปีเป็นเจ้าของทรัพย์สมบัติมากเท่ากับคนที่ยากจนที่สุดในโลกถึง 3.8 พันล้านคนครึ่งหนึ่งของประชากรโลก
^{ลิงก์ไปยังวิดีโอ}

เป็นจริงหรือไม่ โปรดไปที่คำถามเพื่อหาคำตอบและการอภิปรายที่นั่น

สำหรับความท้าทายที่เกิดขึ้นจริงตามการอ้างสิทธิ์นี้:

ท้าทาย:

สองอินพุต:รายการหมายเลข$L$เรียงลำดับจากมากไปน้อยและตัวเลข$n$ (โดยที่$n$คือ$1\leq n\lt \text{length of }L$ )
ขาออกที่ยาวที่สุดที่เป็นไปได้ต่อท้ายรายการย่อยของ$L$ซึ่งผลรวมเป็น$\leq$ผลรวมของแรก$n$ค่าในรายการL$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$ 2
เอาท์พุท:[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$ค่าของรายการ ( ) ผลรวมจะ หากเรารับส่วนต่อท้ายของจำนวนที่เหลืออยู่รวมถึงผลรวมของพวกเขา:$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 ยืดหยุ่นได้ คุณสามารถป้อน$L$เป็นรายการ / สตรีม / อาร์เรย์ของจำนวนเต็ม / ทศนิยม / สตริง, สตริงที่มีตัวคั่นเดียว, หนึ่งโดยหนึ่งผ่าน STDIN, ฯลฯ คุณสามารถส่งออกเป็นรายการ / สตรีม / อาร์เรย์ของจำนวนเต็ม / ทศนิยม / สตริงเช่นกัน พิมพ์ / ส่งคืนสตริงที่มีตัวคั่นพิมพ์ตัวเลขในแต่ละบรรทัดใหม่ ฯลฯ การโทรของคุณ
• การส่งออกจะรับประกันว่าจะไม่ว่างเปล่า ดังนั้นคุณจะไม่ต้องจัดการกับกรณีทดสอบเช่น$L$ = [-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 ไบต์

-4 ไบต์ขอขอบคุณLiefdeWen

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

ลองออนไลน์!

EXAPUNKS (2 EXAs, 30 คำแนะนำ, ไฟล์โซลูชัน 594- ไบต์)

ฉันต้องการลองเล่นกอล์ฟรหัสใน EXAPUNKS มาระยะหนึ่งแล้วและคุณดูเหมือนจะฟิตที่สุดเท่าที่ฉันจะทำได้ขอแสดงความยินดี!

อินพุตผ่านไฟล์ 200 และ 201 สำหรับ L และ n ตามลำดับ ส่งออกผ่านไฟล์ใหม่ L และเอาต์พุตอยู่ในลำดับจากน้อยไปหามาก

โดยพื้นฐานแล้ว XA จะรวมจำนวน n ค่าสุดท้ายใน L จากนั้นส่งไปที่ XB จากนั้นหาจุดเริ่มต้นของ L และส่งแต่ละค่าทีละหนึ่งไปยัง XB XB ก่อนได้รับผลรวมจาก XA และเก็บไว้ใน register 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

JavaScript สำหรับระดับที่นี่

Python 2 , 60 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

ก่อนอื่นให้นำผลรวมของค่าแรกมาใช้ nรายการ

จากนั้นผลรวมของแต่ละรายการย่อยจะถูกเปรียบเทียบกับผลรวมนี้ ทันทีที่เราไม่หยุดเราก็หยุด

จากนั้นรายการย่อยผลลัพธ์ (ยาวที่สุด) จะถูกพิมพ์

05AB1E , 14 12 ไบต์

บันทึก 2 ไบต์ขอบคุณGrimy

.$Δ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 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

กริยา dyadic ใช้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)

Ruby , 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: n ถูกลบโดยใช้0:-n
• ผลตอบแทนจากการYที่ผลรวมสะสมน้อยกว่านั้นเท่ากับผลรวมของL[X]

JavaScript (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

Python 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

แก้ไข: บันทึก 1 ไบต์ขอบคุณ MrXcoder

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

Gaiaขนาด 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)

Haskell , 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 ไบต์

1 ไบต์บันทึกขอบคุณที่@Giuseppeขึ้นอยู่กับคำตอบโดย @MickyT

:&)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]

ลองออนไลน์!

รับรายการตามลำดับจากน้อยไปมากเอาต์พุตจะลดลง (เนื่องจากเปรียบเทียบกับกรณีทดสอบได้ง่ายกว่า: ^))

ไปข้างหน้ารายการย้อนหลังไปข้างหน้าเปรียบเทียบแอคคูเลเตอร์กับnรายการล่าสุดที่รวมเข้าด้วยกัน (ผ่านการติดกาวพวกมันพร้อมกับ+s และส่งผ่านสตริงผลลัพธ์ไปที่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] [4, 3]เหตุผลที่มีองค์ประกอบพิเศษในรายการแรกคือในวงสิ่งแรกที่เกิดขึ้นคือการละทิ้ง หากองค์ประกอบเพิ่มเติมไม่ได้ถูกเติมไว้ล่วงหน้ากรณีที่ผลลัพธ์ควรเป็นส่วนที่เหลือทั้งหมดของรายการจะล้มเหลว

ภาษา Wolfram (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*)

Clojure, 66 75 ไบต์

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

น่าเศร้าที่ดูเหมือนจะไม่เป็นสำนวนสั้นลงสำหรับผลรวมของลำดับ

แก้ไข : โอ้เมื่อเพิ่มตัวอย่างในลองออนไลน์! ลิงก์ฉันสังเกตว่าคำตอบเดิมให้ผลลัพธ์ที่ผิดเมื่อมีตัวเลขติดลบจำนวนมาก

การdoseqใช้การทำลาย "คีย์" ดังนั้นจึงควรมีความชัดเจนว่าข้อมูลใดที่เป็นสัญลักษณ์ #(...)เป็นฟังก์ชั่นไม่ระบุชื่อที่นี่ฉันผูกพันกับสัญลักษณ์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

ลองออนไลน์!