Definição

Diz-se que um vetor a contendo n elementos majoriza ou domina um vetor b com n elementos se todos os valores k são tais que 1 ≤ k ≤ n , a soma do primeiro elemento de a ^↓ através do k ésimo elemento de a ^↓ é maior igual ou igual à soma do primeiro a k de elementos de b ^↓ , em que v ^↓ representa o vetor v classificado em ordem decrescente.

Isso é,

                          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

onde a e b são classificadas em ordem decrescente.

Para o objetivo deste desafio, usaremos uma ligeira generalização da majorização: diremos que uma lista é uma majoração não classificada de outra se todas as desigualdades acima forem verdadeiras sem classificar a e b . (Isso é, obviamente, matematicamente inútil, mas torna o desafio mais interessante.)

Desafio

Dada uma entrada de duas listas distintos um e b de inteiros no intervalo de 0 a 255 (inclusive), ambas as listas de comprimento n ≥ 1, a saída se a primeira lista não classificada-majorizes o segundo ( um > b ), a segunda unsorted- realça o primeiro ( b > a ), ou nenhum.

Opcionalmente, você pode exigir que o comprimento das duas listas seja fornecido como entrada. A saída deve sempre ser um dos três valores distintos, mas os valores em si podem ser o que você quiser (especifique quais valores representam a > b , b > a e nenhum na sua resposta).

Casos de teste para a > b :

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

Casos de teste 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 teste sem majoração:

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

Geléia , 10 8 6 bytes

2 bytes graças a @orlp.

2 bytes graças a @Dennis.

_+\ṠQS

Experimente online!

1para a>b, -1para a<b, 0sem majoração.

_+\ṠQS

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

Se houvesse ambos 1e -1presentes (algumas somas cumulativas são maiores, outras menores), o último passo seria produzido 0.

ngn / apl, 11 bytes

{+/∪×+\⍺-⍵}

Baseado no método da resposta de @Leaky Nun .

Dadas duas listas A e B , encontrar a diferença entre cada elemento a elemento de valor, ou deixá- C = A - B . Em seguida, encontre as somas cumulativas de C e pegue o sinal de cada uma. A soma dos valores de sinal exclusivos será o resultado. Se A > B , o resultado for 1, se A < B, o resultado for -1 e, se não houver maioria, o resultado será 0.

Experimente online.

Julia, 30 bytes

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

Guardado 4 bytes graças 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]]]

Uma função lambda anônima. Retorna [True,False]se a>b, [False,True]se b>aou [False,False]se nenhum deles for verdadeiro. Espero que isso esteja bem.

Experimente Online! (Ideona)

Queijo Cheddar , 118 114 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]

Basicamente, um porto da minha resposta Jelly .

O fato de que a função scope dentro está quebrada, causando a incapacidade de definir a função variável dentro significa que eu precisaria fazer isso em [xxx].map(i->yyy)[0]vez de var a=xxx;yyy.

Leva o array transposto 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)

Teste em Ideone .

Ruby, 72 59 bytes

Retorna 1para a>b, -1para a<b, 0para nenhum.

-13 bytes de deduzir o truque da soma do @Dennis na resposta em Python

Experimente online!

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

Saídas:

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

Repete a lista, acompanhando a soma tdas diferenças. O número srastreia quais sinais foram vistos como um número de dois bits r: positivos no bit direito e negativos no bit esquerdo. Isso acontece via cmp(t,0)%3, o que dá

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

Tirar orisso e o valor atual de ratualiza os 2 bits com or, com valores zero sem efeito.

Javascript (usando a biblioteca externa enumerável) (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)

Link para lib: https://github.com/mvegh1/Enumerable

Explicação do código: Passe no vetor aeb, crie a função global z. z começará criando uma matriz de números inteiros a partir de 1, para uma contagem de a.length. .All verificará se o predicado é verdadeiro para todos os membros pertencentes a a. Esse predicado diz para carregar a como um enumerável, faça uma contagem desse equivalente enumerável ao valor atual da iteração do intervalo que criamos e resuma isso. Verifique se>> é a mesma lógica da matriz "b". Então, chamamos z na ordem de (a, b) e comparamos com a ordem de (b, a) ... se igual, retornamos 0 para significar que não há maior. Caso contrário, retornamos 1 se (a, b) for verdadeiro, caso contrário -1