Os 26 bilionários mais ricos possuem tanta riqueza quanto os 3,8 bilhões de pessoas mais pobres?

37

Introdução:

Alguns dias atrás, li este post com o mesmo título quando o encontrei no HNQ. Nesta questão, está sendo discutido se a reivindicação do candidato a presidente Bernie Sanders, que reivindicou o seguinte:

Hoje, os 26 bilionários mais ricos do mundo, 26, agora possuem tanta riqueza quanto os 3,8 bilhões de pessoas mais pobres do planeta, metade da população mundial.
Link para o vídeo

é verdade ou não. Por favor, vá para a pergunta em si para obter respostas e discussões lá.

Quanto ao desafio real com base nessa reivindicação:

Desafio:

Duas entradas: uma lista de números ordenada decrescente L e um número (onde é ). Output: a maior sub-lista possível sufixo de para que a soma total é a soma dos primeiros valores na lista .nn1n<length of LL n L
LnL

Exemplo:

Entradas: = e . Saída: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]

Por quê?

Os primeiros valores da lista ( ) somam . Se pegarmos todos os sufixos dos números restantes, bem como suas somas:n=2L[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

O sufixo mais longo que tem uma soma menor ou igual a 700é [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]com uma soma de 643, portanto esse é o nosso resultado.

Regras do desafio:

  • Os valores no primeiro prefixo não são contados no sufixo de saída. Ou seja, as entradas = e resultariam em , e não .nL[10,5,5,3]n=2[5,3][5,5,3]
  • A E / S é flexível. Você pode inserir como uma lista / fluxo / array de números inteiros / decimais / strings, uma única string delimitada, uma a uma através de STDIN, etc. Você pode gerar como uma lista / stream / array de inteiros / decimais / strings imprima / retorne uma sequência delimitada, imprima um número em cada nova linha, etc. Sua ligação.L
  • A saída é garantida para não estar vazia. Então você não terá que lidar com casos de teste como = e , resultando em . Ln = 2[-5,-10,-13]n=2[]
  • Tanto (ou qualquer) a entrada e / ou saída também podem estar em ordem crescente, em vez de ordem decrescente, se você optar por isso.

Regras gerais:

  • Isso é , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
  • Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

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]
Kevin Cruijssen
fonte
Posso escrever uma resposta que funcione apenas com números inteiros positivos (ou talvez não negativos; ainda não os escrevi) devido à falta de um tipo inteiro no idioma?
Neil
3
@ Neil Suponho que você esteja falando da Retina aqui? Mas, claro, você pode assumir que todos os valores não são negativos nesse caso. No entanto, é melhor você também ter uma segunda versão que funcione com valores negativos, porque tenho a sensação de que é realmente possível (com um grande aumento na contagem de bytes e algumas soluções alternativas); que é mais um sentimento geral do que um fato real, não tenho certeza se é realmente possível contornar a parte dos valores negativos).
Kevin Cruijssen 01/07
6
O caso de teste real seria assim [131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]:: p
Arnauld
2
E o cenário em que nenhum dos valores atende aos critérios: [1,2,3] n = 1? O que você deseja para a saída?
ouflak 01/07
@ouflak Ver a terceira regra desafio: " A saída é garantia de ser não-vazia Então você não terá que lidar com casos de teste como. L = [-5,-10,-13]e n=2resultando em []. " Além disso, a lista de entrada é garantida para ser descendente ordenada (ou ascendente se você optar por), portanto, [1,2,3]não é uma lista de entrada válida para começar (a menos que você escolha entrada ascendente, nesse caso, [1,2]seria o resultado).
Kevin Cruijssen 01/07

Respostas:

17

C # (Compilador interativo do Visual C #) , 88 81 69 68 63 bytes

-4 bytes graças a LiefdeWen

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

Experimente online!

Dados expirados
fonte
Estou pensando que você poderia economizar mais dois, eliminando +ba Skipchamada; é redundante verificar a primeira nlista, mas acho que ainda está correta.
TheRubberDuck
3
@TheRubberDuck não, teve que adicioná-lo para o caso em que o prefixo e o sufixo se sobrepõem. Ou seja, [10,5,5,3], n = 2
dados expirados
64 bytes
LiefdeWen
@LiefdeWen nice! na verdade, é menos também se usarmos uma função ao curry.
Data expirada
@ExpiredData Ah sim, esqueci que eu o removi.
LiefdeWen
12

EXAPUNKS (2 EXAs, 30 instruções, arquivo de solução de 594 bytes)

Eu queria experimentar um desafio de código de golfe no EXAPUNKS por um tempo e você parecia o melhor ajuste que eu poderia encontrar, então parabéns!

Entrada via arquivos 200 e 201, para L e n, respectivamente. Saída através de um novo arquivo. L e a saída estão em ordem crescente.

Basicamente, XA soma os últimos n valores em L e os envia para XB. Em seguida, procura o início de L e envia cada valor um por um para XB. O XB primeiro recebe o total de XA e o armazena no registro X. Em seguida, recebe os valores um a um de XA, deduzindo o novo valor de X e gravando esses valores no arquivo de saída até 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 para o nível aqui

ymbirtt
fonte
O IIRC não exapunks tem como salvar soluções? Nesse caso, você deve usar a contagem de bytes em vez das instruções do jogo.
Wheat Wizard
11
@ SriotchilismO'Zaic, sim, eu não acho que os arquivos devam ser facilmente acessíveis, mas acabei de encontrá-los. Vou adicionar o tamanho em disco. Vários metadados que não escrevi são armazenados ao lado, mas acho que essa é a melhor maneira de obter uma única "contagem de bytes" deste jogo.
ymbirtt 1/07
Adoraria dedicar um tempo para analisar esses arquivos e verificar se há uma maneira de classificar os metadados para baixo. Também me pergunto se algumas instruções levam mais memória que outras.
Wheat Wizard
@ SriotchilismO'Zaic, eles realmente fazem. Todas as instruções são armazenadas como texto simples, portanto, para começar, podemos transformar todas as marcas em identificadores de letra única. O nome da sua solução está lá, para que possamos remover alguns bytes chamando a solução 'a'. Algumas partes também parecem relacionadas à rede virtual que você criou para o EXA. Honestamente, acho que a maneira "mais justa" de classificar as soluções EXAPUNKS é usar a contagem de bytes do código real ou o número de instruções. Isso pode valer a pena uma meta post ...
ymbirtt 2/07
2
@ymbirtt Suponho que a pergunta se resume a você poderia escrever um intérprete que analise as instruções e se converta nos dados salvos? Bem, trivialmente sim, basta escrever um programa que insira para você a partir da fonte .., embora contasse como um idioma diferente.
Data de
11

Python 2 , 60 bytes

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

Experimente online!


Explicação:

Primeiro pega a soma dos primeiros nitens.

Em seguida, a soma de cada sub-lista é comparada a essa soma. Assim que um não é maior, paramos.

Em seguida, a sublist (resultante) mais longa é impressa.

TFeld
fonte
2
realmente o mais legível +1
Kryštof Řeháček
10

05AB1E , 14 12 bytes

Economizou 2 bytes graças ao Grimy

.$ΔDOI¹£O›.$

Experimente online!

Explicaçã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
Emigna
fonte
2
Exatamente o mesmo que eu havia preparado como solução. E por 'exatamente' quero dizer que o meu era .$.sʒO²¹£O>‹}θ. :)
Kevin Cruijssen
2
@KevinCruijssen aqui está 12
Grimmy
11
Somente ASCII 12 (usando um método de entrada diferente).
Grimmy 01/07
11
@ Grimy: Hein. Eu nunca soube |substituir last-input, interessante.
Emigna 01/07
2
@ Grimy: Veja isso vs isso . Normalmente, quando todas as entradas são consumidas, a última entrada é implicitamente usada para todas as instâncias da próxima entrada. Usar |aqui faz com que o resultado |se torne a última entrada, em vez da última entrada.
Emigna 01/07
7

J , 18 bytes

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

Experimente online!

Explicação:

Um verbo diádico, tendo ncomo argumento à esquerda e L- como argumento à direita.

                }.  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)
Galen Ivanov
fonte
7

Ruby , 47 43 bytes

n

-4 bytes lendo as especificações mais de perto.

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

Experimente online!

Value Ink
fonte
7

R , 53 55 bytes

@ Giuseppe me salvou 2 bytes mudando a maneira como a remoção foi feita

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

Experimente online! Leva a entrada como descendente e as saídas em ascensão, conforme permitido pela regra 4.

  • Yé a rotação Lcom 1: n removido usando0:-n
  • retorna de Yonde a soma acumulada é menor que igual à soma deL[X]
MickyT
fonte
@ Giuseppe como sempre obrigado. Tentei remover o Xuso, -(1:n)mas é claro que era do mesmo tamanho, então deixou
MickyT 01/07
6

JavaScript (ES6), 66 bytes

Recebe as entradas como (a)(n)na lista em ordem crescente.

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

Experimente online!

Comentado

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
Arnauld
fonte
11
@KevinCruijssen Parece que eu interpretei errado o requisito. Deve ser corrigido agora.
Arnauld
E, diferentemente de outras respostas que corrigiram o mesmo problema, sem um aumento na contagem de bytes. :) (E parcialmente ruim, deveria ter incluído um caso de teste para
5

Python 2 , 59 bytes

Também compatível com Python 3

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

Experimente online!


Explicação

A soma do sufixo é comparada à metade da soma da lista inteira. Se a soma do sufixo for menor ou igual, o sufixo será retornado. Caso contrário, a função é chamada recursivamente com o primeiro item do sufixo exibido.

Jitse
fonte
4

Pitão , 16 15 bytes

efgs>vzQsT._<vz

Experimente online!

A lista de entrada deve ser classificada em ordem crescente, em vez de decrescente, como é usado nos exemplos.

É nessas horas que eu realmente desejo que o Pyth tenha um único operador de token para acessar a segunda entrada mais de uma vez (E avalia a próxima linha de entrada, mas chamadas repetidas descartam o valor anterior lido).

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

Edit: economizou 1 byte graças ao MrXcoder

Sok
fonte
@ Mr.Xcoder Boa sorte, que salvamento óbvio! Obrigado 👍
Sok
4

JavaScript, 64 bytes

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

Experimente 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
)
tsh
fonte
4

Stax , 12 bytes

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

Execute e depure-o em staxlang.xyz!

Versão melhor

Descompactado (14 bytes) e explicação:

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

Por consenso , posso deixar esse resultado na pilha. O Stax tentará uma impressão implícita, o que pode falhar, mas anexar um mao programa descompactado permite que você veja a saída perfeitamente.

Parece que { ... }jé o mesmo que { ... fh. Hã. Edit: Esse não é bem o caso; o único que o primeiro irá parar quando obtiver um resultado verdadeiro, possivelmente evitando efeitos colaterais ou erros fatais mais tarde.

Khuldraeseth na'Barya
fonte
3

Japonês , 16 bytes

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

Tente

£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
Shaggy
fonte
3

Geléia , 13 12 bytes

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

Experimente online!

Obrigado a @ JonathanAllan por salvar um byte!

Ln

Explicação

ṫ            | 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)
Nick Kennedy
fonte
Você pode salvar um byte, classificando em vez de filtrar:ṫḊÐƤS>¥ÞḣS¥Ḣ
Jonathan Allan
3

Gaia , 12 bytes

eSe¤Σ¤┅⟪Σ⊃⟫∇

Experimente online!

Eu acho que há um byte que eu posso jogar se eu conseguir a pilha certa.

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)
Giuseppe
fonte
3

Haskell , 46 bytes

Desagradado com a aparência; Espero que eu esteja perdendo alguns tacos óbvios.

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

Experimente online!

Eu tentei obter o prefixo e sufixo usando splitAt correspondência de padrões em um guarda, mas isso resultou em 3 bytes a mais. Planejando tentar converter para uma função recursiva com guardas posteriormente para ver se isso reduz a contagem de bytes.

Explicação

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

O que me refiro como "o prefixo" são os primeiros nelementos e "o sufixo" é o restante da lista.

Cole
fonte
3

APL (Dyalog Unicode) , 23 21 bytes SBCS

nL

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

Experimente online!

{}nL

⌽⍵L

+\ soma prefixo desse

()< Máscara booleana em que menos de:

  ⍺↑⍵nL

  +/ somar aqueles

⊥⍨contar verdades finais

⍺⌈n

⍵↓⍨L

Adão
fonte
11
@KevinCruijssen Bem localizado. Fixo.
Adám 02/07
3

MATL , 13 12 bytes

1 byte economizado graças a @ Giuseppe , com base na resposta de @MickyT .

:&)PtYsbs>~)

A saída está em ordem crescente.

Experimente online! Ou verifique todos os casos de teste .

Explicação

Considere entradas 2e [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]
Luis Mendo
fonte
3

PowerShell , 99 97 bytes

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]

Experimente online!

Leva a lista em ordem crescente, a saída é decrescente (porque era mais fácil comparar com os casos de teste: ^))

Percorre a lista de trás para frente, comparando o acumulador com as últimas nentradas adicionadas (colando-as com +es e passando a sequência resultante para invoke-expression). O loop Até precisava de lógica adicional para lidar com a entrada no Bairro Rico, porque não pararia se ainda não fôssemos mais ricos que os Ricos até percorrermos a lista inteira.

Desenrolado:

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]
Veskah
fonte
3

Retina 0.8.2 , 99 bytes

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

(1*),
$.1,
,$

Experimente online! O link inclui apenas alguns casos de teste; Eu poderia fazê-lo funcionar em alguns casos com números negativos a um custo de 12 bytes (em particular, as primeiras nentradas Lainda precisam ser positivas; teoricamente eu provavelmente só poderia exigir que a soma das primeiras nentradas fosse positiva). Explicação:

\d+
$*

Converta para unário.

^
;,

Insira um marcador no início de L.

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

Mova para baixo na lista de ntempos, somando à medida que avançamos. Isso exclui, nmas sua vírgula permanece.

,
;$'¶$`,

Crie uma entrada para cada sufixo de L.

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

Substitua o meio por uma cópia do sufixo.

T`,`_`.*;

Soma a cópia do sufixo.

1G`(1+);\1;

Tome a primeira entrada em que a soma do sufixo não exceda a soma do prefixo.

.*;

Exclua as somas.

(1*),
$.1,

Converta para decimal.

.,$

Exclua a vírgula à direita que veio antes n.

Neil
fonte
n
11
@KevinCruijssen Minha versão do número negativo acabou sendo proibitivamente lenta, mas consegui corrigir isso usando a ropção, então agora a vinculei a alguns casos de teste.
Neil
2

Carvão , 17 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

  θ                 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
I                   Cast to string
                    Implicitly print on separate lines
Neil
fonte
2

PowerShell , 86 bytes

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

Experimente online!

Desenrolado:

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
}
confuso
fonte
2

MathGolf , 13 bytes

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

Experimente online!

Explicação

Aceita entrada como 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

A razão pela qual isso funciona é que, na primeira etapa, dividimos a lista em duas partes sobrepostas. Como exemplo, L = [4, 3, 2, 1], n = 2dividirá a lista como [3, 2, 1]e [4, 3]. O motivo de ter um elemento extra na primeira lista é que, no loop, a primeira coisa que acontece é um descarte. Se um elemento extra não fosse anexado, os casos em que a saída deveria ser o resto da lista falhariam.

maxb
fonte
2

Wolfram Language (Mathematica) , 40 bytes

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

Experimente 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*)
attinat
fonte
1

Clojure, 66 75 bytes

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

Infelizmente, não parece haver um idioma mais curto para a soma total de uma sequência.

Edit : Ah, ao adicionar exemplos ao Experimente online! notei que a resposta original dava resultados errados quando muitos números negativos estavam presentes.

O dosequso de "chaves" é desestruturado, portanto deve ficar um pouco claro quais dados terminam em qual símbolo. #(...)é uma função anônima, aqui estou vinculando-a ao símbolo 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)))

Saída:

(5 3)
(-12)
(20 10 0 -10 -20 -30)
NikoNyrh
fonte
11
Você se importaria de adicionar um TIO com código de teste (vejo Clojure na lista)? Se não for possível de alguma forma (incompatibilidade de versão ou usar componentes internos que não estão disponíveis no TIO), você poderia incluir uma captura de tela com alguns dos casos de teste para verificar se funciona?
Kevin Cruijssen 01/07
1

APL (NARS), 32 caracteres, 64 bytes

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

teste e comentários:

  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

Eu relatei incorretamente o comprimento do byte ...

RosLuP
fonte
1

MS SQL Server 2017 , 271 bytes

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

Eu sei que usar uma tabela mais parecida com relação para armazenar os dados de entrada pode tornar o código mais conciso, mas usando o tipo de dados de caractere para armazenar a lista numérica e a STRING_SPLITfunção, diminuo a Build Schemaparte :)

Versão mais legível:

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

Experimente no SQL Fiddle !

Andrei Odegov
fonte