Définition

On dit qu'un vecteur a contenant n éléments majorise ou domine un vecteur b avec n éléments ssi pour toutes les valeurs k telles que 1 ≤ k ≤ n , la somme du premier élément de a ^↓ jusqu'au k ème élément de a ^↓ est plus grande supérieur ou égal à la somme des premier à k ème éléments de b ^↓ , où v ^↓ représente le vecteur v trié par ordre décroissant.

C'est,

                          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

où a et b sont triés par ordre décroissant.

Aux fins de ce défi, nous utiliserons une légère généralisation de la majoration: nous dirons qu'une liste est une majoration non triée d'une autre si toutes les inégalités ci-dessus sont vraies sans trier a et b . (Ceci est, bien sûr, mathématiquement inutile, mais rend le défi plus intéressant.)

Défi

Étant donné une entrée de deux listes distinctes a et b d'entiers compris entre 0 et 255 (inclus), les deux listes de longueur n ≥ 1, indiquent si la première liste non triée-majorise la seconde ( a > b ), la seconde non triée- majorise le premier ( b > a ), ou aucun.

Vous pouvez éventuellement demander que la longueur des deux listes soit fournie en entrée. La sortie doit toujours être l'une des trois valeurs distinctes, mais les valeurs elles-mêmes peuvent être ce que vous voulez (veuillez spécifier quelles valeurs représentent a > b , b > a , et aucune dans votre réponse).

Cas de test pour a > b :

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

Cas de test pour b > a :

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

Cas de test sans majoration:

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

Gelée , 10 8 6 octets

2 octets grâce à @orlp.

2 octets grâce à @Dennis.

_+\ṠQS

Essayez-le en ligne!

1pour a>b, -1pour a<b, 0pour aucune majoration.

_+\ṠQS

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

S'il y avait à la fois 1et -1présent (certaines sommes cumulées sont plus grandes, d'autres plus petites), alors la dernière étape produirait 0.

ngn / apl, 11 octets

{+/∪×+\⍺-⍵}

Basé sur la méthode de @Leaky Nun's réponse de .

Compte tenu de deux listes A et B , trouver la différence entre chaque valeur par éléments, ou encore C = A - B . Ensuite, trouvez les sommes cumulées de C et prenez le signe de chacune. La somme des valeurs de signe unique sera le résultat. Si A > B , le résultat est 1, si A < B le résultat est -1, et s'il n'y a pas de majorité, le résultat est 0.

Essayez-le en ligne.

Julia, 30 octets

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

4 octets enregistrés grâce à @Dennis!

Python 3.5, 85 octets:

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

Une fonction lambda anonyme. Retour[True,False] si a>b, [False,True]si b>aou [False,False]si aucun de ces deux éléments n'est vrai. J'espère que ça va.

Essayez-le en ligne! (Ideone)

Cheddar , 118 octets

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]

Fondamentalement, un port de ma réponse Jelly .

Le fait que la portée à l'intérieur de la fonction soit brisée entraînant l'impossibilité de définir une variable à l'intérieur de la fonction signifie que je devrais faire [xxx].map(i->yyy)[0] au lieu devar a=xxx;yyy .

Prend le tableau transposé en entrée.

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 octets

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

Testez-le sur Ideone .

Rubis, 72 59 octets

Renvoie 1pour a>b, -1pour a<b, 0pour aucun.

-13 octets provenant de la suppression de la somme de @Dennis dans leur réponse Python

Essayez-le en ligne!

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

Python 2, 59 octets

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

Les sorties:

• 1 pour a>b
• 2 pour b>a
• 3 pour ni l'un ni l'autre

Itère dans la liste, en suivant la somme cumulée tdes différences. Le nombre ssuit les signes qui ont été considérés comme un nombre à deux bits r: positifs dans le bit de droite et négatifs dans le bit de gauche. Cela se produit via cmp(t,0)%3, ce qui donne

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

La prise orde ceci et la valeur actuelle de rmet à jour les 2 bits avec or, les valeurs nulles n'ayant aucun effet.

Javascript (en utilisant une bibliothèque externe-Enumerable) (123 octets)

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

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication du code: passez les vecteurs a et b, créez la fonction globale z. z commencera par créer un tableau d'entiers à partir de 1, pour un compte de a.length. Tout vérifiera que le prédicat est vrai pour chaque membre appartenant à a. Ce prédicat dit de charger un en tant qu'énumérable, de prendre un compte de cet équivalent énumérable à la valeur d'itération actuelle de cette plage que nous avons créée, et de résumer cela. Vérifiez si> = la même logique du tableau "b". Donc, nous appelons z dans l'ordre de (a, b), et comparons cela à l'ordre de (b, a) ... si égal, nous retournons 0 pour signifier qu'il n'y a pas de majeur. Sinon, nous retournons 1 si (a, b) est vrai, sinon -1