Questa è una sfida abbastanza semplice per giocare a golf. Il tuo programma, dato una stringa ASCII, è di analizzare quella stringa in due stringhe, che valuterà. Se la seconda stringa è "successiva" rispetto alla prima, restituirà un 1, se è "precedente" rispetto alla prima, restituirà un -1 e, se sono uguali, restituirà 0. A chiariamo cosa significano "più tardi" e "prima", diamo un'occhiata ai codici dei caratteri ASCII. Devi confrontare ogni carattere della stringa, trattandoli come cifre di un numero. Successivamente si riferisce a un numero più grande, che si verifica dopo un numero più piccolo. Le stringhe verranno formattate con un carattere trattino per separare i due gruppi di input.

Dai un'occhiata a questo esempio:

7-9come input dovrebbe tornare 1.

7converte in codice ASCII 55e 9converte in codice ASCII 57.

Come 57accade numericamente dopo 55, 9è più tardi di 7.

Un altro esempio:

LKzb-LKaj come input dovrebbe tornare -1

Le sequenze di codice ASCII per questo sono 76-75-122-98e76-75-97-106

Questa è una sfida di golf del codice e il conteggio dei byte è il modo in cui verranno segnate le voci.

È accettato qualsiasi input dai 95 caratteri ASCII stampabili, esclusi spazi e trattini per tutto tranne che separare l'input. Inoltre, non è garantito che le stringhe abbiano la stessa lunghezza.

In bocca al lupo!

EDIT: per essere più chiari, ogni personaggio deve essere trattato come una cifra in un numero. Nell'esempio LKzb-LKaj, sebbene jsia più tardi di b, zè più tardi di a, e poiché è una cifra più significativa, ha la precedenza. Una stringa fornita avrà sempre almeno 3 caratteri, eliminando le stringhe vuote dall'ambito di questo problema.

EDIT: ecco alcuni altri casi di test, per il tuo aiuto:

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

Pyth - 11 byte

Facile, usa il ._segno per ottenere il segno e Cper ottenere i codici char.

._-F_CMcz\-

Provalo online qui .

Suite di test .

._               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 byte

l'-/esfb~\-g

Provalo online nell'interprete CJam .

Come funziona

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));}  

Un modo molto strano di confrontare le stringhe. Ha fatto una soluzione rapida in modo da superare ulteriori casi di test, cercherà più golfiness in seguito.

Grazie a Vartan nei commenti per il signumsuggerimento

Perl, 31 byte

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

30 byte + 1 byte per -p. Accetta input su STDIN.

Spiegazione

Quando gli operandi cmphanno lunghezze diverse, come chickene egg, sono allineati in questo modo:

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

in modo che egg> chicken( \0sia un byte null). Ma vogliamo che siano allineati in questo modo:

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

in modo che chicken> egg.

Per fare questo, li concateniamo, una volta con chickenprima egge una volta con eggprima chicken:

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

Ora che le nostre due stringhe hanno la stessa lunghezza, rimuoviamo la parola iniziale usando un XOR per ottenere:

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

E ora possiamo usare cmpper scoprire quale è venuto prima. (Ecco, l'ho detto!)

Python 2, 88 caratteri

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

cmpnon fa la cosa giusta quando hai due stringhe di lunghezza diversa, quindi devo riempirle entrambe con il carattere null (che ordconverte in 0) per gestire quel caso. Sfortunatamente, questo ha aggiunto circa 35 caratteri, in più ora sono due righe anziché una perché ho bisogno sia della lunghezza dell'input che dell'iterazione su di essa.

R, 54 byte

Ciò richiede la libreria pracma. Divide la stringa di input su -. Giusto giustifica le stringhe. Li classifica e fa una differenza.

Quindi per 11-7 finiamo con le stringhe "11" e "7". Il grado di questi è [2, 1]. La differenza è -1. Per 3h ~ J * -3h ~ J * otteniamo "3h ~ J *" e "3h ~ J *". Il grado di questi è [1,5, 1,5] con una differenza di 0.

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

Esempi di test

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

Ecco un jsfiddle con i risultati (guarda nella console)

PERL, 46 36 byte

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

Converte l'elenco argv in una stringa, si divide per il trattino in un arg a sinistra e a destra senza spazi, quindi restituisce una chiamata cmp.

Python 3, 84 byte

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

Dividi l'input della stringa per "-". Converti le stringhe unicode in stringhe di byte, quindi interpreta queste stringhe di byte come numeri interi big-endian. Finalmente fai il confronto - (un) fortunatamente cmpnon è più disponibile in Python 3.

Python 2, 69 byte

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

Python 2, 79 byte

Soluzione piuttosto semplice ed è facile da capire. Confronta le lunghezze delle stringhe, quindi confronta le stringhe in modo lessigrafico.

Provalo qui

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

Eseguilo dalla riga di comando. anche se apparirebbe meglio con una nuova linea ma che costa 1 carattere.

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

Questa versione più lunga gestisce correttamente lunghezze non corrispondenti.

F #, 53

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

Questo è nella forma di una funzione anonima (lambda), quindi devi incollarlo e fornire il parametro direttamente dopo (o, usando la notazione di piping). Ad esempio (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 byte

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

Rubino, 59 byte

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

05AB1E , 12 11 9 byte

'-¡₄ö¥0.S

Provalo online o verifica tutti i casi di test .

Spiegazione:

'-¡          # 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]