Il s'agit d'un défi de golf de code assez simple. Votre programme, étant donné une chaîne ASCII, doit analyser cette chaîne en deux chaînes, qu'il évaluera. Si la deuxième chaîne est "plus tard" que la première, elle renverra un 1, si elle est "plus tôt" que la première, elle renverra un -1, et si elles sont identiques, elle renverra 0. Pour clarifier ce que "plus tard" et "plus tôt" signifient, jetons un coup d'œil aux codes de caractères ASCII. Vous devez comparer chaque caractère de la chaîne, en traitant chacun d'eux comme des chiffres d'un nombre. Plus tard, fait référence à un plus grand nombre, survenant après un plus petit nombre. Les chaînes seront formatées avec un trait d'union pour séparer les deux groupes d'entrée.

Jetez un œil à cet exemple:

7-9comme entrée devrait revenir 1.

7convertit en code ASCII 55et 9convertit en code ASCII 57.

Comme cela 57se produit numériquement après 55, 9est postérieur à 7.

Un autre exemple:

LKzb-LKaj comme entrée devrait retourner -1

Les séquences de code ASCII pour cela sont 76-75-122-98et76-75-97-106

Il s'agit d'un défi de golf de code, et le nombre d'octets est la façon dont les entrées seront notées.

Toute entrée à partir des 95 caractères ASCII imprimables est acceptée, à l'exclusion des espaces et des tirets pour tout sauf la séparation de l'entrée. De plus, les cordes ne sont pas garanties d'avoir la même longueur.

Bonne chance!

EDIT: Pour être plus clair, chaque caractère doit être traité comme un chiffre dans un nombre. Dans l'exemple LKzb-LKaj, bien qu'il jsoit postérieur à b, zest postérieur à a, et puisqu'il s'agit d'un chiffre plus significatif, il a priorité. Une chaîne fournie contiendra toujours au moins 3 caractères, éliminant les chaînes vides de l'étendue de ce problème.

EDIT: Voici quelques cas de test supplémentaires, pour votre aide:

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

Pyth - 11 octets

Facile, utilise le ._signe pour obtenir le signe et Cpour obtenir les codes de caractères.

._-F_CMcz\-

Essayez-le en ligne ici .

Suite de tests .

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

l'-/esfb~\-g

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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

Une façon très étrange de comparer des cordes. A fait une solution rapide pour qu'il passe des cas de test supplémentaires, recherchera plus de golfiness plus tard.

Merci à Vartan dans les commentaires pour la signumsuggestion

Perl, 31 octets

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

30 octets + 1 octet pour -p. Accepte une entrée sur STDIN.

Explication

Lorsque les opérandes cmpont des longueurs différentes, comme chickenet egg, ils sont alignés comme ceci:

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

de sorte que egg> chicken( \0est un octet nul). Mais nous voulons qu'ils soient alignés comme ceci:

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

pour que chicken> egg.

Pour ce faire, nous les concaténons, une fois avec chickenavant egget une fois avec eggavant chicken:

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

Maintenant que nos deux chaînes ont la même longueur, nous supprimons le premier mot en utilisant un XOR pour obtenir:

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

Et maintenant, nous pouvons utiliser cmppour trouver ce qui est arrivé en premier. (Là, je l'ai dit!)

Python 2, 88 caractères

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

cmpne fait pas la bonne chose lorsque vous avez deux chaînes de longueur différente, donc je dois les remplir toutes les deux avec le caractère nul (qui se ordconvertit en 0) pour gérer ce cas. Malheureusement, cela a ajouté environ 35 caractères, et c'est maintenant deux lignes au lieu d'une car j'ai besoin à la fois de la longueur de l'entrée et de l'itérer.

R, 54 octets

Cela nécessite la bibliothèque pracma. Il divise la chaîne d'entrée sur le -. La droite justifie les cordes. Les classe et fait un diff.

Donc pour 11-7 on se retrouve avec les cordes "11" et "7". Le rang de ces derniers est [2, 1]. La différence est -1. Pour 3h ~ J * -3h ~ J * nous obtenons "3h ~ J *" et "3h ~ J *". Le rang de ces derniers est [1,5, 1,5] avec un diff de 0.

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

Exemples de tests

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

Voici un jsfiddle avec les résultats (regardez dans la console)

PERL, 46 36 octets

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

Convertit la liste argv en une chaîne, se divise par le tiret en un argument sans espace sur les côtés gauche et droit, puis renvoie un appel cmp.

Python 3, 84 octets

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

Divisez la chaîne entrée par "-" . Convertissez les chaînes unicode en chaînes d'octets, puis interprétez ces chaînes d'octets comme des entiers big-endian. Enfin, faites la comparaison - (un) heureusement cmpn'est plus disponible dans Python 3.

Python 2, 69 octets

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

Python 2, 79 octets

Solution assez simple et facile à comprendre. Compare les longueurs de chaînes, puis compare les chaînes lexigraphiquement.

Essayez-le ici

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

Il suffit de l'exécuter à partir de la ligne de commande. bien que cela aurait l'air mieux avec une nouvelle ligne, mais cela coûte 1 car.

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

Cette version plus longue gère correctement les longueurs incompatibles.

F #, 53

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

Il s'agit sous la forme d'une fonction anonyme (lambda), vous devez donc la coller et fournir le paramètre directement après is (ou, en utilisant la notation de tuyauterie). Par exemple (en 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 octets

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

Rubis, 59 octets

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

05AB1E , 12 11 9 octets

'-¡₄ö¥0.S

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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