Istruzioni

Dato una stringa di input sconosciuta icon un valore sia teste o code , ritorno 1per teste o -1per le code con il codice breve.

Codice campione non golfato (55b):

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

Esempio di codice golfizzato (16b):

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

CJam, 4 byte

I'e#

Presuppone che la variabile Icontenga l'input, poiché inon è un identificatore valido in CJam.

Provalo online.

Ciò equivale al codice JavaScript I.indexOf('e').

C, 18 byte

Abbastanza facile, ma facciamolo solo per divertimento ...

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

Data la stringa char *iche stampa 1 per headse -1 per tails, con newline finale.

Spiegazione

In C, "-1" + 1punta a 1 carattere in avanti, quindi è lo stesso di "1". Diamo un'occhiata ai primi personaggi:

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

Se contiamo i bit da quello più a destra iniziando da zero, il bit 3 è 1 in headse 0 in tails: sommandolo per "-1"dare la stringa giusta. Sembra così:

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

Ora, sostituisci i[0]con *iil turno giusto con la divisione power-of-two per salvare alcuni byte. Rimuovi anche le parentesi inutili:

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

Ora, & 1può essere sostituito con % 2. Il conteggio dei caratteri è lo stesso, ma il modulo ha una priorità più elevata, consentendo di rilasciare le parentesi. Rimuovi lo spazio bianco:

"-1"+*i/8%2

indennità

Penso che il modo più breve per ottenere un numero intero 1 o -1 (non una stringa) in C sia:

18-*i/6

Spiegazione:

'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 senza uscita)

p ?t<=>i

Operatore della nave spaziale!

PHP - 11 byte

<?=1-$i^=F;

Questo funziona perché 'tails' ^ 'F'→ '2'e 'heads' ^ 'F'→ '.', che quando viene digitato come intero è 0.

È possibile testare questa soluzione (o una delle opzioni seguenti) nel modo seguente:

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

Link Ideone

alternative

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

TI-BASIC, 9-10 byte

cos(πʳinString(Ans,"t

Semplice. "t" è nella posizione 1 di "code", ma "t" non è nella stringa "teste", quindi inString (restituisce 1 per le code e 0 per le teste.

Se la tua calcolatrice è in modalità radiante (come dovrebbe essere qualsiasi matematico), ci vogliono solo nove byte:

cos(πinString(Ans,"t

Si noti che i calcolatori TI non hanno stringhe con nome, quindi l'input è nella variabile di risposta della calcolatrice. Si noti inoltre che le lettere minuscole sono due byte ciascuna, quindi questa soluzione richiede effettivamente meno memoria rispetto alla parola "head".

Fissione , 26 21 byte

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

Martin (e la sua eccellente risposta qui ) mi hanno convinto ad imparare una nuova lingua, e quale posto migliore di un golf veloce? Quasi certamente questo non è ottimale, ma ehi, è stato divertente! Una volta che mi sento bene, posso fornire qualche forma di spiegazione se è richiesto.

Python 2, 16 byte

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

Pyth - 4 byte

 xz"e

Corri con la testa o la coda . Come iè intin Pyth, Questo utilizza zcome il nome della variabile, che contiene alcun input dell'utente. È equivalente al Python print(z.find("e")), quindi utilizza il metodo @ Dennis.

VBA (Excel), 12 byte

Non è un gran gioco di golf, ma è divertente provare con VBA per avvicinarsi a un linguaggio di programmazione adeguato ...

?13-asc(i)/6

i è la stringa e sfrutta semplicemente il valore ASCII del primo carattere, diviso per 6 e sottratto da 13 per dare 1 o -1. Molto semplice.

Esempio eseguito nella finestra immediata (10 byte extra per impostare la variabile di input):

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

C, 22 byte

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

^{_{I crediti vanno a @TheE per avermelo detto !}}

Spiegazione:

Se il primo carattere della stringa è maggiore di 'h', la stringa "-1"viene stampata. Altrimenti, la stringa "1"viene stampata. Si noti che questo approccio viene fornito con un carattere di nuova riga finale.

Vecchia versione (25 byte):

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

Spiegazione:

Se il primo carattere della stringa è maggiore di 'h', viene stampato -1. Altrimenti, viene stampato 1.

Tr: 17 13 caratteri

(O 14 10 se conti solo gli argomenti ...)

tr -s ta-s -1

Esecuzione di esempio:

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

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

Breve spiegazione:

tr sta per transliterate, ciò significa che sostituisce ogni carattere dell'input trovato nel primo argomento con carattere nella stessa posizione nel secondo argomento:

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

Se il primo argomento è più lungo, i caratteri senza corrispondenza posizionale nel secondo argomento vengono sostituiti con l'ultimo carattere del secondo argomento:

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

Quando viene utilizzata l'opzione -s( --squeeze-repeats), i caratteri successivi che verrebbero sostituiti con lo stesso carattere vengono sostituiti contemporaneamente:

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

Quindi, se elenciamo tutti i caratteri in "code", otteniamo ciò di cui abbiamo bisogno:

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

Lo stesso vale per le "teste", ma dobbiamo tenere la "t" davanti per consumare il meno (personaggi ordinati alfabeticamente per inquietudine):

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

Unire tutti i caratteri univoci di "code" e "teste" in un unico primo argomento, mantenendo "t" davanti porta alla soluzione 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

Per evitare di enumerare i caratteri, è possibile utilizzare invece un intervallo da - a formato.

8088 assembly, IBM PC DOS, 17 byte

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

smontato:

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

Spiegazione:

Utilizzare il flag di parità della CPU per determinare se il primo carattere è un 'h'(numero pari di file binari 1) o un 't'(numero dispari di file binari 1). Ciò consente di risparmiare un byte rispetto al confronto del carattere in ASCII.

Input da riga di comando, output su console.

Input Output:

Japt , 2 byte

ae

Provalo online

shell (portatile / POSIX), 16 byte

expr $i : he - 1

Provalo online!
Grazie a @ StéphaneChazelas in unix.stackexchange.com

Altre soluzioni provate:
echo $[30#$i%7-1] # 17 bytes but only in bash, zsh. provalo online!
echo $((30#$i%7-1)) # 19 bytes but only bash,ksh,zsh. Provalo online!
he=2;echo $[${i%a*}-1] # 22 bytes But only in bash,zsh . Provalo online!
a=${i%h*};echo ${a:+-}1 # 23 . portatile. Provalo online!
he=2;echo $((${i%a*}-1)) # 24 bytes . portatile. Provalo online!
IFS=h;set $i;echo ${1:+-}1 # 26 (change IFS) . portatile. Provalo online!
(IFS=h;set $i;echo ${1:+-}1) # 28 (subshell) . portatile. Provalo online!
(IFS=h;set $i;echo $(($#*2-3))) # 31 bytes . portatile. Provalo online!

Nota: utilizzo dashcome una similitudine ragionevole di un tester per shell portatile.

• expr $i : he - 1opere di contare quante caratteri corrispondono hecon $i : he. Una headspartita 2e una tailspartita 0 (nessuna). Quindi sottrai 1con - 1.

• $[30#$i%7-1]funziona convertendo la stringa in un numero intero. La base 30 e la mod di 7 sono state selezionate per ottenere una differenza di 2 tra headse tails. Quindi sottraendo 1, i numeri vengono convertiti in 1e -1.
  Si noti che a $[...]è una forma arcaica di espressione aritmetica $((...))valida solo in alcune shell.

• he=2;echo $[${i%a*}-1]funziona creando una variabile di un certo valore e quindi usando l'espansione aritmetica per espandere quella variabile (dal valore del testo). Il ${i%a*}converte headsin hee tailsin t(che, come variabile, ha un valore di 0).

• IFS=h;set $i;echo ${1:+-}1funziona in due passaggi. Impostazione IFS per hinterruzioni del quotati $iin set $iin parti divise dal carattere h, headsè diviso a ''e 'eads', mettendo così $1a nullo. tailnon è diviso per h, rendendo così $1uguale a tails. Quindi, ${1:+-}genera un -se il valore di $1è non nullo (come in tails) o niente (come con un null $1). Quel segno (o niente) è concatenato 1.

• (IFS=h;set $i;echo $(($#*2-3)))funziona in modo simile ma usa il numero di parti ( $#) in cui è $istata rotta la stringa .

Python 2, 17 byte

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

'heads'è minore di 't', quindi valuta True == 1e stampa la stringa dopo il primo carattere. 'tails'è maggiore di 't', quindi valuta False == 0e viene stampata l'intera stringa.

Se lo stiamo facendo dalla riga di comando, con la stampa implicita, diventa solo:

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

... per 12 byte, ma aggiunge virgolette singole all'output.

QBasic, 11 byte

Questo deve essere il pezzo più breve di QBasic che abbia mai scritto.

c=i>"t
?c^c

Spiegazione:

Quanto sopra è un QBasic piuttosto pesantemente giocato a golf. Una volta che l'autoformatter avrà finito, sembrerà così:

c = i > "t"
PRINT c ^ c

La prima riga confronta la stringa icon "t". Se iè "heads", i > "t"è falso e c = 0. Se iè "tails", i > "t"è vero e c = -1. Sì, -1è il valore predefinito per booleano true in QBasic!

La seconda riga è mappata -1da -1e 0verso 1un trucco matematico: (-1)^(-1) == 1/(-1) == -1e 0^0, sebbene tecnicamente matematicamente indefinito, ritorna 1.

Questo codice richiede che isia esplicitamente dichiarato come variabile stringa; altrimenti, dovrebbe essere i$. Programma di test completo (testato su 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 byte

'eI(

Simile alla risposta CJam di Dennis , trova l'indice di enella stringa di input

Ho salvato un byte poiché non avevo capito che l'input veniva usato automaticamente come argomento se non c'erano abbastanza valori di stack

Come funziona

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

Provalo online!

Bash , 22

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

Prende la seconda lettera ( eo a) e la interpreta come una cifra esadecimale (14 o 10), quindi dividi per 2 e sottrai 6 per ottenere le risposte giuste.

Provalo online!

ed , 27 25 21 byte

edmi ha fatto venire il mal di testa. Alla fine l'ho capito con l'aiuto di @ed1confTwitter e alcuni sbirciati unix.se. Non puoi semplicemente abbinare le cose con s/re/newtext/, devi prefissarlo con galtrimenti edimpacca un triste. È come un burbero programma unix di 50 anni che dice "vattene dal prato".

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

Provalo online!

_{-2 byte rilasciando gli ultimi /s
-4 byte grazie a @manatwork (e di cui sedho plagiato la risposta)
Vecchia versione:
g/t/s//- g/\w\+/s//1 wq .}

Python, 20 byte

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

Questo ritorna Falsese non lo è e Truese lo è. In Python Falsee 0sono gli stessi, Truee lo 1sono anche.

Così:

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)

Probabilmente si potrebbe giocare ancora un po 'a golf usando alcuni trucchi a cui non sto pensando al momento. (vedi la cronologia per la vecchia versione) Hai salvato 5 caratteri spostando l'input writee ignorando l' ifistruzione lì. Altri due caratteri sono stati salvati ignorando la parentesi opzionale attivata find. Non controlla le condizioni non riuscite (ovvero input che non sono head o code ).

Un equivalente di Lua sarebbe

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

Haskell, 18 byte

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

Ogni stringa che inizia con la lettera hè mappata su 1, tutte le altre su -1.

Sed: 16 caratteri

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

Esecuzione di esempio:

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

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

Stax , 3 byte

'eI

Esegui ed esegui il debug

Stax , 4 byte

└0Y.

Esegui ed esegui il debug

È il punto di codice del primo personaggio mod 7 meno 5.

PowerShell , 15 byte

($args[1]-99)/2

Provalo online!

Accetta input tramite splatting. Utilizza la matematica ASCII evs ado to do

dc , 8 byte

?z2*1r-p

dc non può fare nulla di significativo con le stringhe oltre a leggerle e tentare di valutarle. In questo modo, "head" genera alcuni avvertimenti su comandi non implementati e stack vuoto, che ignoriamo, ma soprattutto lo stack rimane vuoto. "Tails" fa quasi la stessa cosa con l'importante eccezione che la "ls" finale carica un valore dal registro s allo stack.

Quindi usiamo "z" per ottenere la lunghezza dello stack e aritmeticamente il violino per ottenere le risposte giuste.

Provalo online!

Triangolare , 10 byte

F.~%.7/-_<

Provalo online!

Divide il valore ASCII di un carattere immesso per 7. Sottrae il quoziente da 15. L'esecuzione si interrompe quando l'IP si esaurisce nello spazio del programma. Questo funziona perché Triangular può gestire solo la divisione di numeri interi. Convenientemente, "h" ha un valore di 104, che è 14 quando numero intero diviso per 7; "t" è 116, che è 16 quando intero è diviso per 7.

Ungolfed / Spiegazione:

   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

Versione precedente (14 byte):

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

Leggi un carattere dall'input; se il valore ASCII di quel personaggio diviso 8 ha un resto, stampa -1, altrimenti stampa 1.

Keg ,8 12 8 byte

_d=2*1-.

Provalo online!

Spiegazione (sintatticamente non valida)

_        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 byte grazie a manatwork

Vitsy , 13 byte

Quindi, sono in ritardo per la 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.