Instruções

Dada uma cadeia de entrada desconhecido icom um valor de ambos cabeças ou caudas , retornar 1para as cabeças ou -1para caudas com o código mais curto.

Exemplo de código não golfado (55b):

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

Exemplo de código de golfe (16b):

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

CJam, 4 bytes

I'e#

Assume que a variável Iretém a entrada, pois inão é um identificador válido no CJam.

Experimente online.

Isso é equivalente ao código JavaScript I.indexOf('e').

C, 18 bytes

Muito fácil, mas vamos fazê-lo apenas por diversão ...

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

Dada a sequência char *i, imprime 1 para headse -1 para tails, com nova linha à direita.

Explicação

Em C, "-1" + 1aponta para 1 caractere à frente, portanto é o mesmo que "1". Vamos dar uma olhada nos primeiros caracteres:

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

Se contarmos os bits do ponto mais à direita começando em zero, o bit 3 será 1 in headse 0 in tails: somará para obter "-1"a string correta. Se parece com isso:

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

Agora, substitua i[0]por *ie a troca certa pela divisão de potência de dois para economizar alguns bytes. Remova também parênteses inúteis:

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

Agora, & 1pode ser substituído por % 2. A contagem de caracteres é a mesma, mas o módulo tem maior prioridade, permitindo descartar os parênteses. Remova o espaço em branco:

"-1"+*i/8%2

Bônus

Eu acho que a maneira mais curta de obter um número inteiro 1 ou -1 (não uma string) em C é:

18-*i/6

Explicação:

'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 sem saída)

p ?t<=>i

Operador de foguete!

PHP - 11 bytes

<?=1-$i^=F;

Isso funciona porque 'tails' ^ 'F'→ '2'e 'heads' ^ 'F'→ '.', que quando digitados como um número inteiro, são 0.

Você pode testar esta solução (ou qualquer uma das opções abaixo) da seguinte maneira:

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

Ideone Link

Alternativas

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

TI-BASIC, 9-10 bytes

cos(πʳinString(Ans,"t

Direto. "t" está na posição 1 de "caudas", mas "t" não está na string "heads", portanto inString (retorna 1 para caudas e 0 para cabeças.

Se a sua calculadora estiver no modo radiano (como qualquer matemático), são necessários apenas nove bytes:

cos(πinString(Ans,"t

Observe que as calculadoras de TI não possuem cadeias nomeadas, portanto a entrada está na variável de resposta da calculadora. Observe também que as letras minúsculas têm dois bytes cada, portanto, esta solução realmente requer menos memória que a palavra "cabeças".

Fissão , 26 21 Bytes

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

Martin (e sua excelente resposta aqui ) me convenceu a aprender um novo idioma, e que lugar melhor do que um golfe rápido? Isso quase certamente não é o ideal, mas, ei, foi divertido! Quando me sentir bem, posso fornecer alguma forma de explicação, se for solicitada.

Python 2, 16 bytes

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

Pitão - 4 bytes

 xz"e

Corra com cara ou coroa . Como ié intem Pyth, esta usos zcomo o nome da variável, que contém qualquer entrada de utilizador. É equivalente ao Python print(z.find("e")), então usa o método de @ Dennis.

VBA (Excel), 12 bytes

Não é um jogo fantástico de golfe, mas é divertido tentar com o VBA chegar perto de uma linguagem de programação adequada ...

?13-asc(i)/6

i é a string e apenas explora o valor ASCII do primeiro caractere, dividido por 6 e subtraído de 13 para fornecer 1 ou -1. Muito simples.

Exemplo de execução na janela imediata (10 bytes extras para definir a variável de entrada):

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

C, 22 bytes

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

^{_{Os créditos vão para @TheE por me falar sobre isso !}}

Explicação:

Se o primeiro caractere da sequência for maior que 'h', a sequência "-1"será impressa. Caso contrário, a sequência "1"será impressa. Observe que essa abordagem vem com um caractere de nova linha à direita.

Versão antiga (25 bytes):

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

Explicação:

Se o primeiro caractere da sequência for maior que 'h', -1 será impresso. Caso contrário, 1 é impresso.

Tr: 17 13 caracteres

(Ou 14 10 se você contar apenas os argumentos…)

tr -s ta-s -1

Exemplo de execução:

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

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

Breve explicação:

tr significa transliterado, ou seja, substitui cada caractere da entrada encontrada no primeiro argumento por caractere na mesma posição no segundo argumento:

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

Se o primeiro argumento for mais longo, os caracteres sem correspondência posicional no segundo argumento serão substituídos pelo último caractere do segundo argumento:

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

Quando a opção -s( --squeeze-repeats) é usada, caracteres sucessivos que seriam substituídos pelo mesmo caractere são substituídos de uma só vez:

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

Portanto, se enumerarmos todos os caracteres em "caudas", obtemos o que precisamos:

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

O mesmo para “cabeças”, mas precisamos manter o “t” na frente para consumir o sinal de menos (caracteres classificados em ordem alfabética por fluidez):

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

Mesclar todos os caracteres únicos de "caudas" e "cabeças" em um único primeiro argumento, mantendo "t" na frente leva à solução final:

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

Para evitar enumerar os caracteres, um intervalo de - para o formato pode ser usado.

Montagem 8088, IBM PC DOS, 17 bytes

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

Desmontado:

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

Explicação:

Use o sinalizador de paridade da CPU para determinar se o primeiro caractere é um 'h'(número par de binários 1) ou um 't'(número ímpar de binários 1). Isso economiza um byte em comparação ao caractere em ASCII.

Entrada da linha de comando, saída para o console.

Entrada / Saída:

Japonês , 2 bytes

ae

Experimente online

shell (portátil / POSIX), 16 bytes

expr $i : he - 1

Experimente Online!
Obrigado a @ StéphaneChazelas em unix.stackexchange.com

Outras soluções tentadas:
echo $[30#$i%7-1] # 17 bytes but only in bash, zsh. Experimente Online!
echo $((30#$i%7-1)) # 19 bytes but only bash,ksh,zsh. Experimente Online!
he=2;echo $[${i%a*}-1] # 22 bytes But only in bash,zsh . Experimente Online!
a=${i%h*};echo ${a:+-}1 # 23 . portátil. Experimente Online!
he=2;echo $((${i%a*}-1)) # 24 bytes . portátil. Experimente Online!
IFS=h;set $i;echo ${1:+-}1 # 26 (change IFS) . portátil. Experimente Online!
(IFS=h;set $i;echo ${1:+-}1) # 28 (subshell) . portátil. Experimente Online!
(IFS=h;set $i;echo $(($#*2-3))) # 31 bytes . portátil. Experimente Online!

Nota: Utilizando dashcomo um símile razoável de um testador de shell portátil.

• expr $i : he - 1funciona através da contagem de quantos caracteres coincidir hecom $i : he. Uma headscorrespondência 2e uma tailscorrespondência 0 (nenhuma). Em seguida, subtrair 1com - 1.

• $[30#$i%7-1]funciona convertendo a string em um número inteiro. A base 30 e o mod por 7 foram selecionados para obter uma diferença de 2 entre headse tails. Subtrair 1 converte os números em 1e -1.
  Observe que a $[...]é uma forma arcaica de expressão aritmética $((...))válida apenas em algumas conchas.

• he=2;echo $[${i%a*}-1]funciona criando uma variável com algum valor e, em seguida, usando a Expansão aritmética para expandir essa variável (a partir do valor do texto). O ${i%a*}converte headspara hee tailspara t(que, como variável, tem um valor de 0).

• IFS=h;set $i;echo ${1:+-}1funciona em duas etapas. Definir IFS para hpausas a não cotadas $iem set $iem partes divididas pelo personagem h, headsé dividido para ''e 'eads', estabelecendo assim $1como nulo. tailnão é dividido por h, tornando-o $1igual a tails. Em seguida, ${1:+-}gera a -se o valor de $1for não nulo (como em tails) ou nada (como em um nulo $1). Esse sinal (ou nada) é concatenado com 1.

• (IFS=h;set $i;echo $(($#*2-3)))funciona de maneira semelhante, mas use o número de partes ( $#) nas quais a string $ifoi quebrada.

Python 2, 17 bytes

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

'heads'é menor que 't', então ele avalia True == 1e imprime a sequência após o primeiro caractere. 'tails'é maior que 't', portanto, é avaliado False == 0e a sequência inteira é impressa.

Se fizermos isso na linha de comando, com impressão implícita, isso se tornará:

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

... por 12 bytes, mas adiciona aspas simples à saída.

QBasic, 11 bytes

Esse deve ser o menor pedaço de QBasic que eu já escrevi.

c=i>"t
?c^c

Explicação:

O acima é alguns QBasic bastante fortemente golfed. Quando o autoformatter terminar com isso, ficará assim:

c = i > "t"
PRINT c ^ c

A primeira linha compara a sequência icom "t". Se ifor "heads", i > "t"é falso e c = 0. Se ifor "tails", i > "t"é verdade e c = -1. Sim, -1é o valor padrão para boolean true em QBasic!

A segunda linha é mapeada -1de -1e 0para 1um truque de matemática: (-1)^(-1) == 1/(-1) == -1e 0^0, embora tecnicamente matematicamente indefinida, retorne 1.

Este código requer que iseja declarado explicitamente como uma variável de cadeia; caso contrário, teria que ser i$. Programa de teste completo (testado em 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 bytes

'eI(

Semelhante à resposta CJam de Dennis , localiza o índice ena string de entrada

Salvei um byte, pois não percebi que a entrada era usada automaticamente como argumento se não houvesse valores de pilha suficientes

Como funciona

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

Experimente Online!

Bash , 22

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

Pega a 2ª letra ( eou a) e a interpreta como um dígito hexadecimal (14 ou 10), depois divida por 2 e subtraia 6 para obter as respostas corretas.

Experimente online!

ed , 27 25 21 bytes

edme deu dor de cabeça. Finalmente descobri com ajuda do @ed1conftwitter e algumas espreitadelas unix.se. Você não pode apenas combinar as coisas com s/re/newtext/, você tem que prefixar com pacotes de goutra edforma tristes. É como um programa unix rabugento de 50 anos dizendo "saia do meu gramado".

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

Experimente online!

_{-2 bytes /eliminando os s
-4 bytes sedfinais, graças a @manatwork (e cuja resposta plagiei )
Versão antiga:
g/t/s//- g/\w\+/s//1 wq .}

Python, 20 bytes

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

Isso retorna Falsese não estiver e Truese estiver. Em python Falsee 0são iguais Truee também 1são.

Tão:

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)

Provavelmente poderia jogar mais um pouco usando alguns truques nos quais não estou pensando no momento. (veja o histórico da versão antiga) Salva 5 caracteres movendo a entrada para writee ignorando a ifinstrução lá. Mais dois caracteres foram salvos ignorando o parêntese opcional find. Não verifica se há condições com falha (ou seja, entrada que não seja cara ou coroa ).

Um equivalente Lua seria

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

Haskell, 18 bytes

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

Cada sequência iniciada com a letra hé mapeada para 1, e todas as outras para -1.

Sed: 16 caracteres

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

Exemplo de execução:

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

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

Stax , 3 bytes

'eI

Execute e depure

Stax , 4 bytes

└0Y.

Execute e depure

É o ponto de código do primeiro caractere mod 7 menos 5.

PowerShell , 15 bytes

($args[1]-99)/2

Experimente online!

Recebe entrada através de splatting. Usa o evs apara fazer matemática ASCII

dc , 8 bytes

?z2*1r-p

dc não pode fazer nada significativo com strings a não ser lê-las e tentar avaliá-las. Fazendo isso, "heads" emite alguns avisos sobre comandos não implementados e pilha vazia, que ignoramos, mas o mais importante é que a pilha permanece vazia. "tails" faz quase o mesmo com a importante exceção de que o "ls" final carrega um valor do registro s para a pilha.

Em seguida, usamos "z" para obter o tamanho da pilha e aritmeticamente mexer para obter as respostas corretas.

Experimente online!

Triangular , 10 bytes

F.~%.7/-_<

Experimente online!

Divide o valor ASCII de uma entrada de caracteres por 7. Subtrai o quociente de 15. A execução pára quando o IP fica sem espaço no programa. Isso funciona porque o Triangular pode gerenciar apenas a divisão inteira. Convenientemente, "h" tem um valor de 104, que é 14 quando inteiro dividido por 7; "t" é 116, que é 16 quando inteiro dividido por 7.

Ungolfed / Explicação:

   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

Versão anterior (14 bytes):

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

Leia um caractere da entrada; se o valor ASCII desse caractere dividido por 8 tiver um restante, imprima -1, caso contrário, imprima 1.

Barril ,8 12 8 bytes

_d=2*1-.

Experimente online!

Explicação (sintaticamente inválida)

_        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 bytes graças ao manatwork

Vitsy , 13 bytes

Então, estou atrasado para a festa. ¯ \ _ (ツ) _ / ¯

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.