Instrucciones

Dada una cadena de entrada desconocido icon un valor de cabezas o colas , volver 1a las cabezas o -1de las colas con el código más corto.

Ejemplo de código no golfizado (55b):

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

Ejemplo de código de golf (16b):

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

CJam, 4 bytes

I'e#

Asume que la variable Icontiene la entrada, ya ique no es un identificador válido en CJam.

Pruébalo en línea.

Esto es equivalente al código JavaScript I.indexOf('e').

C, 18 bytes

Bastante fácil, pero hagámoslo solo por diversión ...

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

Dada la cadena char *i, imprime 1 para headsy -1 para tails, con nueva línea final.

Explicación

En C, "-1" + 1apunta a 1 carácter hacia adelante, por lo que es lo mismo que "1". Echemos un vistazo a los primeros personajes:

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

Si contamos los bits del más a la derecha comenzando en cero, el bit 3 es 1 en headsy 0 en tails: sumando a "-1"da la cadena correcta. Se parece a esto:

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

Ahora, sustituya i[0]con *iy el desplazamiento a la derecha con la división de potencia de dos para guardar algunos bytes. También elimine los paréntesis inútiles:

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

Ahora, & 1puede ser sustituido con % 2. El recuento de caracteres es el mismo, pero el módulo tiene mayor prioridad, lo que permite eliminar los paréntesis. Eliminar el espacio en blanco:

"-1"+*i/8%2

Prima

Creo que la forma más corta de obtener un número entero 1 o -1 (no una cadena) en C es:

18-*i/6

Explicación:

'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

Rubí, 8 (6 sin salida)

p ?t<=>i

Operador de cohetes!

PHP - 11 bytes

<?=1-$i^=F;

Esto funciona porque 'tails' ^ 'F'→ '2'y 'heads' ^ 'F'→ '.', que cuando se escribe como un entero es 0.

Puede probar esta solución (o cualquiera de las siguientes) de la siguiente manera:

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

Enlace Ideone

Alternativas

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

TI-BASIC, 9-10 bytes

cos(πʳinString(Ans,"t

Sencillo. "t" está en la posición 1 de "colas", pero "t" no está en la cadena "cabezas", por lo que inString (devuelve 1 para colas y 0 para cabezas).

Si su calculadora está en modo radianes (como debería estarlo cualquier matemático), solo toma nueve bytes:

cos(πinString(Ans,"t

Tenga en cuenta que las calculadoras TI no tienen cadenas con nombre, por lo que la entrada está en la variable de respuesta de la calculadora. También tenga en cuenta que las letras minúsculas son de dos bytes cada una, por lo que esta solución en realidad requiere menos memoria que la palabra "cabezas".

Fisión , 26 21 Bytes

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

Martin (y su excelente respuesta aquí ) me convenció para aprender un nuevo idioma, y ​​¿qué mejor lugar que un golf rápido? Es casi seguro que esto no es óptimo, pero bueno, ¡fue divertido! Una vez que me sienta bien al respecto, puedo proporcionar alguna forma de explicación si así lo solicita.

Python 2, 16 bytes

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

Pyth - 4 bytes

 xz"e

Corre con cabezas o colas . Como ies inten Pyth, este usos zcomo el nombre de la variable, que contiene cualquier entrada del usuario. Es equivalente a Python print(z.find("e")), por lo que utiliza el método de @ Dennis.

VBA (Excel), 12 bytes

No es un juego de golf fantástico, pero es divertido probar con VBA para acercarse a un lenguaje de programación adecuado ...

?13-asc(i)/6

i es la cadena, y solo explota el valor ASCII del primer carácter, dividido por 6 y restado de 13 para dar 1 o -1. Muy simple.

Ejemplo ejecutado en una ventana inmediata (10 bytes adicionales para establecer la variable de entrada):

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

C, 22 bytes

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

^{_{¡Los créditos van a @TheE por contarme sobre esto !}}

Explicación:

Si el primer carácter de la cadena es mayor que 'h', la cadena "-1"se imprime. De lo contrario, la cadena "1"se imprime. Tenga en cuenta que este enfoque viene con un carácter de nueva línea final.

Versión anterior (25 bytes):

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

Explicación:

Si el primer carácter de la cadena es mayor que 'h', se imprime -1. De lo contrario, se imprime 1.

Tr: 17 13 caracteres

(O 14 10 si solo cuenta los argumentos ...)

tr -s ta-s -1

Ejecución de muestra:

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

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

Breve explicacion:

tr significa transliterar, es decir, reemplaza cada carácter de la entrada que se encuentra en el primer argumento con un carácter en la misma posición en el segundo argumento:

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

Si el primer argumento es más largo, los caracteres sin coincidencia posicional en el segundo argumento se reemplazan con el último carácter del segundo argumento:

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

Cuando se usa la opción -s( --squeeze-repeats), los caracteres sucesivos que se reemplazarían con el mismo carácter se reemplazan a la vez:

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

Entonces, si enumeramos todos los caracteres en “colas”, obtenemos lo que necesitamos:

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

Lo mismo para "cabezas", pero es necesario mantener la "t" al frente para consumir el signo menos (caracteres ordenados alfabéticamente por escalofriante)

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

Fusionar todos los caracteres únicos de "colas" y "cabezas" en un solo primer argumento, manteniendo "t" al frente conduce a la solución 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 los caracteres, se puede utilizar un intervalo en formato desde - hasta .

Conjunto 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

Explicación:

Use el indicador de paridad de la CPU para determinar si el primer carácter es un 'h'(número par de binarios 1) o un 't'(número impar de binarios 1). Esto ahorra un byte al comparar el carácter en ASCII.

Entrada desde la línea de comando, salida a la consola.

De entrada y salida:

Japt , 2 bytes

ae

Pruébalo en línea

shell (portátil / POSIX), 16 bytes

expr $i : he - 1

¡Pruébelo en línea!
Gracias a @ StéphaneChazelas en unix.stackexchange.com

Otras soluciones probadas: ¡
echo $[30#$i%7-1] # 17 bytes but only in bash, zsh. Pruébelo en línea!
echo $((30#$i%7-1)) # 19 bytes but only bash,ksh,zsh. ¡Pruébelo en línea!
he=2;echo $[${i%a*}-1] # 22 bytes But only in bash,zsh . ¡Pruébelo en línea!
a=${i%h*};echo ${a:+-}1 # 23 . portátil . ¡Pruébelo en línea!
he=2;echo $((${i%a*}-1)) # 24 bytes . portátil . ¡Pruébelo en línea!
IFS=h;set $i;echo ${1:+-}1 # 26 (change IFS) . portátil . ¡Pruébelo en línea!
(IFS=h;set $i;echo ${1:+-}1) # 28 (subshell) . portátil . ¡Pruébelo en línea!
(IFS=h;set $i;echo $(($#*2-3))) # 31 bytes . portátil . ¡Pruébelo en línea!

Nota: Usar dashcomo un símil razonable de un probador de shell portátil.

• expr $i : he - 1funciona mediante recuento de cuántos caracteres coinciden hecon $i : he. Un headspartido 2y un tailspartido 0 (ninguno). Luego restando 1con - 1.

• $[30#$i%7-1]funciona convirtiendo la cadena a un entero. La base 30 y el mod por 7 se seleccionaron para obtener una diferencia de 2 entre headsy tails. Luego, restando 1 convierte los números a 1y -1.
  Tenga en cuenta que a $[...]es una forma arcaica de expresión aritmética $((...))válida solo en algunos shells.

• he=2;echo $[${i%a*}-1]funciona haciendo una variable de algún valor y luego usando la expansión aritmética para expandir esa variable (desde el valor del texto). Los ${i%a*}convertidos headsa hey tailsa t(que, como una variable, tiene un valor de 0).

• IFS=h;set $i;echo ${1:+-}1Funciona en dos pasos. Establecer IFS para dividir lo hno entrecomillado $ien set $ipartes divididas por el carácter h, headsse divide en ''y 'eads', por lo tanto, se establece $1en nulo. tailNo se divide por h, por lo tanto, $1igual a tails. Luego, ${1:+-}genera un -si el valor de $1es no nulo (como en tails) o nada (como con un nulo $1). Ese signo (o nada) se concatena con 1.

• (IFS=h;set $i;echo $(($#*2-3)))funciona de manera similar, pero usa el número de partes ( $#) en las que $ise rompió la cadena .

Python 2, 17 bytes

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

'heads'es menor que 't', por lo que se evalúa True == 1e imprime la cadena después del primer carácter. 'tails'es mayor que 't', por lo que se evalúa False == 0y se imprime toda la cadena.

Si hacemos esto desde la línea de comandos, con impresión implícita, simplemente se convierte en:

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

... para 12 bytes, pero agrega comillas simples a la salida.

QBasic, 11 bytes

Esta tiene que ser la pieza más breve de QBasic que he escrito.

c=i>"t
?c^c

Explicación:

Lo anterior es un QBasic bastante bastante golfizado. Una vez que el autoformatter lo supere, se verá así:

c = i > "t"
PRINT c ^ c

La primera línea compara la cadena icon "t". Si ies "heads", i > "t"es falso y c = 0. Si ies "tails", i > "t"es cierto y c = -1. Sí,-1 es el valor predeterminado para boolean verdadero en QBasic!

La segunda línea se asigna -1a -1y 0a 1través de un truco de matemáticas: (-1)^(-1) == 1/(-1) == -1y 0^0, aunque técnicamente matemáticamente sin definir, devoluciones1 .

Este código requiere que ise declare explícitamente como una variable de cadena; de lo contrario, tendría que ser así i$. Programa de prueba completo (probado en 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(

Similar a la respuesta de Dennis CJam , encuentra el índice de een la cadena de entrada

Se guardó un byte ya que no me di cuenta de que la entrada se usó automáticamente como argumento si no hay suficientes valores de pila

Cómo funciona

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

Pruébalo en línea!

Bash , 22

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

Toma la segunda letra ( eo a) y la interpreta como un dígito hexadecimal (14 o 10), luego divide entre 2 y resta 6 para obtener las respuestas correctas.

Pruébalo en línea!

ed , 27 25 21 bytes

edme dio dolor de cabeza Finalmente lo resolví con la ayuda de @ed1confTwitter y algunos comentarios unix.se. No solo puedes unir las cosas s/re/newtext/, tienes que ponerle un prefijo, de lo gcontrario ed, es un paquete triste. Es como un gruñón programa de 50 años de Unix que dice "sal de mi jardín".

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

Pruébalo en línea!

_{-2 bytes al soltar los últimos /s
-4 bytes gracias a @manatwork (y cuya sedrespuesta plagué )
Versión anterior:
g/t/s//- g/\w\+/s//1 wq .}

Python, 20 bytes

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

Esto regresa Falsesi no lo es, y Truesi lo es. En python Falsey 0son lo mismo, Truey también lo 1son.

Asi que:

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)

Probablemente podría jugar un poco más usando algunos trucos en los que no estoy pensando en este momento. (vea el historial de la versión anterior) Guarde 5 caracteres moviendo la entrada writee ignorando la ifdeclaración allí. Se guardaron dos caracteres más al ignorar el paréntesis opcional en find. No comprueba para condiciones fallidos (es decir, de entrada que no es cabezas o colas ).

Un equivalente de Lua sería

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

Haskell, 18 bytes

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

Cada cadena que comienza con la letra hestá asignada a 1, todas las demás a -1.

Sed: 16 caracteres

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

Ejecución de muestra:

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

Ejecutar y depurarlo

Stax , 4 bytes

└0Y.

Ejecutar y depurarlo

Es el punto de código del primer personaje mod 7 menos 5.

PowerShell , 15 bytes

($args[1]-99)/2

Pruébalo en línea!

Toma entrada a través de salpicaduras. Utiliza el evs el apara hacer matemáticas ASCII

dc , 8 bytes

?z2*1r-p

dc no puede hacer nada significativo con cadenas distintas a leerlas e intentar evaluarlas. Al hacer esto, "heads" genera algunas advertencias sobre los comandos no implementados y la pila vacía, que ignoramos, pero lo más importante es que la pila permanece vacía. "colas" hace casi lo mismo con la importante excepción de que la "ls" final carga un valor del registro s en la pila.

Luego usamos "z" para obtener la longitud de la pila y el violín aritmético para obtener las respuestas correctas.

Pruébalo en línea!

Triangular , 10 bytes.

F.~%.7/-_<

Pruébalo en línea!

Divide el valor ASCII de una entrada de caracteres entre 7. Resta el cociente de 15. La ejecución se detiene cuando la IP se queda sin espacio del programa. Esto funciona porque Triangular solo puede administrar la división de enteros. Convenientemente, "h" tiene un valor de 104, que es 14 cuando el número entero se divide por 7; "t" es 116, que es 16 cuando entero dividido por 7.

Ungolfed / Explicación:

   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

Versión anterior (14 bytes):

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

Leer un personaje de entrada; si el valor ASCII de ese carácter dividido entre 8 tiene un resto, imprima -1, de lo contrario imprima 1.

barril ,8 12 8 bytes

_d=2*1-.

Pruébalo en línea!

Explicación (sintácticamente 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 gracias a manatwork

Vitsy , 13 bytes

Y qué, llego tarde a la fiesta. ¯ \ _ (ツ) _ / ¯

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.