инструкции

Учитывая неизвестную входную строку iсо значением либо головки или хвостов , возвратите 1для головок или -1для хвостов с самым коротким кодом.

Образец не гольф-кода (55b):

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

Пример гольф-кода (16b):

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

CJam, 4 байта

I'e#

Предполагается, что переменная Iсодержит входные данные, поскольку iне является допустимым идентификатором в CJam.

Попробуйте онлайн.

Это эквивалентно коду JavaScript I.indexOf('e').

C, 18 байтов

Довольно просто, но давайте сделаем это просто для удовольствия ...

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

Учитывая строку, char *iона печатает 1 для headsи -1 для tails, с завершающим переводом строки.

объяснение

В C "-1" + 1указывает на 1 символ вперед, поэтому он такой же, как "1". Давайте посмотрим на первые символы:

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

Если мы посчитаем биты от самого правого, начиная с нуля, бит 3 равен 1 в, headsа 0 в tails: суммируя его, "-1"получаем правильную строку. Это выглядит так:

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

Теперь, заменить i[0]с *iи сдвиг вправо с разделением мощности на двоих , чтобы сохранить несколько байт. Также удалите ненужные скобки:

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

Теперь & 1можно заменить на % 2. Количество символов одинаковое, но модуль имеет более высокий приоритет, что позволяет убрать скобки. Удалить пробелы:

"-1"+*i/8%2

бонус

Я думаю, что самый короткий способ получить целое число 1 или -1 (не строка) в C:

18-*i/6

Объяснение:

'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

Рубин, 8 (6 без выхода)

p ?t<=>i

Оператор ракеты!

PHP - 11 байт

<?=1-$i^=F;

Это работает, потому что 'tails' ^ 'F'→ '2'и 'heads' ^ 'F'→ '.', который при вводе в виде целого числа 0.

Вы можете проверить это решение (или любое из нижеперечисленного) следующим образом:

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

Ideone Link

альтернативы

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

TI-BASIC, 9-10 байтов

cos(πʳinString(Ans,"t

Непосредственная. «t» находится в позиции 1 «tails», но «t» не в строке «глав », поэтому inString (возвращает 1 для хвостов и 0 для голов.

Если ваш калькулятор работает в радианах (как и любой математик), он занимает всего девять байтов:

cos(πinString(Ans,"t

Обратите внимание, что в калькуляторах TI нет именованных строк, поэтому входные данные находятся в переменной ответа калькулятора. Также обратите внимание, что строчные буквы составляют два байта каждая, поэтому это решение на самом деле занимает меньше памяти, чем слово «head».

Деление , 26 21 байт

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

Мартин (и его превосходный ответ здесь ) убедил меня выучить новый язык, а что может быть лучше, чем быстрый гольф? Это почти наверняка не оптимально, но эй, это было весело! Как только я почувствую себя хорошо по этому поводу, я могу предоставить некоторую форму объяснения, если это будет запрошено.

Python 2, 16 байт

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

Pyth - 4 байта

 xz"e

Бег с головами или хвостами . Как iи intв Pyth, здесь используется zимя переменной, которая содержит любой пользовательский ввод. Он эквивалентен Python print(z.find("e")), поэтому использует метод @ Dennis.

VBA (Excel), 12 байт

Немного фантастики, но с VBA интересно попробовать подобрать подходящий язык программирования ...

?13-asc(i)/6

i - это строка, и она просто использует значение ASCII первого символа, разделенное на 6 и вычтенное из 13, чтобы получить 1 или -1. Очень просто.

Пример выполнения в непосредственном окне (10 дополнительных байтов для установки входной переменной):

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

C, 22 байта

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

^{_{Кредиты идут в @TheE для того, чтобы рассказать мне об этом !}}

Объяснение:

Если первый символ строки больше чем 'h', строка "-1"печатается. В противном случае строка "1"печатается. Обратите внимание, что этот подход сопровождается завершающим символом новой строки.

Старая версия (25 байт):

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

Объяснение:

Если первый символ строки больше чем 'h', печатается -1. В противном случае печатается 1.

Тр: 17 13 символов

(Или 14 10 если считать только аргументы ...)

tr -s ta-s -1

Образец прогона:

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

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

Краткое объяснение:

tr расшифровывается как транслитерация, то есть заменяет каждый символ ввода, найденного в первом аргументе, символом в той же позиции, что и во втором аргументе:

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

Если первый аргумент длиннее, символы без позиционного соответствия во втором аргументе заменяются последним символом второго аргумента:

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

Когда используется опция -s( --squeeze-repeats), последовательные символы, которые будут заменены одним и тем же символом, заменяются сразу:

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

Поэтому, если мы перечислим все символы в «хвостах», мы получим то, что нам нужно:

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

То же самое для «голов», но нам нужно держать «t» впереди, чтобы использовать минус (символы отсортированы в алфавитном порядке для удобства):

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

Объединение всех уникальных символов «хвостов» и «голов» в один первый аргумент, сохранение «t» впереди приводит к окончательному решению:

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

Чтобы избежать перечисления символов, вместо этого можно использовать интервал от - до формата.

Сборка 8088, IBM PC DOS, 17 байт

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

разобранное:

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

Объяснение:

Используйте флаг четности процессора, чтобы определить, является ли первый символ 'h'(четным числом двоичных 1файлов) или 't'(нечетным числом двоичных 1файлов). Это экономит один байт при сравнении char в ASCII.

Ввод из командной строки, вывод в консоль.

Ввод, вывод:

Japt , 2 байта

ae

Попробуйте онлайн

оболочка (переносная / POSIX), 16 байт

expr $i : he - 1

Попробуйте онлайн!
Благодаря @ StéphaneChazelas в unix.stackexchange.com

echo $[30#$i%7-1] # 17 bytes but only in bash, zsh. Попробуйте другие решения: попробуйте онлайн!
echo $((30#$i%7-1)) # 19 bytes but only bash,ksh,zsh. Попробуйте онлайн!
he=2;echo $[${i%a*}-1] # 22 bytes But only in bash,zsh . Попробуйте онлайн!
a=${i%h*};echo ${a:+-}1 # 23 . портативный Попробуйте онлайн!
he=2;echo $((${i%a*}-1)) # 24 bytes . портативный Попробуйте онлайн!
IFS=h;set $i;echo ${1:+-}1 # 26 (change IFS) . портативный Попробуйте онлайн!
(IFS=h;set $i;echo ${1:+-}1) # 28 (subshell) . портативный Попробуйте онлайн!
(IFS=h;set $i;echo $(($#*2-3))) # 31 bytes . портативный Попробуйте онлайн!

Примечание: использование dashв качестве разумного сравнения портативного тестера оболочки.

• expr $i : he - 1работает, считая, сколько символов совпадают heс $i : he. headsМатч 2и tails(нет) .Затем вычитая матч 0 1с - 1.

• $[30#$i%7-1]работает путем преобразования строки в целое число. Основание 30 и мод на 7 были выбраны, чтобы получить разницу 2 между headsи tails. Затем вычитание 1 преобразует числа в 1и -1.
  Обратите внимание, что a $[...]является архаичной формой арифметического выражения, $((...))действительного только в некоторых оболочках.

• he=2;echo $[${i%a*}-1]работает, создавая переменную некоторого значения, а затем используя Арифметическое Расширение, чтобы раскрыть эту переменную (из текстового значения). В ${i%a*}обращенных headsк heи tailsк t(что, как переменная, имеет значение 0).

• IFS=h;set $i;echo ${1:+-}1работает в два этапа. Установка IFS в hперерывах некотируемым $iв set $iна части разделены по характеру h, headsделится на ''и 'eads', таким образом , установив $1в нуль. tailне делится на h, таким образом, делая $1равным tails. Затем ${1:+-}генерирует a, -если значение $1является ненулевым (как в tails) или ничем (как с нулевым $1). Этот знак (или ничего) соединяется с 1.

• (IFS=h;set $i;echo $(($#*2-3)))работает аналогичным образом, но использует количество частей ( $#), в которые $iбыла разбита строка .

Python 2, 17 байт

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

'heads'меньше 't', поэтому он оценивает True == 1и печатает строку после первого символа. 'tails'больше, чем 't', поэтому он оценивает False == 0и печатает всю строку.

Если мы делаем это из командной строки с неявной печатью, это просто становится:

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

... для 12 байтов, но добавляет к выводу одинарные кавычки.

QBasic, 11 байт

Это должен быть самый короткий кусок QBasic, который я когда-либо писал.

c=i>"t
?c^c

Объяснение:

Выше приведен довольно сильный QBasic. Как только автоформатер справится с этим, он будет выглядеть так:

c = i > "t"
PRINT c ^ c

Первая строка сравнивает строку iс "t". Если iесть "heads", i > "t"ложно и c = 0. Если iесть "tails", i > "t"верно и c = -1. Да, -1это значение по умолчанию для логического true в QBasic!

Вторая строка отображается -1на -1и 0с 1помощью математического трюка: (-1)^(-1) == 1/(-1) == -1и 0^0, хотя технически математически не определено, возвращает 1.

Этот код требует, чтобы он iбыл явно объявлен как строковая переменная; иначе это должно было быть i$. Полная тестовая программа (тестируется на 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 байта

'eI(

Подобно ответу CJam Денниса , находит индекс eво входной строке

Сохранен один байт, так как я не знал, что ввод автоматически использовался в качестве аргумента, если не хватает стековых значений.

Как это работает

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

Попробуйте онлайн!

Баш , 22

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

Берет 2-ю букву ( eили a) и интерпретирует ее как шестнадцатеричное число (14 или 10), затем делит на 2 и вычитает 6, чтобы получить правильные ответы.

Попробуйте онлайн!

ed , 27 25 21 байт

edдал мне головную боль. Наконец-то разобрался с помощью @ed1confтвиттера и немного заглянул unix.se. Вы не можете просто сопоставить вещи с s/re/newtext/, вы должны префикс это с gдругими edпакетами грустно. Это как сварливая 50-летняя Unix-программа, говорящая «сойди с моего газона».

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

Попробуйте онлайн!

_{-2 байта, отбрасывая последние /s
-4 байта благодаря @manatwork (и чей sedответ я плагиат)
Старая версия:
g/t/s//- g/\w\+/s//1 wq .}

Python, 20 байт

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

Это возвращает, Falseесли это не так, и Trueесли это так. В питоне Falseи 0есть то же самое, и Trueи 1есть так же.

Так:

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)

Вероятно, можно было бы сыграть в гольф еще, используя некоторые хитрости, о которых я сейчас не думаю. (см. историю для старой версии). Сохранение 5 символов путем перемещения ввода writeи игнорирования ifоператора там. Еще два символа были сохранены, игнорируя необязательные скобки find. Он не проверяет наличие неисправных условий (т. Е. Входных данных, которые не являются головами или хвостами ).

Эквивалент Lua будет

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

Haskell, 18 байт

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

Каждая строка, начинающаяся с буквы h, сопоставляется со 1всеми остальными -1.

Sed: 16 символов

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

Образец прогона:

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

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

Stax , 3 байта

'eI

Запустите и отладьте его

Stax , 4 байта

└0Y.

Запустите и отладьте его

Это кодовая точка первого символьного мода 7 минус 5.

PowerShell , 15 байт

($args[1]-99)/2

Попробуйте онлайн!

Вводит через сплаттинг. Использует eпротив aASCII для математики

постоянный ток , 8 байт

?z2*1r-p

dc не может делать ничего значащего со строками, кроме как читать их и пытаться оценить их. При этом «головы» выводит некоторые предупреждения о невыполненных командах и пустом стеке, которые мы игнорируем, но важно, чтобы стек оставался пустым. "tails" делает почти то же самое с важным исключением, что заключительный "ls" загружает значение из регистра s в стек.

Затем мы используем «z», чтобы получить длину стека, и арифметически, чтобы получить правильные ответы.

Попробуйте онлайн!

Треугольный , 10 байтов

F.~%.7/-_<

Попробуйте онлайн!

Делит значение ASCII для ввода символов на 7. Вычитает частное из 15. Выполнение останавливается, когда IP заканчивается из пространства программы. Это работает, потому что треугольный может управлять только целочисленным делением. Удобно, чтобы «h» имел значение 104, которое равно 14, когда целое число делится на 7; «t» равно 116, то есть 16, когда целое число делится на 7.

Ungolfed / Пояснение:

   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

Предыдущая версия (14 байт):

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

Читать символ из ввода; если значение ASCII этого символа, разделенное на 8, содержит остаток, выведите -1, в противном случае выведите 1.

Бочонок ,8 12 8 байт

_d=2*1-.

Попробуйте онлайн!

Объяснение (синтаксически неверно)

_        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 байта благодаря ручной работе

Витси , 13 байт

Ну и что, я опаздываю на вечеринку. ¯ \ _ (ツ) _ / ¯

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.