¿Los 26 multimillonarios más ricos poseen tanta riqueza como los 3,8 mil millones de personas más pobres?

37

Introducción:

Hace unos días leí esta publicación con el mismo título cuando la encontré en el HNQ. En esta pregunta se está discutiendo si el reclamo del presidente candidato Bernie Sanders, quien afirmó lo siguiente:

Hoy, los 26 multimillonarios más ricos del mundo, 26, poseen ahora tanta riqueza como los 3,8 mil millones de personas más pobres del planeta, la mitad de la población mundial.
Enlace al video

es cierto o no Vaya a la pregunta en sí para obtener respuestas y discusiones allí.

En cuanto al desafío real basado en esta afirmación:

Reto:

Dos entradas: una lista de números ordenada descendente L y un número n (donde n es 1n<length of L ).
Salida: la posible sufijo sub-lista más larga de L para los que la suma total es la suma de los primeros n valores en la lista L .

Ejemplo:

Entradas: 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]y n=2 .
Salida:[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é?

Los primeros n=2 valores de la lista L ( [500,200]) suman 700. Si tomamos todos los sufijos de los números restantes, así como sus sumas:

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

El sufijo más largo que tiene una suma menor o igual a 700es [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]con una suma de 643, así que ese es nuestro resultado.

Reglas de desafío:

  • Los valores en el primer n prefijo no se cuentan para el sufijo de salida. Es decir, las entradas L = [10,5,5,3]y n=2 se traduciría en [5,3], y no [5,5,3].
  • I / O es flexible. Puede ingresar L como una lista / secuencia / matriz de enteros / decimales / cadenas, una sola cadena delimitada, una por una a través de STDIN, etc. También puede generar una lista / secuencia / matriz de enteros / decimales / cadenas, imprima / devuelva una cadena delimitada, imprima un número en cada línea nueva, etc. Su llamada.
  • La salida garantiza que no está vacía. Por lo que no tendrá que hacer frente a los casos de prueba como L = [-5,-10,-13]y n=2 dando como resultado [].
  • Tanto (como cualquiera) la entrada y / o salida también pueden estar en orden ascendente en lugar de orden descendente si lo desea.

Reglas generales:

  • Este es el , por lo que la respuesta más corta en bytes gana.
    No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
  • Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
  • Las lagunas predeterminadas están prohibidas.
  • Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
  • Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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
fuente
¿Puedo escribir una respuesta que solo funcione con enteros positivos (o tal vez no negativos; aún no los he escrito) debido a la falta de un tipo entero en el idioma?
Neil
3
@Neil ¿Asumo que estás hablando de Retina aquí? Pero claro, puede asumir que todos los valores no son negativos en ese caso. Sin embargo, ¿es mejor tener también una segunda versión que funcione para valores negativos, porque tengo la sensación de que en realidad se puede lograr (con un gran aumento en el conteo de bytes y algunas soluciones alternativas); que es más un sentimiento general que un hecho real, no estoy seguro de si es posible evitar la parte de valores negativos).
Kevin Cruijssen
66
El caso de prueba real se vería así [131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]:: p
Arnauld
2
¿Qué pasa con el escenario donde ninguno de los valores cumple con los criterios: [1,2,3] n = 1? ¿Qué quieres para la salida?
ouflak 01 de
@ouflak Vea la tercera regla de desafío: " La salida garantiza que no estará vacía. Por lo tanto, no tendrá que lidiar con casos de prueba como L = [-5,-10,-13]y que n=2resultan en[] " . Además, se garantiza que la lista de entrada se ordenará descendente (o ascendente si lo desea), por [1,2,3]lo que no es una lista de entrada válida para empezar (a menos que elija una entrada ascendente, en cuyo caso [1,2]sería el resultado).
Kevin Cruijssen

Respuestas:

17

C # (compilador interactivo de Visual C #) , 88 81 69 68 63 bytes

-4 bytes gracias a LiefdeWen

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

Pruébalo en línea!

Datos caducados
fuente
Estoy pensando que podría eliminar dos más eliminando +ben la Skipllamada; es redundante verificar la primera nlista, pero creo que sigue siendo correcta.
TheRubberDuck
3
@TheRubberDuck no, tuvo que agregarlo para el caso donde el prefijo y el sufijo se superponen. Es decir, [10,5,5,3], n = 2
Datos
64 bytes
LiefdeWen
@LiefdeWen agradable! en realidad es menos también si usamos una función curry
Datos caducados el
@ExpiredData Oh sí, olvidé que lo eliminé.
LiefdeWen
12

EXAPUNKS (2 EXA, 30 instrucciones, archivo de solución de 594 bytes)

Quería probar un desafío de código de golf en EXAPUNKS por un tiempo, y parecías el mejor ajuste que pude encontrar, ¡felicidades!

Entrada a través de los archivos 200 y 201, para L yn respectivamente. Salida a través de un nuevo archivo. L y la salida están en orden ascendente.

Básicamente, XA suma los últimos n valores en L, luego lo envía a XB. Luego busca el comienzo de L y envía cada valor uno por uno a XB. XB primero recibe el total de XA y lo almacena en el registro X. Luego recibe valores uno por uno de XA, deduciendo el nuevo valor de X y escribiendo esos valores en el archivo de salida hasta 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 el nivel aquí

ymbirtt
fuente
¿IIRC no tiene exapunks una manera de guardar soluciones? Si es así, debes usar el conteo de bytes en lugar de las instrucciones del juego.
Wheat Wizard
1
@ SriotchilismO'Zaic, sí, no pensé que se suponía que los archivos fueran fácilmente accesibles, pero acabo de encontrarlos. Agregaré el tamaño en el disco. Un montón de metadatos que no escribí se almacenan junto a él, pero supongo que esta es la mejor manera de obtener un solo "conteo de bytes" de este juego.
ymbirtt
Me encantaría tomarme el tiempo de mirar estos archivos y ver si hay alguna forma de descifrar los metadatos. También me pregunto si algunas instrucciones toman más memoria que otras.
Wheat Wizard
@ SriotchilismO'Zaic, en realidad lo hacen. Todas las instrucciones se almacenan como texto sin formato, por lo que, para empezar, podemos convertir todas las marcas en identificadores de una letra. El nombre de su solución está allí, por lo que podemos eliminar algunos bytes llamando a la solución 'a'. Sin embargo, algunas partes también parecen estar relacionadas con la red virtual que creó para EXA. Honestamente, creo que la forma "más justa" de calificar las soluciones EXAPUNKS es usar el recuento de bytes del código real o la cantidad de instrucciones. Esto podría valer una meta publicación ...
ymbirtt
2
@ymbirtt Supongo que la pregunta se reduce a ¿podrías escribir un intérprete que vea las instrucciones y las convierta en los datos guardados? Bueno, trivialmente sí, solo escriba un programa que ingrese para usted desde la fuente ... aunque contaría como un idioma diferente.
Datos
11

Python 2 , 60 bytes

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

Pruébalo en línea!


Explicación:

Primero toma la suma de los primeros nelementos.

Luego, la suma de cada sublista se compara con esta suma. Tan pronto como uno no es más grande, nos detenemos.

Luego se imprime la sublista resultante (la más larga).

TFeld
fuente
2
en realidad el más legible +1
Kryštof Řeháček
10

05AB1E , 14 12 bytes

Guardado 2 bytes gracias a Grimy

.$ΔDOI¹£O›.$

Pruébalo en línea!

Explicación

.$               # 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
fuente
2
'Exactamente' lo mismo que había preparado como solución. Y por "exactamente" quiero decir que el mío era .$.sʒO²¹£O>‹}θ. :)
Kevin Cruijssen
2
@KevinCruijssen aquí está el 12
Grimmy
1
ASCII-only 12 (usando un método de entrada diferente).
Grimmy
1
@ Grimy: ¿Eh? Nunca supe |sobrescribir el last-input, interesante.
Emigna
2
@ Grimy: Mira esto contra esto . Normalmente, cuando se consumen todas las entradas, la última entrada se usa implícitamente para todas las instancias de la siguiente entrada. Usar |aquí hace que el resultado se |convierta en la última entrada en lugar de lo que en realidad fue la última entrada.
Emigna
7

J , 18 bytes

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

Pruébalo en línea!

Explicación:

Un verbo diádico, tomando ncomo argumento izquierdo y L- como argumento derecho.

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

Ruby , 47 43 bytes

norte

-4 bytes leyendo la especificación más de cerca.

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

Pruébalo en línea!

Tinta de valor
fuente
7

R , 53 55 bytes

@Giuseppe me ahorró 2 bytes cambiando la forma en que se realizó la eliminación

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

Pruébalo en línea! Toma la entrada como descendente y las salidas en ascendente según lo permitido por la regla 4.

  • Yes la revolución de Lwith 1: n eliminado usando0:-n
  • vuelve de Ydonde la suma acumulativa es menor que igual a la suma deL[X]
MickyT
fuente
@Giuseppe como siempre gracias. Intenté eliminar el Xuso, -(1:n)pero por supuesto que era del mismo tamaño, así que lo dejé
MickyT
6

JavaScript (ES6), 66 bytes

Toma la entrada como (a)(n)con la lista en orden ascendente.

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

Pruébalo en línea!

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
fuente
1
@KevinCruijssen Parece que leí mal el requisito. Debería arreglarse ahora.
Arnauld
5

Python 2 , 59 bytes

También compatible con Python 3

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

Pruébalo en línea!


Explicación

La suma del sufijo se compara con la mitad de la suma de la lista completa. Si la suma del sufijo es menor o igual, se devuelve el sufijo. Si no, la función se llama recursivamente con el primer elemento del sufijo desplegado.

Jitse
fuente
4

Pyth , 16 15 bytes

efgs>vzQsT._<vz

Pruébalo en línea!

Se espera que la lista de entrada se ordene en orden ascendente, en lugar de descender como se usa en los ejemplos.

Es en momentos como este cuando realmente desearía que Pyth tuviera un solo operador de token para acceder a la segunda entrada más de una vez ( Eevalúa la siguiente línea de entrada, pero las llamadas repetidas descartan la lectura del valor anterior).

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

Editar: guardado 1 byte gracias a MrXcoder

Sok
fuente
@ Mr.Xcoder Dios mío, ¡qué salva obvio! Gracias S
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

Pruébalo en línea!

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
fuente
4

Stax , 12 bytes

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

¡Ejecútelo y depúrelo en staxlang.xyz!

Versión más bonita

Desempaquetado (14 bytes) y explicación:

:/|]{|+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 , puedo dejar este resultado en la pila. Stax intentará una impresión implícita, que podría fallar, pero agregar un archivo mal programa desempaquetado le permite ver la salida muy bien.

Parece que { ... }jes lo mismo que { ... fh. Huh Editar: Ese no es el caso; lo primero se detendrá cuando obtenga un resultado verdadero, posiblemente evitando efectos secundarios o un error fatal más adelante.

Khuldraeseth na'Barya
fuente
3

Japt , 16 bytes

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

Intentalo

£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
Lanudo
fuente
3

Jalea , 13 12 bytes

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

Pruébalo en línea!

¡Gracias a @JonathanAllan por guardar un byte!

Lnorte

Explicació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)
Nick Kennedy
fuente
Puede guardar un byte ordenando en lugar de filtrar:ṫḊÐƤS>¥ÞḣS¥Ḣ
Jonathan Allan
3

Gaia , 12 bytes

eSe¤Σ¤┅⟪Σ⊃⟫∇

Pruébalo en línea!

Creo que hay un byte que puedo jugar al golf si obtengo la pila correcta.

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
fuente
3

Haskell , 46 bytes

Disgustado con cómo se ve esto; Espero que solo me falten algunos campos de golf obvios.

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

Pruébalo en línea!

Intenté obtener el prefijo y el sufijo usando splitAtuna coincidencia de patrones en una protección, pero resultó ser 3 bytes más. Planeando intentar convertir a una función recursiva con guardias más tarde para ver si eso reduce el recuento de bytes.

Explicación

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

A lo que me refiero como "el prefijo" son los primeros nelementos y "el sufijo" es el resto de la lista.

col
fuente
3

APL (Dyalog Unicode) , 23 21 bytes SBCS

norteL

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

Pruébalo en línea!

{}norteL

⌽⍵L

+\ sumas de prefijo de eso

(... )< Máscara booleana donde menos de:

  ⍺↑⍵norteL

  +/ suma esos

⊥⍨contar las verdades finales

⍺⌈norte

⍵↓⍨L

Adán
fuente
1
@KevinCruijssen Muy bien visto. Fijo.
Adám
3

MATL , 13 12 bytes

1 byte guardado gracias a @Giuseppe , basado en la respuesta de @MickyT .

:&)PtYsbs>~)

La salida está en orden ascendente.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere las entradas 2y [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
fuente
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]

Pruébalo en línea!

Toma la lista en orden ascendente, la salida es descendente (porque fue más fácil de comparar con los casos de prueba: ^))

Recorre la lista hacia atrás y hacia adelante, comparando el acumulador con las últimas nentradas agregadas (pegándolas con+ sy pasando la cadena resultante a invoke-expression). El ciclo Hasta necesitaba lógica adicional para manejar el acceso al Barrio Rico porque no se detendría si aún no somos más ricos que los Hombres Ricos hasta que recorramos toda la lista.

Desenrollado:

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
fuente
3

Retina 0.8.2 , 99 bytes

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

(1*),
$.1,
,$

Pruébalo en línea! El enlace solo incluye algunos casos de prueba; Podría hacer que funcione en algunos casos con números negativos a un costo de 12 bytes (en particular, las primeras nentradas Laún deben ser positivas; en teoría, probablemente solo podría requerir que la suma de las primeras nentradas sea positiva). Explicación:

\d+
$*

Convierte a unario.

^
;,

Inserte un marcador al comienzo de L.

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

Muévalo hacia abajo en la lista de ntiempos, sumando a medida que avanzamos. Esto se elimina npero su coma permanece.

,
;$'¶$`,

Cree una entrada para cada sufijo de L.

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

Reemplace el medio con una copia del sufijo.

T`,`_`.*;

Suma la copia del sufijo.

1G`(1+);\1;

Tome la primera entrada donde la suma del sufijo no excede la suma del prefijo.

.*;

Eliminar las sumas.

(1*),
$.1,

Convierte a decimal.

.,$

Elimine la coma final que vino antes n.

Neil
fuente
norte
1
@KevinCruijssen La versión de mi número negativo resultó ser prohibitivamente lenta, pero logré solucionarlo usando la ropción, así que ahora la he vinculado con algunos casos de prueba.
Neil
2

Carbón , 17 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ                 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
fuente
2

PowerShell , 86 bytes

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

Pruébalo en línea!

Desenrollado:

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
}
mazzy
fuente
2

MathGolf , 13 bytes

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

Pruébalo en línea!

Explicación

Toma 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

La razón por la que esto funciona es que en el primer paso, en realidad dividimos la lista en dos partes superpuestas. Como ejemplo, L = [4, 3, 2, 1], n = 2dividirá la lista como [3, 2, 1]y [4, 3]. La razón para tener un elemento adicional en la primera lista es que en el bucle, lo primero que sucede es un descarte. Si no se antepuso un elemento adicional, los casos en los que la salida debería ser el resto de la lista fallarían.

maxb
fuente
2

Wolfram Language (Mathematica) , 40 bytes

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

Pruébalo en línea!

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
fuente
1

Clojure, 66 75 bytes

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

Lamentablemente, no parece haber un modismo más corto para la suma total de una secuencia.

Editar : ¡Oh, cuando agregue ejemplos al Probar en línea! Enlace Noté que la respuesta original daba resultados incorrectos cuando había muchos números negativos.

Los dosequsos "claves" desestructurantes por lo que debe ser algo claro extremos que existen datos en la que el símbolo. #(...)es una función anónima, aquí la estoy vinculando al 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)))

Salida:

(5 3)
(-12)
(20 10 0 -10 -20 -30)
NikoNyrh
fuente
1
¿Te importaría agregar un TIO con código de prueba (veo Clojure en la lista)? Si de alguna manera no es posible (desajuste de versión o uso de incorporados que no están disponibles en TIO), ¿podría incluir una captura de pantalla con algunos de los casos de prueba como verificación de que funciona?
Kevin Cruijssen
1

APL (NARS), 32 caracteres, 64 bytes

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

prueba y comentarios:

  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

Informé erróneamente la longitud del byte ...

RosLuP
fuente
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

Sé que usar una tabla más parecida a una relación para almacenar los datos de entrada puede hacer que el código sea más conciso, pero usando el tipo de datos de caracteres para almacenar la lista numérica y la STRING_SPLITfunción, acorto la Build Schemaparte :)

Versión más legible:

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

Pruébalo en SQL Fiddle !

Andrei Odegov
fuente