（第一个挑战，请让我知道它是否有任何问题。）

一个heterogram是在没有字母表的字母出现不止一次一个词，一个回文是一个短语，是一样的向后和向前。

这里的挑战是编写一段代码，将一个单词（仅一个字母）作为输入，并输出它是否是一个异义字（真实/虚假）。问题在于程序必须是回文式-前后读取相同的内容。资本并不重要位置，因此对于heterogram是有效的它不能有Q和Q，例如。不允许注释，并且您不能放置包含代码（或代码的重要部分）的字符串来尝试使回文部分变得容易：P

这是代码高尔夫球，因此最短的代码获胜。祝好运！

编辑：回文部分的括号，方括号或其他具有左右形式的符号必须适当颠倒。因此（helloolleh）是回文，但是（helloolleh（不是。显然，这被称为便捷回文。

编辑2：您将不会得到任何空输入，输入多个单词或输入除字母之外的其他字符。所以不用担心:)

Pyth-11个字节

（需要并计算后勤和领导空间）。

 z.{ z }.z 

测试套件。

<space>        Suppress print
 z             Input (for palindromness)
.{             Unique - actually does testing
  z            Input
<space>        Suppress print
  }            In operator
   .z          Cached input list
   <space>     At end of program makes empty tuple

Pyth，17个字节

 Z.{rzZ.q.Zzr}.Z 

在这里在线尝试。

前导空间是必要的。我已经计算了它以及字节数中的尾随空格。

细目如下：

     z            z is initialized to the input
    r Z           Z is initialized to 0, and r(string)0 converts the string to lowercase
  .{              .{ is pyth's builtin uniqueness test
       .q         .q terminates the program
         .Zzr}    This is just the program mirrored
              .Z  . requires a number to immediately follow it
                  If left blank the parser would throw an error
 Z                This is just mirrored from the end
                  The leading space suppresses the automatic printing of this 0
                  The trailing space mirrors the leading space

Python 3、125

主要问题是使相反的代码可解析。然后，我们可以让它从未定义的标识符中出错。

w=[str.lower][0]((input)())
(print)((max)((map)(w.count,w))<2)
(2>((w,tnuoc.w)(pam))(xam))(tnirp)
(()(tupni))[0][rewol.rts]=w

Perl，43个字节

print+m:^(?!.*(.).*\1|1/*.(.)*.!?)^:m+tnirp

用法示例：

echo "abcde" | perl -n entry.pl

> <>，137131字节

当我看到这个挑战时，我认为> <>可能最终是一种不错的语言选择，因为使用它您几乎可以忽略回文。确保指针仅停留在应有的位置很简单。虽然这是事实，但不幸的是，> <>使打高尔夫球的条件变得令人生厌（或一般来说打高尔夫球）。我希望使用我想到的一些怪异技巧来弥补这一点，但这是一个“快速”（实际上，无论是在程序方面还是在创建方面）答案。您可以在这里在线尝试。

i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
  ;n1<^  -*48<   .00~<  ;n-10<01-n;  >~00.   >84*-  ^>1n;
<.0e&$v?=@:}:&v?)1:-1lv?("Z":<v?)0:i

返回1表示true，-1表示false（我可以将其更改为0，但长度会保持不变，很不幸）

与往常一样，请让我知道这是否行不通，以及您是否对打高尔夫球有任何想法。我针对一些测试用例进行了测试，但始终可能会有例外。

这是另一个版本，我认为这个版本更聪明，但是可惜多了十个字节。这次的Truthy / Falsey值为1，并且有一个错误（something smells fishy...）：

>i:0(?v>:"Z")?vl: 2(?v&{:@$:@=01-*2.
 < ;n1<^  -*48<f6+0.0<
 &1-:1)e*1.1*e(1:-1& 
>0.0+6f>84*-  ^>1n; > 
.2*-10=@:$@:}&v?)2 :lv?("Z":<v?)0:i<

说明：

这是没有添加使其成为回文的部分的代码。该示例没有使用我尝试用于替代版本的“更聪明”的技巧，因此它的解释要容易一些（如果有人对“技巧”的解释感兴趣，我很乐意举一个）。

i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
  ;n1<^  -*48<   .00~<  ;n-10<

第1行：

i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
i:0(?v                                 #Pushes input and directs down if negative
      >:"Z")?v                         #Directs down if input is greater than "Z"
                                       #(reduces lowercase input to uppercase)
              l                        #Pushes length

                                       #Main loop begins
               1-:1(?v                 #Decrements top, and then directs down if less than 1
                      &                #Pushes top of stack onto register (length minus 1)
                       :{              #Duplicates top, shifts stack to the left
                         :@            #Duplicates top, shifts top three values of the stack to the right

                           =?v         #If top two values are equal, directs down
                              $        #Swaps top two values of the stack
                               &       #Pushes register onto stack
                                e0.    #Jumps back to the "1" after "?vl"
                                       #Main loop ends

                                   >   #Makes sure when the pointer jumps back to i it goes the right way

这就是令人费解的swapping（:{:@=?v$）的工作方式-我将使用此堆栈的测试用例：[5,1,8,1]最后一个字符是顶部。

:{堆栈的顶部被复制：[5,1,8,1,1]，并且堆栈向左移动：[1,8,1,1,5]

:@顶部重复：[1,8,1,1,5,5]，然后顶部三个值向右移动：[1,8,1,5,1,5]

=?v 这部分解释不必要

$最高值将再次交换一次yield [1,8,1,5]，请注意，这是将原始堆栈转移一次（就好像{是唯一的命令一样）。

因此，这是用英语做的^{（“感谢上帝，他实际上是在解释事情”）}是对照最高值检查整个堆栈，如果有任何值等于最高值，则移至第二行中的某个点。此检查是根据堆栈中有多少个值（l - 1，l是堆栈的长度）成比例地进行的，以便相互检查所有值。

第2行：

  ;n1<^  -*48<   .00~<  ;n-10<
   n1<                          #If input is less than 0 (i.e. there is none), print 1
  ;                             #and terminate

             <                  #If redirected because input is greater than "Z"
         -*48                   #Push 32, subtract (reducing lowercase to uppercase, numerically)
      ^                         #And move back to the portion that tests if input 
                                #is uppercase (which it will pass now)

                     <          #If counter is less than 1 (for main loop)
                 .00~           #Pop the counter and jump to the beginning (i)

                             <  #If any two values in the stack are equal
                          -10   #Push -1 (subtract 1 from 0)
                        ;n      #Print and terminate

PHP，126字节

您需要在5.4或更高版本中关闭short_tags ini指令的情况下运行它。

有史以来第一次高尔夫。有两份，第一份打印了一大堆垃圾，结果是虚假的/真实的：

<?=var_dump(max(array_count_values(str_split(end($argv))))<2)?><?(2>((((vgra$)dne)tilps_rts)seulav_tnuoc_yarra)xam)pmud_rav=?>

此版本将不打印任何行话（162字节）：

<?=var_dump(max(array_count_values(str_split(end($argv))))<2);__halt_compiler()?><?()relipmoc_tlah__;(2>((((vgra$)dne)tilps_rts)seulav_tnuoc_yarra)xam)pmud_rav=?>

从命令行运行

php -f golf.php heterogram

可能可以再打些高尔夫球

05AB1E，9个字节

lDÙQqQÙDl

在线尝试。

*插入有关重新回到我的第一个挑战的内容*

自从05AB1E以来，这项比赛之后就不参加比赛了。

说明

lDÙQqQÙDl
l           Take input and lowercase it.
 DÙ         Duplicate and uniquify.
   Q        Compare the two strings.
    q       Immediately exit.
     QÙDl   The rest of the program is ignored.

Brachylog，3个字节，语言发布日期挑战

DdD

在线尝试！

这是在Brachylog 1和Brachylog 2中都可以使用的极少数程序之一。TIO链接是出于古老的缘故而指向Brachylog 1。同样对于Brachylog来说，这也是一个异常，它是一个完整的程序，而不是一个功能。（Brachylog中的完整程序隐式输出布尔值，这正是我们想要的此问题。）

这里的一般原则是将谓词放在一对相同的大写字母之间是断言当前值在该谓词下是不变的。因此，您经常会看到诸如AoA“已排序”（“排序不变”）之类的内容；A↔A（在Brachylog 2中）将表示“是回文”（“在逆转下不变”），依此类推。该程序在删除重复项时是不变的，即“不包含重复项”。这种指定不变性的方法恰好是回文，这真的很方便。

Brachylog，3个字节

≠ụ≠

在线尝试！

如果输入是异义词，则谓词成功，否则，则谓词失败。

≠      The characters of the input are all distinct,
 ụ     and when converted to upper case,
  ≠    are still all distinct.

MATL，7个字节

tuX=Xut

在线尝试！

如果输入是异义词，则返回列表[1，1]，如果不是，则返回列表[0，0]。

说明：

t       % duplicate the input
u       % remove duplicates from the original
X=      % check the two lists are equal
Xu      % unique rows (does nothing as we now have a boolean)
t       % duplicate the result
        % (implicit) convert to string and display