Este é um desafio bastante simples para o código de golfe. Seu programa, com uma string ASCII, deve analisá-la em duas strings, que serão avaliadas. Se a segunda sequência for "posterior" à primeira, ela retornará 1, se for "anterior" à primeira, retornará -1 e, se forem iguais, retornará 0. Para Para esclarecer o que "mais tarde" e "mais cedo" significam, vamos dar uma olhada nos códigos de caracteres ASCII. Você precisa comparar cada caractere da string, tratando cada um deles como dígitos de um número. Mais tarde refere-se a um número maior, ocorrendo após um número menor. As strings serão formatadas com um caractere hífen para separar os dois grupos de entrada.

Veja este exemplo:

7-9como uma entrada deve retornar 1.

7converte para código ASCII 55e 9converte para código ASCII 57.

Como 57ocorre numericamente depois 55, 9é posterior a 7.

Outro exemplo:

LKzb-LKaj como uma entrada deve retornar -1

As seqüências de código ASCII para isso são 76-75-122-98e76-75-97-106

Este é um desafio de código de golfe e a contagem de bytes é como as entradas serão pontuadas.

Qualquer entrada dos 95 caracteres ASCII imprimíveis é aceita, excluindo espaços e hífens, para separar a entrada. Além disso, não é garantido que as seqüências tenham o mesmo comprimento.

Boa sorte!

EDIT: Para ser mais claro, cada caractere deve ser tratado como um dígito em um número. No exemplo LKzb-LKaj, embora jseja posterior a b, zseja posterior a ae, como é um dígito mais significativo, tem precedência. Uma cadeia fornecida sempre terá no mínimo 3 caracteres, eliminando cadeias vazias do escopo desse problema.

EDIT: Aqui estão mais alguns casos de teste, para sua ajuda:

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

Pitão - 11 bytes

Fácil, usa ._sinal para obter o sinal e Cobter códigos de caracteres.

._-F_CMcz\-

Experimente online aqui .

Conjunto de teste .

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

Experimente on-line no intérprete CJam .

Como funciona

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

Uma maneira muito estranha de comparar strings. Foi feita uma correção rápida para que ele passasse em casos de teste adicionais e procuraria mais golfabilidade posteriormente.

Agradecimentos a Vartan nos comentários para signumsugestões

Perl, 31 bytes

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

30 bytes + 1 byte para -p. Aceita entrada no STDIN.

Explicação

Quando os operandos cmptêm comprimentos diferentes, como chickene egg, eles estão alinhados assim:

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

para que egg> chicken( \0seja um byte nulo). Mas queremos que eles estejam alinhados assim:

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

para que chicken> egg.

Para fazer isso, nós as concatenamos, uma vez com chickenantes egge outra com eggantes chicken:

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

Agora que nossas duas strings têm o mesmo comprimento, removemos a palavra principal usando um XOR para obter:

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

E agora podemos usar cmppara descobrir o que veio primeiro. (Lá, eu disse!)

Python 2, 88 caracteres

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

cmpnão faz a coisa certa quando você tem duas cadeias de comprimento diferentes, então eu tenho que preencher as duas com o caractere nulo (que é ordconvertido em 0) para lidar com esse caso. Infelizmente, isso adicionou cerca de 35 caracteres, e agora são duas linhas em vez de uma, porque eu preciso do comprimento da entrada e da iteração.

R, 54 bytes

Isso requer a biblioteca pracma. Ele divide a string de entrada no -. Direito justifica as cordas. Classifica-os e faz um diff.

Assim, para 11-7, terminamos com as seqüências "11" e "7". A classificação destes é [2, 1]. A diferença é -1. Por 3h ~ J * -3h ~ J *, obtemos "3h ~ J *" e "3h ~ J *". A classificação destes é [1.5, 1.5] com uma diferença de 0.

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

Exemplos de teste

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

Aqui está um jsfiddle com os resultados (veja no console)

PERL, 46 36 bytes

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

Converte a lista argv em uma seqüência de caracteres, divide-se pelo hífen em um espaço à esquerda e à direita sem espaços e, em seguida, retorna uma chamada cmp.

Python 3, 84 bytes

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

Divida a entrada de sequência por "-". Converta as cadeias unicode em cadeias de bytes e interprete essas cadeias de bytes como números inteiros big-endian. Finalmente, faça a comparação - felizmente (des) cmpnão está mais disponível no Python 3.

Python 2, 69 bytes

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

Python 2, 79 bytes

Solução bastante simples e fácil de entender. Compara os comprimentos das strings e compara as strings lexigraficamente.

Experimente aqui

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

Basta executá-lo na linha de comando. embora parecesse melhor com uma nova linha, mas isso custa 1 caractere.

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

Esta versão mais longa lida corretamente com comprimentos incompatíveis.

F #, 53

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

Isso está na forma de uma função anônima (lambda), portanto, você deve colá-lo e fornecer o parâmetro diretamente após is (ou, usando a notação de tubulação). Por exemplo (no 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

Experimente online ou verifique todos os casos de teste .

Explicação:

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