Wprowadzenie:

Kilka dni temu przeczytałem ten post z tym samym tytułem, gdy natknąłem się na niego w HNQ. W tym pytaniu dyskutuje się, czy roszczenie kandydata na prezydenta Bernie Sandersa, który twierdził, co następuje:

Dzisiaj 26 najbogatszych na świecie, 26 miliarderów, ma obecnie tyle samo bogactwa, co najbiedniejszych 3,8 miliarda ludzi na świecie, połowa populacji świata.
^{Link do wideo}

jest prawdą czy nie. Proszę przejść do samego pytania w celu uzyskania odpowiedzi i dyskusji.

Jeśli chodzi o faktyczne wyzwanie oparte na tym twierdzeniu:

Wyzwanie:

Dwa wejścia: malejąca posortowana lista liczb i liczba (gdzie to ). Wydajność: najdłuższy sufiks podmenu z dla których suma jest sumy pierwszego wartości w zestawieniu .$L$$n$$n$$1\leq n\lt \text{length of }L$L ≤ n L
$L$$\leq$$n$$L$

Przykład:

Wejścia: = i . Wydajność:$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]

Czemu?

Pierwsze wartości z listy ( ) sumują się do . Jeśli weźmiemy wszystkie przyrostki pozostałych liczb, a także ich sumy:$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

Najdłuższy przyrostek, którego suma jest mniejsza lub równa, 700to [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]suma 643, więc taki jest nasz wynik.

Zasady konkursu:

• Wartości w pierwszym prefiksie nie są liczone do sufiksu wyjściowego. Tj. Wejścia = i spowodują , a nie .$n$$L$[10,5,5,3]$n=2$[5,3][5,5,3]
• I / O jest elastyczny. Możesz wprowadzić jako listę / strumień / tablicę liczb całkowitych / dziesiętnych / ciągów, pojedynczy ciąg rozdzielany, jeden po drugim poprzez STDIN itp. Możesz również wyprowadzać jako listę / strumień / tablicę liczb całkowitych / dziesiętnych / ciągów, wydrukuj / zwróć rozdzielany ciąg, wydrukuj numer na każdej nowej linii itp. Twoje połączenie.$L$
• Dane wyjściowe gwarantują, że nie będą puste. Więc nie będzie mieć do czynienia z przypadków testowych, takich jak = a skutkuje . $L$n = 2[-5,-10,-13]$n=2$[]
• Zarówno (jak i oba) dane wejściowe i / lub wyjściowe mogą być również w porządku rosnącym zamiast malejącym, jeśli chcesz.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

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 # (interaktywny kompilator Visual C #) , 88 81 69 68 63 bajtów

-4 bajty dzięki LiefdeWen

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

Wypróbuj online!

EXAPUNKS (2 EXA, 30 instrukcji, 594-bajtowy plik rozwiązania)

Przez jakiś czas chciałem spróbować gry w golfa w EXAPUNKS, a wyglądałaś na najlepszą formę, jaką mogłem znaleźć, więc gratulacje!

Wprowadź za pomocą plików 200 i 201, odpowiednio dla L i n. Wyjście przez nowy plik. L i dane wyjściowe są w porządku rosnącym.

Zasadniczo XA sumuje ostatnie n wartości w L, a następnie wysyła je do XB. Następnie szuka początku L i wysyła każdą wartość jeden po drugim do XB. XB najpierw otrzymuje sumę z XA i przechowuje ją w rejestrze X. Następnie otrzymuje wartości jeden po drugim od XA, odejmując nową wartość od X i zapisując te wartości w pliku wyjściowym, aż do 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 dla poziomu tutaj

Python 2 , 60 bajtów

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

Wypróbuj online!

Wyjaśnienie:

Najpierw pobiera sumę pierwszych nelementów.

Następnie suma każdej podlisty jest porównywana z tą sumą. Gdy tylko jeden nie jest większy, przestajemy.

Następnie drukowana jest wynikowa (najdłuższa) podlista.

05AB1E , 14 12 bajtów

Zaoszczędzono 2 bajty dzięki Grimy

.$ΔDOI¹£O›.$

Wypróbuj online!

Wyjaśnienie

.$               # 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 bajtów

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

Wypróbuj online!

Wyjaśnienie:

Czasownik dynastyczny, njako lewy argument i L- jako prawy argument.

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

Rubinowy , 47 43 bajtów

$n$

-4 bajty przez dokładniejsze przeczytanie specyfikacji.

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

Wypróbuj online!

R , 53 55 bajtów

@Giuseppe oszczędził mi 2 bajty, zmieniając sposób usunięcia

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

Wypróbuj online! Przyjmuje dane wejściowe jako malejące, a dane wyjściowe - rosnąco zgodnie z zasadą 4.

• Yoznacza rev Lz 1: n usuniętym za pomocą0:-n
• zwraca, gdy Ysuma skumulowana jest mniejsza niż równa sumieL[X]

JavaScript (ES6), 66 bajtów

Pobiera dane wejściowe jak (a)(n)w liście rosnącej.

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

Wypróbuj online!

Skomentował

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 bajtów

Kompatybilny również z Python 3

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

Wypróbuj online!

Wyjaśnienie

Suma sufiksu jest porównywana z połową sumy całej listy. Jeśli suma sufiksu jest mniejsza lub równa, sufiks jest zwracany. Jeśli nie, funkcja jest wywoływana rekurencyjnie z wyskakującym pierwszym elementem sufiksu.

Pyth , 16 15 bajtów

efgs>vzQsT._<vz

Wypróbuj online!

Oczekuje się, że lista danych wejściowych zostanie posortowana w kolejności rosnącej, a nie malejącej, jak w przykładach.

W takich momentach naprawdę chciałbym, aby Pyth miał jeden operator tokenu, który miał dostęp do drugiego wejścia więcej niż raz ( Eocenia następny wiersz danych wejściowych, ale powtarzane połączenia odrzucają odczytaną poprzednią wartość).

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

Edycja: zapisano 1 bajt dzięki MrXcoder

JavaScript, 64 bajty

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

Wypróbuj online!

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 bajtów

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

Uruchom i debuguj na staxlang.xyz!

Ładniejsza wersja

Rozpakowane (14 bajtów) i objaśnienie:

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

W drodze konsensusu mogę pozostawić ten wynik na stosie. Stax podejmie próbę niejawnego wydruku, który może się nie powieść, ale dołączenie mdo rozpakowanego programu pozwala dobrze wyświetlić wynik.

Wygląda na { ... }jto, że jest taki sam jak { ... fh. Huh Edycja: Nie do końca tak jest; jedyny z nich zatrzyma się, gdy osiągnie prawdziwy wynik, prawdopodobnie unikając później skutków ubocznych lub fatalnego błędu.

APL + WIN, 27 bajtów

Monituje o wprowadzenie L, a następnie n.

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

Wypróbuj online! Dzięki uprzejmości Dyalog Classic

Japt , 16 bajtów

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

Spróbuj

£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

Galaretka , 13 12 bajtów

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

Wypróbuj online!

Dzięki @JonathanAllan za uratowanie bajtu!

$L$$n$

Wyjaśnienie

ṫ            | 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 bajtów

eSe¤Σ¤┅⟪Σ⊃⟫∇

Wypróbuj online!

Myślę, że istnieje bajt, w którym mogę grać w golfa, jeśli uda mi się uzyskać stos.

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 bajtów

Niezadowolony z tego, jak to wygląda; mam nadzieję, że po prostu brakuje mi oczywistych golfów.

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

Wypróbuj online!

Próbowałem uzyskać prefiks i sufiks splitAtoraz dopasowanie wzorca w osłonie, ale okazało się, że to 3 bajty więcej. Planujesz później spróbować przekonwertować na funkcję rekurencyjną ze strażnikami, aby sprawdzić, czy to obniży liczbę bajtów.

Wyjaśnienie

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

To, co nazywam „prefiksem”, to pierwsze nelementy, a „sufiks” to reszta listy.

APL (Dyalog Unicode) , 23 21 bajtów ^SBCS

$n$$L$

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

Wypróbuj online!

{}$n$⍺$L$⍵

 ⌽⍵$L$

 +\ przedrostek sum tego

 (… )< Maska boolowska, gdzie mniej niż:

  ⍺↑⍵$n$$L$

  +/ zsumuj je

 ⊥⍨ liczyć końcowe prawdy

 ⍺⌈$n$

 ⍵↓⍨$L$

MATL , 13 12 bajtów

1 bajt zapisany dzięki @Giuseppe , na podstawie odpowiedzi @MickyT .

:&)PtYsbs>~)

Wyjście jest w porządku rosnącym.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Rozważ dane wejściowe 2i [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 bajtów

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]

Wypróbuj online!

Pobiera listę w kolejności rosnącej, wyniki maleją (ponieważ łatwiej było porównać do przypadków testowych: ^))

Przechodzi przez listę do tyłu do przodu, porównując akumulator do ostatnio ndodanych wpisów (poprzez sklejenie ich razem +zs i przekazanie powstałego ciągu invoke-expression). Pętla Until potrzebowała dodatkowej logiki, by poradzić sobie z wejściem do bogatego sąsiedztwa, ponieważ nie zatrzymałby się, gdybyśmy nie byli bogatsi od bogatych facetów, dopóki nie przejdziemy przez całą listę.

Rozwinięty:

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 bajtów

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

(1*),
$.1,
,$

Wypróbuj online! Link zawiera tylko niektóre przypadki testowe; Mogłem sprawić, że zadziała w niektórych przypadkach z liczbami ujemnymi kosztem 12 bajtów (w szczególności pierwsze nwpisy Lnadal muszą być dodatnie; teoretycznie prawdopodobnie mógłbym wymagać tylko sumy pierwszych nwpisów, aby były dodatnie). Wyjaśnienie:

\d+
$*

Konwertuj na unary.

^
;,

Wstaw znacznik na początku L.

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

Przenieś go w dół listy nrazy, sumując w miarę, jak idziemy. Usuwa się, nale przecinek pozostaje.

,
;$'¶$`,

Utwórz wpis dla każdego sufiksu L.

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

Zastąp środek kopią sufiksu.

T`,`_`.*;

Zsumuj kopię przyrostka.

1G`(1+);\1;

Weź pierwszy wpis, w którym suma sufiksu nie przekracza sumy prefiksu.

.*;

Usuń sumy.

(1*),
$.1,

Konwertuj na dziesiętny.

.,$

Usuń końcowy przecinek, który pojawił się wcześniej n.

Węgiel drzewny , 17 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

  θ                 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

Czerwony , 63 bajty

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

Wypróbuj online!

PowerShell , 86 bajtów

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

Wypróbuj online!

Rozwinięty:

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

Pobiera dane wejściowe jako 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

Powodem tego jest fakt, że w pierwszym etapie faktycznie dzielimy listę na dwie pokrywające się części. Na przykład L = [4, 3, 2, 1], n = 2podzieli listę jako [3, 2, 1]i [4, 3]. Powodem posiadania dodatkowego elementu na pierwszej liście jest to, że w pętli pierwszą rzeczą, która się dzieje, jest odrzucenie. Jeśli dodatkowy element nie zostałby poprzedzony, przypadki, w których dane wyjściowe powinny stanowić całą resztę listy, zakończyłyby się niepowodzeniem.

Wolfram Language (Mathematica) , 40 bajtów

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

Wypróbuj online!

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 bajtów

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

Niestety, wydaje się, że nie ma krótszego idiomu dla całkowitej sumy sekwencji.

Edycja : Och, dodając przykłady do Wypróbuj online! link Zauważyłem, że oryginalna odpowiedź dawała złe wyniki, gdy obecnych było wiele liczb ujemnych.

Do doseqzastosowań „Keys” destructuring tak powinno być nieco jasne końce, które dane w której symbol. #(...)jest funkcją anonimową, tutaj wiążę ją z symbolem 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)))

Wydajność:

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

APL (NARS), 32 znaki, 64 bajty

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

test i komentarze:

  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

Podałem błędnie długość bajtu ...

MS SQL Server 2017 , 271 bajtów

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

Wiem, że użycie bardziej podobnej do relacji tabeli do przechowywania danych wejściowych może sprawić, że kod będzie bardziej zwięzły, ale używając typu danych znakowych do przechowywania listy numerycznej i STRING_SPLITfunkcji, skracam Build Schemaczęść :)

Bardziej czytelna wersja:

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

Wypróbuj na SQL Fiddle !

Python 3.8 (wersja wstępna) , 59 bajtów

Wyjście jest w porządku rosnącym

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

Wypróbuj online!