Contribution

Deux listes Aet Bd'entiers non négatifs.

Production

Ou bien 1, 0ou -1, selon qu'il Aest supérieur à, égal à, ou plus petit que Bpar rapport à l' ordre lexicographique torsadé tel que défini ci - dessous. Si vous le souhaitez, vous pouvez remplacer 1, 0et -1par trois autres valeurs constantes.

L'ordre lexicographique tordu est semblable à l'ordre lexicographique ordinaire, en ce sens que vous comparez les listes élément par élément et décidez de leur ordre au premier indice différent. Cependant, dans la version torsadée, nous utilisons un ordre différent pour les entiers non négatifs à chaque index. À savoir, à chaque index i(l'indexation commence à partir de 1), l'ordre des premiers ientiers non négatifs (de 0à i-1) est inversé, et ils sont déplacés au-dessus de tous les autres nombres. De plus, "l'élément manquant" qui signifie qu'une liste est plus courte que l'autre est déplacé directement en dessous i-1. Visuellement, l'ordre à l'index iest

i < i+1 < i+2 < i+3 < ... < [missing element] < i-1 < i-2 < i-3 < ... < 2 < 1 < 0

Notez que le premier ...désigne une infinité de nombres. Cela signifie que les listes suivantes sont en ordre croissant par rapport à l'ordre lexicographique tordu:

[3,2,3,4]
[3,2,3,5]
[3,2,3,10]
[3,2,3,1341]
[3,2,3]
[3,2,3,3]
[3,2,3,2]
[3,2,3,1]
[3,2,3,0]

Règles

Vous pouvez donner un programme complet ou une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Cas de test

Output 1:
[0] []
[] [1]
[] [1,2,1,2]
[2,1] [1,1]
[0,1,2] [0,2,1]
[3,0] [3,1]
[3,1] [3]
[2] [2,2]
[2] [2,23]
[2,24] [2,23]
[2,1] [2,23]

Output 0:
[] []
[0] [0]
[1,1] [1,1]
[2,1,2] [2,1,2]

Output -1:
[1,2,1,1,2] [1,2,1,1,1]
[1,2,1,1,5] [1,2,1,1,4]
[1,2,1,1,5] [1,2,1,1]
[1,2,1] [1,2,1,1]
[1,2,1,1,5] [1,2,1,1,6]
[1,2,1,1,6] [1,2,1,1,7]

CJam - 57

q:S~=0{S~]:A:,~e>{A{_,I>{I=_I>0{W*2}?}1?[\]}%}fI]z~>2*(}?

Ouais c'est encore très long ...

Essayez-le en ligne

Brève explication:
Le code génère 0 si les tableaux sont égaux au sens traditionnel, sinon il convertit chaque élément de chaque tableau en un tableau à 2 éléments: [0 a _i ] si a _i > i (basé sur 0), [1 quel que soit] si a _i est manquant, et [2 -a _i ] si a _i <= i. Dans le processus, le tableau le plus court est également étendu à la plus grande taille. Ensuite, les tableaux transformés sont comparés lexicographiquement et le résultat est ajusté à -1/1.

Python 2, 76 octets

c=lambda*a:cmp(*[[(max(i-x,-1),x)for i,x in enumerate(L)]+[(0,)]for L in a])

Cela remplace chaque entier dans les deux listes par un tuple 2 pour tenir compte de l'ordre tordu. La fonction cmpintégrée de Python 2 fait le reste.

Usage:

>>> c([1,2,1,1,6], [1,2,1,1,7])
-1

Perl, 74

Sans de bonnes fonctions de manipulation de tableaux, Perl n'est pas l'outil optimal pour le travail, mais il fonctionne.

#!perl -pa
$i=0,s/\d+,?/$s=sprintf"%9d",$&;$&>$i++?$s:~$s/ge for@F;$_=$F[0]cmp$F[1]

Testez- moi .

J, 95 octets

(Pas super court mais peu importe. Certainement jouable au golf.)

f=.4 :0
m=.>:>./x,y
t=.(|+(1+m)*0>:*)@(i.@#-~])@(],m$~>&#*-&#)
x(t~(*@-&((m+#x,y)&#.))t)y
)

Passer tous les cas de test. (Grand jeu de cas de test! Merci!)

Méthode:

• Remplissage de la liste plus courte avec maxvalue + 1 ( m=.>:>./x,y).(],m$~>&#*-&#
• Transformer les éléments de la liste afin de pouvoir utiliser une comparaison normale. (|+(1+m)*0>:*)@(i.@#-~])
• Calcul de deux nombres baseX à partir de la liste de deux avec suffisamment de X. ((m+#x,y)&#.)
• Retour du signe de la différence des deux nombres.*@-&

Mathematica, 65

f=-Order@@MapIndexed[If[#>Last@#2,#,a-b#]&,PadRight[{##}+1],{2}]&

Usage:

f[{1, 2, 1, 1, 6}, {1, 2, 1, 1, 7}]

-1