Definizione

Si dice che un vettore a contenente n elementi majorizzi o domini un vettore b con n elementi iff per tutti i valori k tali che 1 ≤ k ≤ n , la somma del primo elemento di un ^↓ attraverso il k esimo elemento di un ^↓ è maggiore pari o uguale alla somma dei primi attraverso i k elementi di b ^↓ , dove v ^↓ rappresenta il vettore v ordinato in ordine decrescente.

Questo è,

                          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

dove un e b sono ordinati in ordine decrescente.

Ai fini di questa sfida, useremo una leggera generalizzazione della maggiorizzazione: diremo che una lista è una maggiorazione non ordinata di un'altra se tutte le disuguaglianze di cui sopra sono vere senza ordinare a e b . (Questo è, ovviamente, matematicamente inutile, ma rende la sfida più interessante.)

Sfida

Dato un input di due distinti elenchi a e b di numeri interi nell'intervallo da 0 a 255 (inclusi), entrambi gli elenchi di lunghezza n ≥ 1, emettono se il primo elenco non ordinato aumenta il secondo ( a > b ), il secondo non ordinato- ingrandisce il primo ( b > a ) o nessuno dei due.

Facoltativamente, potresti richiedere che la lunghezza dei due elenchi sia fornita come input. L'output deve essere sempre uno dei tre valori distinti, ma i valori stessi possono essere qualsiasi cosa tu voglia (specifica quali valori rappresentano a > b , b > a e nessuno dei due nella tua risposta).

Casi di prova per a > b :

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

Casi di prova per b > a :

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

Casi di test per nessuna maggiorazione:

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

2 byte grazie a @orlp.

2 byte grazie a @Dennis.

_+\ṠQS

Provalo online!

1per a>b, -1per a<b, 0per nessuna maggiorizzazione.

_+\ṠQS

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

Se ci fossero entrambi 1e -1presenti (alcune somme cumulative sono maggiori, altre più piccole), l'ultimo passo produrrebbe 0.

ngn / apl, 11 byte

{+/∪×+\⍺-⍵}

Basato sul metodo nella risposta di @Leaky Nun .

Dati due elenchi A e B , la differenza tra ogni elementwise valore, o lasciare che C = A - B . Quindi, trova le somme cumulative di C e prendi il segno di ciascuna. La somma dei valori dei segni univoci sarà il risultato. Se A > B , il risultato è 1, se A < B il risultato è -1 e in assenza della maggioranza il risultato è 0.

Provalo online.

Julia, 30 byte

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

Salvato 4 byte grazie a @Dennis!

Python 3.5, 85 byte:

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

Una funzione lambda anonima. Restituisce [True,False]se a>b, [False,True]se b>ao [False,False]se nessuno dei due è vero. Spero che vada bene.

Provalo online! (Ideone)

Cheddar , 118 114 byte

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]

Fondamentalmente una porta della mia risposta Jelly .

Il fatto che l'ambito all'interno della funzione si rompa causando l'impossibilità di definire una variabile all'interno della funzione significa che avrei bisogno di fare [xxx].map(i->yyy)[0]invece di var a=xxx;yyy.

Accetta l'array trasposto come input.

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 byte

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

Provalo su Ideone .

Rubino, 72 59 byte

Restituisce 1per a>b, -1per a<b, 0per nessuno dei due.

-13 byte dal paralizzare il trucco di somma di @Dennis nella loro risposta Python

Provalo online!

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

Python 2, 59 byte

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

Uscite:

• 1 per a>b
• 2 per b>a
• 3 per nessuno dei due

Scorre l'elenco, monitorando la somma corrente tdelle differenze. Il numero stiene traccia di quali segni sono stati visti come un numero a due bit r: positivi nel bit destro e negativi nel bit sinistro. Questo accade tramite cmp(t,0)%3, il che dà

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

Prendendo il ordi questo e il valore corrente di raggiorna i 2 bit con or, con zero valori senza effetto.

Javascript (utilizzando una libreria esterna enumerabile) (123 byte)

(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 alla lib: https://github.com/mvegh1/Enumerable

Spiegazione del codice: passare il vettore aeb, creare la funzione globale z. z inizierà creando una matrice di numeri interi da 1, per un conteggio di a.length. Tutti verificheranno che il predicato sia vero per ogni membro appartenente a. Quel predicato dice di caricare un come enumerabile, prendere un conteggio di quell'enumerabile equivalente all'attuale valore di iterazione di quell'intervallo che abbiamo creato e sommarlo. Verificare che> = la stessa logica dall'array "b". Quindi, chiamiamo z nell'ordine di (a, b) e lo confrontiamo con l'ordine di (b, a) ... se uguale restituiamo 0 per indicare che non c'è maggiore. Altrimenti, restituiamo 1 se (a, b) è vero, altrimenti -1