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 y un número (donde es ).
Salida: la posible sufijo sub-lista más larga de para los que la suma total es la suma de los primeros valores en la lista .
Ejemplo:
Entradas: = [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 .
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 valores de la lista ( [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 700
es [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 prefijo no se cuentan para el sufijo de salida. Es decir, las entradas =
[10,5,5,3]
y se traduciría en[5,3]
, y no[5,5,3]
. - I / O es flexible. Puede ingresar 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 =
[-5,-10,-13]
y 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 código de golf , 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]
[131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]
:: pL = [-5,-10,-13]
y quen=2
resultan 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).Respuestas:
C # (compilador interactivo de Visual C #) ,
8881696863 bytes-4 bytes gracias a LiefdeWen
Pruébalo en línea!
fuente
+b
en laSkip
llamada; es redundante verificar la primeran
lista, pero creo que sigue siendo correcta.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
XB
JavaScript para el nivel aquí
fuente
Python 2 , 60 bytes
Pruébalo en línea!
Explicación:
Primero toma la suma de los primeros
n
elementos.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).
fuente
05AB1E ,
1412 bytesGuardado 2 bytes gracias a Grimy
Pruébalo en línea!
Explicación
fuente
.$.sʒO²¹£O>‹}θ
. :)|
sobrescribir ellast-input
, interesante.|
aquí hace que el resultado se|
convierta en la última entrada en lugar de lo que en realidad fue la última entrada.J , 18 bytes
Pruébalo en línea!
Explicación:
Un verbo diádico, tomando
n
como argumento izquierdo yL
- como argumento derecho.fuente
Ruby ,
4743 bytes-4 bytes leyendo la especificación más de cerca.
Pruébalo en línea!
fuente
R , 53
55bytes@Giuseppe me ahorró 2 bytes cambiando la forma en que se realizó la eliminación
Pruébalo en línea! Toma la entrada como descendente y las salidas en ascendente según lo permitido por la regla 4.
Y
es la revolución deL
with 1: n eliminado usando0:-n
Y
donde la suma acumulativa es menor que igual a la suma deL[X]
fuente
X
uso,-(1:n)
pero por supuesto que era del mismo tamaño, así que lo dejéJavaScript (ES6), 66 bytes
Toma la entrada como
(a)(n)
con la lista en orden ascendente.Pruébalo en línea!
Comentado
fuente
Python 2 , 59 bytes
También compatible con Python 3
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.
fuente
Pyth ,
1615 bytesPrué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 (
E
evalúa la siguiente línea de entrada, pero las llamadas repetidas descartan la lectura del valor anterior).Editar: guardado 1 byte gracias a MrXcoder
fuente
JavaScript, 64 bytes
Pruébalo en línea!
fuente
Stax , 12 bytes
¡Ejecútelo y depúrelo en staxlang.xyz!
Versión más bonita
Desempaquetado (14 bytes) y explicación:
Por consenso , puedo dejar este resultado en la pila. Stax intentará una impresión implícita, que podría fallar, pero agregar un archivo
m
al programa desempaquetado le permite ver la salida muy bien.Parece que
{ ... }j
es 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.fuente
APL + WIN, 27 bytes
Solicita la entrada de L y luego n.
Pruébalo en línea! Cortesía de Dyalog Classic.
fuente
Japt , 16 bytes
Intentalo
fuente
Jalea ,
1312 bytesPruébalo en línea!
¡Gracias a @JonathanAllan por guardar un byte!
Explicación
fuente
ṫḊÐƤS>¥ÞḣS¥Ḣ
Gaia , 12 bytes
Pruébalo en línea!
Creo que hay un byte que puedo jugar al golf si obtengo la pila correcta.
fuente
Haskell , 46 bytes
Disgustado con cómo se ve esto; Espero que solo me falten algunos campos de golf obvios.
Pruébalo en línea!
Intenté obtener el prefijo y el sufijo usando
splitAt
una 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
A lo que me refiero como "el prefijo" son los primeros
n
elementos y "el sufijo" es el resto de la lista.fuente
APL (Dyalog Unicode) ,
2321 bytes SBCSPruébalo en línea!
{
}
⍺
⍵
⌽⍵
+\
sumas de prefijo de eso(
...)<
Máscara booleana donde menos de:⍺↑⍵
+/
suma esos⊥⍨
contar las verdades finales⍺⌈
⍵↓⍨
fuente
MATL ,
1312 bytes1 byte guardado gracias a @Giuseppe , basado en la respuesta de @MickyT .
La salida está en orden ascendente.
Pruébalo en línea! O verificar todos los casos de prueba .
Explicación
Considere las entradas
2
y[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]
.fuente
PowerShell ,
9997 bytesPrué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 haciaadelante, comparando el acumulador con las últimasn
entradas agregadas (pegándolas con+
sy pasando la cadena resultante ainvoke-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:
fuente
Retina 0.8.2 , 99 bytes
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
n
entradasL
aún deben ser positivas; en teoría, probablemente solo podría requerir que la suma de las primerasn
entradas sea positiva). Explicación:Convierte a unario.
Inserte un marcador al comienzo de
L
.Muévalo hacia abajo en la lista de
n
tiempos, sumando a medida que avanzamos. Esto se eliminan
pero su coma permanece.Cree una entrada para cada sufijo de
L
.Reemplace el medio con una copia del sufijo.
Suma la copia del sufijo.
Tome la primera entrada donde la suma del sufijo no excede la suma del prefijo.
Eliminar las sumas.
Convierte a decimal.
Elimine la coma final que vino antes
n
.fuente
r
opción, así que ahora la he vinculado con algunos casos de prueba.Carbón , 17 bytes
Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:
fuente
Rojo , 63 bytes
Pruébalo en línea!
fuente
PowerShell , 86 bytes
Pruébalo en línea!
Desenrollado:
fuente
MathGolf , 13 bytes
Pruébalo en línea!
Explicación
Toma entrada como
n L
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 = 2
dividirá 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.fuente
Wolfram Language (Mathematica) , 40 bytes
Pruébalo en línea!
fuente
Clojure,
6675 bytesLamentablemente, 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
doseq
usos "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ímbolof
:Salida:
fuente
APL (NARS), 32 caracteres, 64 bytes
prueba y comentarios:
Informé erróneamente la longitud del byte ...
fuente
MS SQL Server 2017 , 271 bytes
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_SPLIT
función, acorto laBuild Schema
parte :)Versión más legible:
Pruébalo en SQL Fiddle !
fuente
Python 3.8 (prelanzamiento) , 59 bytes
La salida está en orden ascendente
Pruébalo en línea!
fuente