Eingang

Zwei Listen Aund Bnichtnegative ganze Zahlen.

Ausgabe

Entweder 1, 0oder -1, je nachdem , ob Agrößer als, gleich oder kleiner ist als Bin Bezug auf die verdrillten lexikographische Ordnung , wie unten definiert. Wenn Sie möchten, können Sie ersetzen 1, 0und -1mit irgendwelchen anderen drei konstanten Werten.

Die verdrehte lexikografische Reihenfolge ist insofern wie die gewöhnliche lexikografische Reihenfolge, als Sie die Listen Element für Element vergleichen und ihre Reihenfolge beim ersten unterschiedlichen Index festlegen. In der verdrehten Version verwenden wir jedoch für jeden Index eine andere Reihenfolge für nichtnegative Ganzzahlen. Bei jedem Index i(Indexierung beginnt bei 1) wird nämlich die Reihenfolge der ersten inichtnegativen Ganzzahlen (von 0bis i-1) umgekehrt, und sie werden über alle anderen Zahlen verschoben. Darüber hinaus wird das "fehlende Element", das anzeigt, dass eine Liste kürzer als die andere ist, direkt darunter verschoben i-1. Visuell ist die Reihenfolge bei Index iist

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

Beachten Sie, dass die erste ...unendlich viele Zahlen bezeichnet. Dies bedeutet, dass die folgenden Listen in Bezug auf die verdrehte lexikografische Reihenfolge in aufsteigender Reihenfolge sind:

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

Regeln

Sie können ein vollständiges Programm oder eine Funktion angeben. Die niedrigste Byteanzahl gewinnt und Standardschlupflöcher sind nicht zulässig.

Testfälle

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*(}?

Ja, es ist immer noch sehr lang ...

Probieren Sie es online aus

Kurze Erklärung:
Der Code gibt 0 aus, wenn die Arrays im herkömmlichen Sinne gleich sind, andernfalls konvertiert er jedes Element jedes Arrays in ein Array mit 2 Elementen: [0 a _i ] wenn a _i > i (0-basiert), [1 was auch immer] wenn ein _i fehlt, und [2 -a _i ] wenn ein _i <= i. Dabei wird das kürzere Array auch auf die größere Größe erweitert. Dann werden die transformierten Arrays lexikographisch verglichen und das Ergebnis auf -1/1 eingestellt.

Python 2, 76 Bytes

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

Dies ersetzt jede Ganzzahl in beiden Listen durch ein 2-Tupel, um die verdrehte Reihenfolge zu berücksichtigen. Das cmpeingebaute Python 2 erledigt den Rest.

Verwendungszweck:

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

Perl, 74

Ohne gute Array-Manipulationsfunktionen ist Perl nicht das optimale Werkzeug für den Job, aber es funktioniert.

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

Teste mich .

J, 95 Bytes

(Nicht super kurz, aber was auch immer. Auf jeden Fall golfbar.)

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

Bestehen aller Testfälle. (Tolles Testfall-Set! Danke!)

Methode:

• Füllen Sie die kürzere Liste mit maxvalue + 1 ( m=.>:>./x,y).(],m$~>&#*-&#
• Transformieren von Listenelementen, damit ein normaler Vergleich verwendet werden kann. (|+(1+m)*0>:*)@(i.@#-~])
• Berechnung von zwei baseX-Zahlen aus der Liste mit ausreichend X. ((m+#x,y)&#.)
• Rückgabe des Signums der beiden Zahlendifferenzen.*@-&

Mathematica, 65

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

Verwendungszweck:

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

-1