Dies ist eine ziemlich einfache Code-Golf-Herausforderung. Ihr Programm besteht bei einer ASCII-Zeichenfolge darin, diese Zeichenfolge in zwei Zeichenfolgen zu analysieren, die ausgewertet werden. Wenn die zweite Zeichenfolge "später" als die erste ist, gibt sie eine 1 zurück, wenn sie "früher" als die erste ist, gibt sie eine -1 zurück, und wenn sie gleich sind, gibt sie 0 zurück Um zu klären, was "später" und "früher" bedeuten, werfen wir einen Blick auf die ASCII-Zeichencodes. Sie müssen jedes Zeichen der Zeichenfolge vergleichen und jedes Zeichen als Ziffern einer Zahl behandeln. Später bezieht sich auf eine größere Zahl, die nach einer kleineren Zahl auftritt. Zeichenfolgen werden mit einem Bindestrich formatiert, um die beiden Eingabegruppen zu trennen.

Schauen Sie sich dieses Beispiel an:

7-9als Eingabe sollte zurückkehren 1.

7Konvertiert in ASCII-Code 55und 9konvertiert in ASCII-Code 57.

Wie 57numerisch danach auftritt 55, 9ist später als 7.

Ein anderes Beispiel:

LKzb-LKaj als Eingabe sollte zurückkehren -1

Die ASCII-Codesequenzen hierfür sind 76-75-122-98und76-75-97-106

Dies ist eine Code-Golf-Herausforderung, und bei der Anzahl der Bytes werden die Einträge bewertet.

Jede Eingabe von 95 druckbaren ASCII-Zeichen wird akzeptiert, ausgenommen Leerzeichen und Bindestriche, die die Eingabe nur trennen. Außerdem ist nicht garantiert, dass die Zeichenfolgen dieselbe Länge haben.

Viel Glück!

BEARBEITEN: Um klarer zu sein, muss jedes Zeichen wie eine Ziffer in einer Zahl behandelt werden. In dem Beispiel LKzb-LKaj, wenn auch jspäter als b, zspäter als a, und da es sich um eine höherwertige Stelle ist, hat es Vorrang. Eine angegebene Zeichenfolge besteht immer aus mindestens 3 Zeichen, wodurch leere Zeichenfolgen aus dem Umfang dieses Problems ausgeschlossen werden.

EDIT: Hier sind einige weitere Testfälle für Ihre Hilfe:

• A-9 -> -1
• 11-Z -> -1
• 3h~J*-3h~J* -> 0
• Xv-Y0 -> 1

Pyth - 11 Bytes

Einfach, verwendet ._Zeichen, um das Zeichen Czu erhalten und Zeichencodes zu erhalten.

._-F_CMcz\-

Probieren Sie es hier online aus .

Testsuite .

._               Sign of number
 -F              Fold subtraction (this finds difference of a tuple)
  _              Reverse list to get correct order of operands when subtracting
   CM            Map char, already treats strings as digits of base256 number
    c \-         Split by "-"
     z           Input

CJam, 12 Bytes

l'-/esfb~\-g

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

l   e# Read a line from STDIN.
'-/ e# Split it at spaces.
es  e# Push the current time (milliseconds since epoch).
fb  e# Consider each string as digits in base huge-number.
~\  e# Dump the results and reverse their order.
-g  e# Subtract and apply sign function.

Java, 86 118

int f(String...s){return(int)Math.signum((s=s[0].split("-"))[1].compareTo(s[0])*(s[0].length()==s[1].length()?1:-1));}  

Eine sehr seltsame Art, Strings zu vergleichen. Eine schnelle Lösung, die zusätzliche Testfälle besteht, wird später nach mehr Golfigkeit suchen.

Vielen Dank an Vartan in den Kommentaren für den signumVorschlag

Perl, 31 Bytes

#!/usr/bin/perl -p
/-/;$_=($`.$'^$`)cmp($'.$`^$')

30 Bytes + 1 Byte für -p. Akzeptiert Eingaben auf STDIN.

Erläuterung

Wenn die Operanden cmpunterschiedliche Längen haben, wie chickenund egg, werden sie wie folgt ausgerichtet:

c  h  i  c  k  e  n
e  g  g  \0 \0 \0 \0

so dass egg> chicken( \0ist ein Null-Byte). Aber wir möchten, dass sie so ausgerichtet werden:

c  h  i  c  k  e  n
\0 \0 \0 \0 e  g  g

so dass chicken> egg.

Dazu verketten wir sie einmal mit chickenvorher eggund einmal mit eggvorher chicken:

c  h  i  c  k  e  n  e  g  g
e  g  g  c  h  i  c  k  e  n

Nachdem unsere beiden Zeichenfolgen gleich lang sind, entfernen wir das führende Wort mit einem XOR, um Folgendes zu erhalten:

\0 \0 \0 \0 \0 \0 \0 e  g  g
\0 \0 \0 c  h  i  c  k  e  n

Und jetzt können wir cmpherausfinden, was zuerst kam. (Dort habe ich es gesagt!)

Python 2, 88 Zeichen

a=raw_input().split('-');print-cmp(*(map(ord,s.rjust(max(map(len,a)),'\0'))for s in a))

cmpWenn Sie zwei Zeichenfolgen unterschiedlicher Länge haben, ist dies nicht das Richtige. Daher muss ich beide mit dem Nullzeichen (das in ordkonvertiert wird 0) auffüllen, um diesen Fall zu behandeln. Leider wurden dadurch etwa 35 Zeichen hinzugefügt, und es sind jetzt zwei Zeilen anstelle von einer, da ich sowohl die Länge der Eingabe als auch die Iteration darüber benötige.

R, 54 Bytes

Dies erfordert die Pracma-Bibliothek. Es teilt die Eingabezeichenfolge auf der -. Rechts rechtfertigt die Zeichenfolgen. Rang sie und macht einen Unterschied.

Für 11-7 erhalten wir also die Zeichenfolgen "11" und "7". Der Rang von diesen ist [2, 1]. Der Unterschied beträgt -1. Für 3h ~ J * -3h ~ J * erhalten wir "3h ~ J *" und "3h ~ J *". Der Rang von diesen ist [1,5, 1,5] mit einem Unterschied von 0.

diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))

Testbeispiele

> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: LKzb-LKaj
3: 
Read 2 items
[1] -1
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: A-9
3: 
Read 2 items
[1] -1
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: 11-Z
3: 
Read 2 items
[1] -1
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: 3h~J*-3h~J*
3: 
Read 2 items
[1] 0
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: Xv-Y0
3: 
Read 2 items
[1] 1

CoffeeScript, 143 140 139

f=(s)->[a,b]=((t=s.split '-').map (y)->Array((m=Math.max) 1, 1+(m ((l=(c)->c.length) t[0]),l t[1])-l y).join('\u0000')+y);`b<a?-1:(b>a?1:0)`

Hier ist eine jsfiddle mit den Ergebnissen (siehe in der Konsole)

PERL, 46 36 Bytes

print$2cmp$1if"@ARGV"=~/(\S+)-(\S+)/

Konvertiert die argv-Liste in eine Zeichenfolge, teilt sie durch den Bindestrich in ein links- und rechtsseitiges Argument ohne Leerzeichen auf und gibt dann einen cmp-Aufruf zurück.

Python 3, 84 Bytes

x,y=[int.from_bytes(i.encode(),"big")for i in input().split("-")];print((x<y)-(y<x))

Teilen Sie die eingegebene Zeichenfolge durch "-". Konvertieren Sie die Unicode-Zeichenfolgen in Byte-Zeichenfolgen und interpretieren Sie diese Byte-Zeichenfolgen als Big-Endian-Ganzzahlen. Führen Sie zum Schluss den Vergleich durch - (un) ist zum Glück cmpin Python 3 nicht mehr verfügbar.

Python 2, 69 Bytes

print -cmp(*[int(i.encode("hex"),16)for i in raw_input().split("-")]) 

Python 2, 79 Bytes

Ziemlich einfache Lösung und leicht zu verstehen. Vergleicht die Zeichenfolgenlängen und vergleicht die Zeichenfolgen dann lexigraphisch.

Probieren Sie es hier aus

s,t=raw_input().split('-')
x,y=len(s),len(t)
print(x<y)*2-1if x-y else cmp(t,s)

perl5, 64

perl -aF- -pe '@f=map{length}@F;$_=$f[1]<=>$f[0]||$F[1]cmp$F[0]'

Führen Sie es einfach über die Befehlszeile aus. mit einer neuen linie würde es zwar besser aussehen aber das kostet 1 char.

perl -laF- -pe '@f=map{length}@F;$_=$f[1]<=>$f[0]||$F[1]cmp$F[0]'

Diese längere Version behandelt nicht übereinstimmende Längen korrekt.

F #, 53

fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a

Dies ist in der Form eine anonyme Funktion (Lambda), daher müssen Sie sie einfügen und den Parameter direkt nach is (oder unter Verwendung der Piping-Notation) angeben. Zum Beispiel (in FSI):

> "7-9" |> fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a
1
> "abc-abc" |> fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a
0
> "LKzb-LKaj" |> fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a
-1

JavaScript ES6, 46 43 Bytes

f=s=>((a=s.split('-'))[1]>a[0])-(a[1]<a[0])

Ruby, 59 Bytes

a,b=gets.chomp.split ?-
p (b.size<=>a.size).nonzero?||b<=>a

05AB1E , 12 11 9 Bytes

'-¡₄ö¥0.S

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

'-¡          # Split the (implicit) input on '-'
             #  i.e. 'LKzb-LKaj' → ['LKzb','LKaj']
   ₄ö        # Convert both parts to a Base-1000 number
             #  i.e. ['LKzb','LKaj'] → [21020061037,21020036045]
     ¥       # Push the deltas (subtraction between each sub sequential pair) of the list
             #  i.e. [21020061037,21020036045] → [-24992]
      0.S    # Get the sign [1 for a>0; -1 for a<0; 0 for a==0] (and output implicitly)
             #  i.e. [-24992] → [-1]