使用说明

给定一个未知的输入字符串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 *i1 heads和-1 tails。

说明

在C中，"-1" + 1向前指向1个字符，因此与相同"1"。让我们看一下第一个字符：

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

如果我们从最右边的一位开始（从零开始）计数，则位3是1 in heads和0 in tails：将其相加"-1"得出正确的字符串。看起来像这样：

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

现在，替代i[0]以*i与功率的两分频的右移，以节省一些字节。还要删除无用的括号：

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

现在，& 1可以用代替% 2。字符数相同，但是模数优先级更高，允许删除括号。删除空格：

"-1"+*i/8%2

奖金

我认为在C中获取整数1或-1（不是字符串）的最短方法是：

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

Ruby 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链接

备择方案

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

TI-BASIC，9-10字节

cos(πʳinString(Ans,"t

直截了当。“ t”位于“ tails”的位置1，但“ t”不在字符串“ heads”中，因此inString（对于尾部返回1，对于头返回0。

如果您的计算器处于弧度模式（与任何数学家一样），则仅占用9个字节：

cos(πinString(Ans,"t

请注意，TI计算器没有命名字符串，因此输入在计算器的答案变量中。还要注意，小写字母每个都是两个字节，因此，该解决方案实际上比单词“ heads”占用更少的内存。

裂变，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。

Tr：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

对于“ heads”也一样，但是我们需要将“ t”放在前面以消耗减号（字符是按字母顺序排列的，以确保蠕变）：

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

将“ tails”和“ heads”的所有唯一字符合并到一个第一个参数中，将“ 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

说明：

使用CPU的奇偶校验标志来确定第一个字符是'h'（二进制数的偶数1）还是't'（二进制数的奇数1）。这样就比用ASCII比较char节省了一个字节。

从命令行输入，输出到控制台。

输入输出：

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的mod来获得heads和之间的差2 tails。然后减去1将数字转换为1和-1。
  请注意，a $[...]是算术表达式的古老形式，$((...))仅在某些shell中有效。

• 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为null。tail不受分割h，从而使得$1等于tails。然后，如果的值是非null（如中的）或没有值（如null ），则${1:+-}生成一个。该符号（或什么都没有）与串联。-$1tails$11

• (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"则为true和c = -1。是的，-1在QBasic中，布尔值的默认值为true吗！

第二行映射-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

盖亚，5 4字节

'eI(

类似于Dennis的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]

取第二个字母（e或a）并将其解释为十六进制数字（14或10），然后除以2再减去6得到正确的答案。

在线尝试！

ed，27 25 21字节

ed让我头疼。终于@ed1conf在Twitter上和在上的一些偷窥的帮助下弄清楚了unix.se。您不能仅通过与进行匹配s/re/newtext/，而必须以开头，g否则会ed让人感到悲伤。就像一个脾气暴躁的50岁的Unix程序说“下车我的草坪”。

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

在线尝试！

_{@manatwork（＆抄袭了我的答案），通过删除最后的/s
-4个字节sed-2个字节
旧版本：
g/t/s//- g/\w\+/s//1 wq .}

Python，20个字节

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

False如果不是，True则返回，如果是，则返回。在python中，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)

可以通过使用我目前未考虑的一些技巧来打更多的高尔夫球。（请参阅旧版本的历史记录）通过将输入移至write并忽略if该处的语句，节省了5个字符。通过忽略上的可选括号，又节省了两个字符find。它不会检查失败的条件（即输入不是head或tails）。

相当于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.

运行并调试

这是第一个字符mod 7减去5的代码点。

PowerShell，15字节

($args[1]-99)/2

在线尝试！

通过展开输入。使用evs a做ASCII数学

dc，8字节

?z2*1r-p

dc除了读入字符串并尝试对其求值外，不能对字符串做任何有意义的事情。这样做，“ heads”会输出一些有关未执行的命令和堆栈为空的警告，我们将忽略这些警告，但重要的是堆栈仍为空。“ tails”的功能几乎相同，但重要的例外是最终的“ ls”将值从s寄存器加载到堆栈。

然后，我们使用“ z”获得堆栈长度，并使用算术运算来获得正确的答案。

在线尝试！

三角形，10字节

F.~%.7/-_<

在线尝试！

将输入的字符的ASCII值除以7。从15减去商。当IP用尽程序空间时，执行将停止。这是可行的，因为Triangular只能管理整数除法。方便地，“ h”的值为104，当整数除以7时为14。“ t”为116，当整数除以7时为16。

取消高尔夫/说明：

   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字节归功于manatwork

Vitsy，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.