Definición

Se dice que un vector a que contiene n elementos para mayorizar o dominar un vector b con n elementos iff para todos los valores k tales que 1 ≤ k ≤ n , la suma del primer elemento de a ^{↓ a} través del k elemento de a ^↓ es mayor que o igual a la suma de los elementos primero a través de k de b ^↓ , donde v ^↓ representa el vector v ordenado en orden descendente.

Es decir,

                          a_1 >= b_1
                    a_1 + a_2 >= b_1 + b_2
              a_1 + a_2 + a_3 >= b_1 + b_2 + b_3
                              ...
      a_1 + a_2 + ... + a_n-1 >= b_1 + b_2 + ... + b_n-1
a_1 + a_2 + ... + a_n-1 + a_n >= b_1 + b_2 + ... + b_n-1 + b_n

donde a y b se ordenan en orden descendente.

A los efectos de este desafío, vamos a utilizar una ligera generalización de mayorización: diremos una lista es una mayorización sin ordenar de otra si todas las desigualdades anteriores son verdaderas sin ordenar una y b . (Esto es, por supuesto, matemáticamente inútil, pero hace que el desafío sea más interesante).

Desafío

Dada una entrada de dos listas distintas a y b de enteros en el rango de 0 a 255 (inclusive), ambas listas de longitud n ≥ 1, muestran si la primera lista sin clasificar-mayoriza la segunda ( a > b ), la segunda sin clasificar- especializa el primero ( b > a ), o ninguno.

Opcionalmente, puede solicitar que se proporcione la longitud de las dos listas como entrada. La salida siempre debe ser uno de tres valores distintos, pero los valores en sí mismos pueden ser lo que desee (especifique qué valores representan a > b , b > a , y ninguno en su respuesta).

Casos de prueba para a > b :

[255] [254]
[3,2,1] [3,1,2]
[6,1,5,2,7] [2,5,4,3,7]

Casos de prueba para b > a :

[9,1] [10,0]
[6,5,4] [7,6,5]
[0,1,1,2,1,2] [0,1,2,1,2,1]

Casos de prueba para no mayorización:

[200,100] [150,250]
[3,1,4] [2,3,3]
[9,9,9,9,9,0] [8,8,8,8,8,9]

Gelatina , 10 8 6 bytes

2 bytes gracias a @orlp.

2 bytes gracias a @Dennis.

_+\ṠQS

Pruébalo en línea!

1para a>b, -1para a<b, 0sin mayorización.

_+\ṠQS

_       Difference (vectorized)
 +\     Cumulative sum.
   Ṡ    Sign of every difference
    Q   Deduplicate
     S  Sum

Si hubiera ambos 1y -1presente (algunas sumas acumulativas son más grandes, otras más pequeñas), entonces el último paso produciría 0.

ngn / apl, 11 bytes

{+/∪×+\⍺-⍵}

Basado en el método en la respuesta de @Leaky Nun .

Dadas dos listas A y B , encontrar la diferencia entre cada valor elementwise, o dejar que C = A - B . Luego, encuentra las sumas acumulativas de C y toma el signo de cada una. La suma de los valores únicos de los signos será el resultado. Si A > B , el resultado es 1, si A < B el resultado es -1, y si no hay mayoría, el resultado es 0.

Pruébalo en línea.

Julia, 30 bytes

a^b=sum(sign(cumsum(a-b))∪0)

¡Guardado 4 bytes gracias a @Dennis!

Python 3.5, 85 bytes:

lambda*e:[all(sum(g[:k])>=sum(h[:k])for k in range(1,-~len(h)))for g,h in[e,e[::-1]]]

Una función lambda anónima. Devuelve [True,False]if a>b, [False,True]if b>ao [False,False]if ninguno de los dos es verdadero. Espero que esté bien.

¡Pruébelo en línea! (Ideona)

Cheddar , 118114 bytes

n->[n.map(i->i[0]-i[1]).map((j,k,l)->l.slice(0,k+1).sum).map(i->i>0?1:i<0?-1:0)].map(j->j has 1?j has-1?0:1:-1)[0]

Básicamente un puerto de mi respuesta Jelly .

El hecho de que el alcance dentro de la función esté roto y no pueda definir una función interna variable significa que tendría que hacerlo en [xxx].map(i->yyy)[0]lugar devar a=xxx;yyy .

Toma la matriz transpuesta como entrada.

n->[n
.map(i->i[0]-i[1])                     Difference (vectorized)
.map((j,k,l)->l.slice(0,k+1).sum)      Cumulative sum.
.map(i->i>0?1:i<0?-1:0)]               Sign of every difference
.map(j->j has 1?j has-1?0:1:-1)[0]     Deduplicate and Sum

Python 2, 73 bytes

a,=b,=r={0}
for x,y in zip(*input()):a+=x;b+=y;r|={cmp(a,b)}
print sum(r)

Pruébelo en Ideone .

Ruby, 72 59 bytes

Devoluciones 1paraa>b , -1para a<b,0 para ninguno.

-13 bytes desde el truco de la suma de @Dennis en su respuesta de Python

Pruébalo en línea!

->a,b{x=y=0;a.zip(b).map{|i,j|(x+=i)<=>y+=j}.uniq.inject:+}

Python 2, 59 bytes

t=r=0
for x,y in zip(*input()):t+=x-y;r|=cmp(t,0)%3
print r

Salidas:

• 1 para a>b
• 2 para b>a
• 3 para ninguno

Itera a través de la lista, rastreando la suma tde diferencias. El número srastrea qué signos se han visto como un número de dos bits r: positivos en el bit derecho y negativos en el bit izquierdo. Esto sucede a través de cmp(t,0)%3, que da

• t>0 → +1 → 1
• t==0 → 0 → 0
• t<0 → -1→ 2

Tomando el orde esto y el valor actual de ractualiza los 2 bits orcon cero valores que no tienen ningún efecto.

Javascript (usando una biblioteca externa enumerable) (123 bytes)

(a,b)=>(z=(c,d)=>_.Range(1,c.length).All(x=>_.From(c).Take(x).Sum()>=_.From(d).Take(x).Sum()))(a,b)==z(b,a)?0:(z(a,b)?1:-1)

Enlace a lib: https://github.com/mvegh1/Enumerable

Explicación del código: Pase el vector ayb, cree la función global z. z comenzará creando una matriz de enteros a partir de 1, para un recuento de a.length. Todos verificarán que el predicado sea verdadero para cada miembro que pertenezca a a. Ese predicado dice que cargue a como enumerable, haga un recuento de ese equivalente enumerable al valor de iteración actual de ese rango que hicimos y sume eso. Compruebe si eso> = la misma lógica de la matriz "b". Entonces, llamamos z en el orden de (a, b), y lo comparamos con el orden de (b, a) ... si es igual, devolvemos 0 para indicar que no hay mayor. De lo contrario, devolvemos 1 si (a, b) es verdadero, de lo contrario -1