这是一个相当简单的高尔夫代码挑战。给定一个ASCII字符串，您的程序将把该字符串解析为两个字符串，它将对其求值。如果第二个字符串比第一个字符串“晚”，则将返回1；如果比第一个字符串“早”，则将返回-1；如果相同，则将返回0。弄清楚“稍后”和“更早”的含义，让我们看一下ASCII字符代码。您需要比较字符串中的每个字符，将每个字符视为一个数字。后来是指较大的数字，出现在较小的数字之后。字符串将使用连字符格式化，以分隔两个输入组。

看一下这个例子：

7-9作为输入应该返回1。

7转换为ASCII代码55，然后9转换为ASCII代码57。

如57数字后所示55，9晚于7。

另一个例子：

LKzb-LKaj 作为输入应该返回 -1

为此的ASCII代码序列是76-75-122-98和76-75-97-106

这是一场高尔夫挑战赛，字节计数是对参赛作品进行评分的方式。

可以接受来自95个可打印ASCII字符的任何输入，但空格和连字符除外，除了分隔输入之外，都可以使用连字符。另外，不能保证字符串的长度相同。

祝好运！

编辑：更清楚地说，每个字符将被视为数字中的数字。在这个例子中LKzb-LKaj，虽然j是迟b，z迟于a，并且由于它是一个更显著的数字，它的优先级。提供的字符串将始终至少包含3个字符，从而从此问题的范围中消除了空字符串。

编辑：这是一些更多的测试用例，为您提供帮助：

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

Pyth-11个字节

容易，使用._sign来获取符号并C获取字符码。

._-F_CMcz\-

在这里在线尝试。

测试套件。

._               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个字节

l'-/esfb~\-g

在CJam解释器中在线尝试。

怎么运行的

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.

爪哇，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));}  

比较字符串的一种非常奇怪的方式。进行了快速修复，使其通过了其他测试用例，以后将寻求更多的高尔夫体验。

感谢Vartan的signum建议

Perl，31个字节

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

30个字节+ 1个字节（用于）-p。接受STDIN上的输入。

说明

当操作数cmp具有不同的长度（如chicken和）时egg，它们的对齐方式如下：

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

因此egg> chicken（\0是一个空字节）。但是我们希望它们像这样对齐：

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

这样chicken> egg。

为此，我们将它们连接在一起，一次用chickenbefore egg和一次用eggbefore chicken：

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

现在我们的两个字符串长度相同，我们使用XOR删除前导词以得到：

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

而现在，我们可以利用cmp查找哪一个先。（在那里，我说了！）

Python 2，88个字符

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

cmp当您使用两个不同长度的字符串时，它做不正确的事情，因此我必须用空字符（ord将其转换为0）填充它们，以处理这种情况。不幸的是，这增加了大约35个字符，加上现在是两行而不是一行，因为我既需要输入的长度，又需要遍历输入的长度。

R，54字节

这需要实用库。它在上分割输入字符串-。右对齐字符串。对它们进行排名并进行比较。

因此，对于11-7，我们最终得到字符串“ 11”和“ 7”。这些的等级是[2，1]。差是-1。对于3h〜J * -3h〜J *，我们得到“ 3h〜J *”和“ 3h〜J *”。它们的等级为[1.5，1.5]，差异为0。

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

测试例

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

这是一个带有结果的jsfiddle（在控制台中查看）

PERL，46 36字节

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

将argv列表转换为字符串，由连字符分隔为左右两侧无空格arg，然后返回cmp调用。

Python 3，84个字节

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

用分割输入的字符串"-"。将unicode字符串转换为字节字符串，然后将这些字节字符串解释为big-endian整数。最后进行比较-（不幸的cmp是）在Python 3中不再可用。

Python 2，69个字节

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

Python 2，79字节

非常简单的解决方案，而且很容易理解。比较字符串长度，然后从字法上比较字符串。

在这里尝试

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

只需从命令行运行即可。虽然换行看起来会更好，但要花1个字符。

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

此较长的版本可以正确处理不匹配的长度。

F＃，53

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

这是匿名函数（lambda）的形式，因此您必须粘贴它并在is之后直接提供参数（或使用管道符号）。例如（在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字节

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

Ruby，59个字节

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

05AB1E，12 11 9 字节

'-¡₄ö¥0.S

在线尝试或验证所有测试用例。

说明：

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