Instructions

Étant donné une chaîne d'entrée inconnue iavec une valeur de têtes ou de queues , retournez 1pour les têtes ou -1pour les queues avec le code le plus court.

Exemple de code non golfé (55b):

if(i == "heads"){
    print(1);
}else{
    print(-1);
}

Exemple de code golfé (16b):

print("t">i||-1)

CJam, 4 octets

I'e#

Suppose que la variable Icontient l'entrée, car in'est pas un identifiant valide dans CJam.

Essayez-le en ligne.

C'est équivalent au code JavaScript I.indexOf('e').

C, 18 octets

Assez facile, mais faisons-le juste pour le plaisir ...

puts("-1"+*i/8%2);

Étant donné la chaîne, char *iil affiche 1 pour headset -1 pour tails, avec une nouvelle ligne de fin.

Explication

En C, "-1" + 1pointe vers 1 caractère vers l'avant, c'est donc la même chose que "1". Jetons un coup d'œil aux premiers personnages:

"heads"[0] = 'h' = 104 = 0b01101000
"tails"[0] = 't' = 116 = 0b01110100

Si nous comptons les bits du plus à droite commençant à zéro, le bit 3 est 1 in headset 0 in tails: en le sommant pour "-1"donner la bonne chaîne. Cela ressemble à ceci:

"-1" + ((i[0] >> 3) & 1)

Maintenant, remplacez i[0]par *iet le décalage à droite par la division de la puissance de deux pour économiser quelques octets. Supprimez également les parenthèses inutiles:

"-1" + (*i / 8 & 1)

Maintenant, & 1peut être remplacé par % 2. Le nombre de caractères est le même, mais le module a une priorité plus élevée, ce qui permet de supprimer les parenthèses. Supprimez l'espace blanc:

"-1"+*i/8%2

Prime

Je pense que le moyen le plus court pour obtenir un entier 1 ou -1 (pas une chaîne) en C est:

18-*i/6

Explication:

'h' = 104
't' = 116

('h' + 't') / 2 = 110
110 - 'h' =  6
110 - 't' = -6

(110 - 'h') / 6 =  1
(110 - 't') / 6 = -1

Apply distributive property (integer division):
18 - 'h' / 6 =  1
18 - 't' / 6 = -1

Ruby, 8 (6 sans sortie)

p ?t<=>i

Opérateur de fusée!

PHP - 11 octets

<?=1-$i^=F;

Cela fonctionne parce que 'tails' ^ 'F'→ '2'et 'heads' ^ 'F'→ '.', qui, lorsqu'ils sont saisis comme un entier, le sont 0.

Vous pouvez tester cette solution (ou l'une des solutions ci-dessous) de la manière suivante:

<?php foreach(['heads', 'tails'] as $i): ?>
 <?=1-$i^=F;
endforeach; ?>

Lien Ideone

Alternatives

15 : <?=1-md5($i)%3;
16 : <?=md5($i)[5]-5;
16 :<?=-crc32($i)%5;

TI-BASIC, 9-10 octets

cos(πʳinString(Ans,"t

Simple. "t" est en position 1 de "queues", mais "t" n'est pas dans la chaîne "têtes", donc inString (renvoie 1 pour les queues et 0 pour les têtes.

Si votre calculatrice est en mode radian (comme tout mathématicien devrait l'être), cela ne prend que neuf octets:

cos(πinString(Ans,"t

Notez que les calculatrices TI n'ont pas de chaînes nommées, donc l'entrée est dans la variable de réponse de la calculatrice. Notez également que les lettres minuscules sont de deux octets chacune, donc cette solution prend en fait moins de mémoire que le mot "têtes".

Fission , 26 21 octets

O/';'1
"S@]_"-
R? <tL

Martin (et son excellente réponse ici ) m'a convaincu d'apprendre une nouvelle langue, et quel meilleur endroit qu'un golf rapide? Ce n'est certainement pas optimal, mais bon, c'était amusant! Une fois que je me sens bien à ce sujet, je peux fournir une certaine forme d'explication si elle est demandée.

Python 2, 16 octets

print(i<'t')*2-1

Pyth - 4 octets

 xz"e

Courez avec des têtes ou des queues . Comme iest inten Pyth, celui - ci utilise zcomme nom de variable, qui contient des entrées d'utilisateur. Il est équivalent au Python print(z.find("e")), utilise donc la méthode de @ Dennis.

VBA (Excel), 12 octets

Pas un peu fantastique de golf, mais c'est amusant d'essayer avec VBA pour se rapprocher d'un langage de programmation approprié ...

?13-asc(i)/6

i est la chaîne, et elle exploite simplement la valeur ASCII du premier caractère, divisée par 6 et soustraite de 13 pour donner 1 ou -1. Très simple.

Exemple exécuté dans une fenêtre immédiate (10 octets supplémentaires pour définir la variable d'entrée):

i="Heads":?13-asc(i)/6
 1

C, 22 octets

puts(*i>'h'?"-1":"1");

^{_{Les crédits vont à @TheE pour m'en parler !}}

Explication:

Si le premier caractère de la chaîne est supérieur à 'h', la chaîne "-1"est imprimée. Sinon, la chaîne "1"est imprimée. Notez que cette approche est accompagnée d'un caractère de fin de ligne.

Ancienne version (25 octets):

printf("%d",*i>'h'?-1:1);

Explication:

Si le premier caractère de la chaîne est supérieur à 'h', -1 est imprimé. Sinon, 1 est imprimé.

Tr: 17 13 caractères

(Ou 14 10 si vous ne comptez que les arguments…)

tr -s ta-s -1

Exemple d'exécution:

bash-4.3$ tr -s ta-s -1 <<< heads
1

bash-4.3$ tr -s ta-s -1 <<< tails
-1

Brève explication:

tr signifie translittéré, cela signifie, remplace chaque caractère de l'entrée trouvée dans le premier argument par un caractère à la même position dans le deuxième argument:

tr ta -1 <<< tails         # replaces t ⇢ -, a → 1
⇒ -1ils

Si le premier argument est plus long, les caractères sans correspondance de position dans le deuxième argument sont remplacés par le dernier caractère du deuxième argument:

tr tals -1 <<< tails       # replaces t ⇢ -, a → 1, l → 1, s → 1
⇒ -1i11

Lorsque l' option -s( --squeeze-repeats) est utilisée, les caractères successifs qui seraient remplacés par le même caractère sont remplacés à la fois:

tr -s tals -1 <<< tails    # replaces t ⇢ -, a → 1, l+s → 1
⇒ -1i1

Donc, si nous énumérons tous les caractères dans «queues», nous obtenons ce dont nous avons besoin:

tr -s tails -1 <<< tails    # replaces t ⇢ -, a+i+l+s → 1
⇒ -1

Idem pour les «têtes», mais nous devons tout de même garder le «t» devant pour consommer le moins (caractères triés alphabétiquement pour la chair de poule):

tr -s taedhs -1 <<< heads   # replaces h+e+a+d+s → 1
⇒ 1

La fusion de tous les caractères uniques de "queues" et de "têtes" dans un seul premier argument, en gardant "t" devant conduit à la solution finale:

tr -s tadehils -1 <<< tails # replaces t → -, a+i+l+s → 1
⇒ -1

tr -s tadehils -1 <<< heads # replaces h+e+a+d+s → 1
⇒ 1

Pour éviter d'énumérer les caractères, un intervalle au format de - à peut être utilisé à la place.

Assemblage 8088, IBM PC DOS, 17 octets

00000000: b402 0826 8200 7a04 b22d cd21 b231 cd21  ...&..z..-.!.1.!
00000010: c3

Non assemblé:

B4 02           MOV  AH, 02H        ; DOS API display char function     
08 26 0082      OR   DS:[82H], AH   ; set parity flag from input 
7A 04           JPE  HEADS          ; if even, heads - display just '1'
B2 2D           MOV  DL, '-'        ; otherwise first display a '-''
CD 21           INT  21H            ; output DL to console
            HEADS: 
B2 31           MOV  DL, '1'        ; display the '1'
CD 21           INT  21H            ; output DL to console
C3              RET

Explication:

Utilisez l'indicateur de parité du processeur pour déterminer si le premier caractère est un 'h'(nombre pair de binaires 1) ou un 't'(nombre impair de binaires 1). Cela économise un octet par rapport à la comparaison du caractère en ASCII.

Entrée depuis la ligne de commande, sortie vers la console.

Entrée sortie:

Japt , 2 octets

ae

Essayez-le en ligne

shell (portable / POSIX), 16 octets

expr $i : he - 1

Essayez-le en ligne!
Merci à @ StéphaneChazelas dans unix.stackexchange.com

Autres solutions essayées:
echo $[30#$i%7-1] # 17 bytes but only in bash, zsh. essayez-le en ligne!
echo $((30#$i%7-1)) # 19 bytes but only bash,ksh,zsh. Essayez-le en ligne!
he=2;echo $[${i%a*}-1] # 22 bytes But only in bash,zsh . Essayez-le en ligne!
a=${i%h*};echo ${a:+-}1 # 23 . portable. Essayez-le en ligne!
he=2;echo $((${i%a*}-1)) # 24 bytes . portable. Essayez-le en ligne!
IFS=h;set $i;echo ${1:+-}1 # 26 (change IFS) . portable. Essayez-le en ligne!
(IFS=h;set $i;echo ${1:+-}1) # 28 (subshell) . portable. Essayez-le en ligne!
(IFS=h;set $i;echo $(($#*2-3))) # 31 bytes . portable. Essayez-le en ligne!

Remarque: Utilisation dashcomme comparaison raisonnable d'un testeur de coque portable.

• expr $i : he - 1fonctionne en comptant le nombre de caractères correspondent heavec $i : he. Une headscorrespondance 2et une tailscorrespondance 0 (aucune). Puis soustraire 1avec - 1.

• $[30#$i%7-1]fonctionne en convertissant la chaîne en un entier. La base 30 et le mod par 7 ont été sélectionnés pour obtenir une différence de 2 entre headset tails. Ensuite, soustraire 1 convertit les nombres en 1et -1.
  Notez que a $[...]est une forme archaïque d'expression arithmétique $((...))valable uniquement dans certains shells.

• he=2;echo $[${i%a*}-1]fonctionne en créant une variable d'une certaine valeur, puis en utilisant l'expansion arithmétique pour développer cette variable (à partir de la valeur de texte). Le ${i%a*}convertit headsen heet tailsvers t(qui, en tant que variable, a une valeur de 0).

• IFS=h;set $i;echo ${1:+-}1fonctionne en deux étapes. La définition de IFS pour diviser les parties hnon $ientre guillemets set $ien parties divisées par le caractère h, headsest divisée en ''et 'eads', donc définie $1sur null. tailn'est pas divisé par h, ce qui rend $1égal à tails. Génère ensuite ${1:+-}un -si la valeur de $1est non nulle (comme dans tails) ou rien (comme avec un null $1). Ce signe (ou rien) est concaténé avec 1.

• (IFS=h;set $i;echo $(($#*2-3)))fonctionne de la même manière mais utilise le nombre de parties ( $#) dans lesquelles la chaîne a $iété divisée.

Python 2, 17 octets

print'-1'['t'>i:]

'heads'est inférieur à 't', donc il évalue True == 1et imprime la chaîne après le premier caractère. 'tails'est supérieur à 't', il est donc évalué à False == 0et la chaîne entière est imprimée.

Si nous faisons cela à partir de la ligne de commande, avec une impression implicite, cela devient simplement:

'-1'['t'>i:]

... pour 12 octets, mais il ajoute des guillemets simples à la sortie.

QBasic, 11 octets

Cela doit être le plus court morceau de QBasic que j'aie jamais écrit.

c=i>"t
?c^c

Explication:

Ce qui précède est un QBasic assez fortement golfé. Une fois que la mise en forme automatique aura terminé, cela ressemblera à ceci:

c = i > "t"
PRINT c ^ c

La première ligne compare la chaîne iavec "t". Si iest "heads", i > "t"est faux et c = 0. Si ic'est "tails", i > "t"c'est vrai et c = -1. Oui, -1la valeur par défaut de booléen est-elle vraie dans QBasic!

La deuxième ligne est mappée -1vers -1et 0vers 1via une astuce mathématique:, (-1)^(-1) == 1/(-1) == -1et 0^0, bien que techniquement non définie mathématiquement, retourne 1.

Ce code nécessite d' iêtre déclaré explicitement comme une variable de chaîne; sinon, il faudrait que ce soit le cas i$. Programme de test complet (testé sur QB64 ):

DIM i AS STRING
DATA heads, tails

FOR x = 1 TO 2
READ i

c=i>"t
?c^c

NEXT x

Gaia , 5 4 octets

'eI(

Similaire à la réponse CJam de Dennis , trouve l'index de edans la chaîne d'entrée

Enregistrement d'un octet car je ne savais pas que l'entrée était automatiquement utilisée comme argument s'il n'y avait pas assez de valeurs de pile

Comment ça marche

'e  Push e
I   Index of e in the the input. 2 if heads, 0 if tails
(   Subtract One
Stack gets automatically outputted

Essayez-le en ligne!

Bash , 22

echo $[0x${1:1:1}/2-6]

Prend la 2e lettre ( eou a) et l'interprète comme un chiffre hexadécimal (14 ou 10), puis divisez par 2 et soustrayez 6 pour obtenir les bonnes réponses.

Essayez-le en ligne!

ed , 27 25 21 octets

edm'a donné mal à la tête. Enfin compris avec l'aide de @ed1confTwitter et quelques coups d'œil unix.se. Vous ne pouvez pas simplement faire correspondre les choses avec s/re/newtext/, vous devez le préfixer avec gsinon vous edemballez un triste. C'est comme un programme Unix grincheux de 50 ans qui dit "descendez de ma pelouse".

g/t/s//-
,s/\w\+/1
w

Essayez-le en ligne!

_{-2 octets en supprimant les /s
-4 octets finaux grâce à @manatwork (& dont sedj'ai plagié la réponse)
Ancienne version:
g/t/s//- g/\w\+/s//1 wq .}

Python, 20 octets

print(('h'in i)*2-1)

Cela revient Falsesi ce n'est pas le Truecas et si c'est le cas. En python Falseet 0sont les mêmes, et Trueet1 sont aussi.

Alors:

True (1) * 2 -1 = 2-1 = 1
False (0) * 2 - 1 = 0-1 = -1

golflua 25 20 18

w(I.r():f'h'&1|-1)

On pourrait probablement jouer au golf encore plus en utilisant des trucs auxquels je ne pense pas pour le moment. (voir l' historique pour l'ancienne version). Enregistrement de 5 caractères en déplaçant l'entrée vers writeet en ignorant l' ifinstruction là. Deux autres caractères ont été enregistrés en ignorant la parenthèse optionnelle activée find. Il ne vérifie pas les conditions d'échec (c'est-à-dire, une entrée qui n'est ni en tête ni en queue ).

Un équivalent Lua serait

io.write(io.read():find('h') and 1 or -1)

Haskell, 18 octets

f('h':_)=1
f _= -1

Chaque chaîne commençant par la lettre hest mappée à 1, toutes les autres à -1.

Sed: 16 caractères

s/t/-/
s/\w\+/1/

Exemple d'exécution:

bash-4.3$ sed 's/t/-/;s/\w\+/1/' <<< 'heads'
1

bash-4.3$ sed 's/t/-/;s/\w\+/1/' <<< 'tails'
-1

Stax , 3 octets

'eI

Exécuter et déboguer

Stax , 4 octets

└0Y.

Exécuter et déboguer

C'est le point de code du premier caractère mod 7 moins 5.

PowerShell , 15 octets

($args[1]-99)/2

Essayez-le en ligne!

Prend entrée via splatting. Utilise le evs le apour faire des maths ASCII

dc , 8 octets

?z2*1r-p

dc ne peut rien faire de significatif avec des chaînes autres que les lire et tenter de les évaluer. Ce faisant, "heads" émet des avertissements concernant les commandes non implémentées et la pile vide, que nous ignorons, mais surtout la pile reste vide. "tails" fait presque la même chose à l'exception importante que le "ls" final charge une valeur du registre s dans la pile.

Nous utilisons ensuite "z" pour obtenir la longueur de la pile et un violon arithmétique pour obtenir les bonnes réponses.

Essayez-le en ligne!

Triangulaire , 10 octets

F.~%.7/-_<

Essayez-le en ligne!

Divise la valeur ASCII d'une entrée de caractère par 7. Soustrait le quotient de 15. L'exécution s'arrête lorsque l'IP manque de l'espace du programme. Cela fonctionne parce que Triangular ne peut gérer que la division entière. Idéalement, "h" a une valeur de 104, qui est 14 lorsqu'il est divisé par 7; "t" est 116, qui est 16 lorsque l'entier est divisé par 7.

Non golfé / Explication:

   F
  . ~
 % . 7
/ - _ <
---------------------------------------------------------------
F                 - Push 15 to Top of Stack
 ~                - Read a character from input, push its value to ToS
   7              - Push 7 to ToS
     <_           - Change directions, then pop ToS-1 and ToS, push their integer quotient
        -         - Pop ToS-1 and ToS, push their difference
          %       - Print ToS as an integer

Version précédente (14 octets):

~\81|m/,!<.>i%

Lire un caractère de l'entrée; si la valeur ASCII de ce caractère divisée par 8 a un reste, imprimez -1, sinon imprimez 1.

Keg ,8 12 8 octets

_d=2*1-.

Essayez-le en ligne!

Explication (syntaxiquement invalide)

_        Take input and discard the last item
 d=      If the top of the stack is d:
   2*    Re-set the top of the stack as 2
     1-  Decrement the top of the stack by 1
       . Explicitly output the top of the stack

-4 octets grâce au manatwork

Vitsy , 13 octets

Alors quoi, je suis en retard pour la fête. ¯ \ _ (ツ) _ / ¯

zv&v'h'=)i1rN
z             Grab all input.
 v            Capture the top item (h or t) as a temp variable.
  &           Generate new stack, move to it.
   v'h'=      Test if the variable is h.
        )i    If it isn't, push -1.
          1   Push 1.
           r  Reverse the stack.
            N Print out the top item as a number.