挑战：

给定一个单词，检查它是否为等轴测图。

什么 ：

等距图是仅由字母组成的单词，没有重复（不区分大小写）。空字符串是等轴测图。

例子 ：

"Dermatoglyphics"     ---> true
"ab"                  ---> true
"aba"                 ---> false
"moOse"               ---> false
"abc1"                ---> false
""                    ---> true

输入：

您可以接受任何合理格式的输入

输入内容仅包含字母和/或数字，不包含空格（[a-zA-Z0-9]）

输出：

• true 或任何真实值（如果输入是等轴图）
• false 或其他任何虚假的值

这是代码高尔夫球，因此每种语言中以字节为单位的最短代码获胜。

Python的2/ 3 36 52 48个字节

lambda s:len(s)==len({*s.lower()}-{*str(56**7)})

在线尝试！

我利用了set仅包含独特元素的事实。通过调用__len__每个方法，我可以确定是否s还仅包含唯一元素（忽略大小写）。

编辑：已更新以满足先前被忽略的要求，以为数字输入返回False。所有数字的集合编码为set(str(56**7))。

编辑2：根据用户的建议，我现在利用解压缩参数来设置理解的优势。这正式破坏了与Python 2的兼容性。

05AB1E，5个字节

lDáÙQ

在线尝试！

说明

l        # convert input to lower-case
 D       # duplicate
  á      # keep only letters
   Ù      # remove duplicates
    Q     # compare for equality

R，41个字节

!grepl("(.).*\\1|\\d",tolower(scan(,"")))

在线尝试！

正则表达式方法。!grepl(regex,scan(,""),F)没有用，所以我猜在R中捕获不区分大小写吗？我一般来说对正则表达式不好，所以如果我做错了，我不会感到惊讶...

R，58个字节

!anyDuplicated(c(el(strsplit(tolower(scan(,"")),"")),0:9))

在线尝试！

将数字附加0:9到（小写的）字符列表中，并测试是否有重复项。

红宝石，25 23 21字节

得益于Giuseppe，两者均为-2个字节

->s{/(.).*\1|\d/i!~s}

在线尝试！

-2个字节，感谢KirillL。

红宝石 -n，21 19 18 16字节

p !/(.).*\1|\d/i

在线尝试！

Brachylog，4个字节

ḷo⊆Ạ

在线尝试！

如果输入是等轴测图，则谓词将成功；否则，则谓词将失败；如果成功，则输出小写拉丁字母。由于Brachylog的⊆内置谓词与子集和超集之间的普通关系不完全匹配，因此我不得不花一个字节对小写输入进行排序，但是节省了一个字节，不必显式检查其中的重复项。（如果不需要输掉数字，我们可以使用ḷ≠。）

外壳，6个字节

§=f√ü_

在线尝试！

说明

§=f√ü_  -- takes a string as argument, eg: "sAad2"
§       -- fork the argument..
  f√    -- | filter out non-letters: "sad"
    ü_  -- | deduplicate by lower-case: "sAd2"
 =      -- ..and compare: 0

Japt，12个字节

;v
oC ‰ eUq

说明：

;v
;         // Set alternative default vars, where C is the lowercase alphabet
 v        // Make the implicit input lowercase and reassign it
oC ‰ eUq
oC        // Remove all items from the input that are not in the alphabet
   ‰     // Split into chars and select unique array items
      eUq // Check if the result is equal to the input split into chars

在这里尝试。

MATL，9字节

kt2Y2X&X=

在线尝试！

k   % Lowercase implicit input
t   % Duplicate that
2Y2 % Push lowercase alphabet
X&  % Intersection of alphabet and duplicate lowercase input
X=  % Check for exact equality.

Python 3，46个字节

lambda s:s.isalpha()*len(s)==len({*s.lower()})

在线尝试！

Japt 2.0，12 11个字节

-1字节感谢Nit

v
f\l â eUq

在线测试！

JavaScript（Node.js），29 25字节

s=>!/(.).*\1|\d/i.test(s)

在线尝试！

感谢您的答案更新@BMO，@ l4m2，@KevinCruijssen

-4个字节，感谢@KevinCruijssen

视网膜，16字节

Ci`(.).*\1|\d
^0

以True 1和0Falsey值返回。
感谢@Neil在我的初始代码中发现并修复了一个错误。

在线尝试。

说明：

C             Check if the input matches part of the following regex:
 i`            Case insensitivity enabled
               Check if part of the input matches either:
  (.)           A character `C`
     .*         followed by zero or more characters
       \1       followed by the same character `C` again
         |     Or
          \d    A digit
^0             Invert Truthy/Falsey, basically replacing every 0 with a 1,
               and every other value with a 1

PowerShell，91字节

param($b)($a=[char[]]$b.ToUpper()|group|sort c*)[0].Count-eq$a[-1].count-and$b-notmatch'\d'

在线尝试！

天真的解决方案，但是我无法提出更好的算法。接受输入$b，将其转换为ToUpper大小写，并将其转换为char-array。对该数组进行管道传输，Group-Object以构造一个对象，该对象具有每个输入字母的名称/计数对。然后sort，我们基于count取其0第一个。我们检查其.Count是-eqUAL到.Count最后的[-1]对。如果是这样，那么计数都是相等的，否则我们会有不同数量的字母。

然后-and，我们通过检查输入是否-notmatch反对\d以排除输入中的任何数字。该布尔结果留在管道上，并且输出是隐式的。

果冻，8字节

ŒufØA⁼QƲ

在线尝试！

Python 2中，57 56个字节

x=input().lower()
print len(set(x)-set(`763**4`))/len(x)

在线尝试！

首先将其输入，然后输入一组，删除重复项，然后删除数字（以编码`763**4`），然后检查长度是否与原始输入相同

Java 8，61 39字节

s->!s.matches("(?i).*((.).*\\2|\\d).*")

说明：

在线尝试。

s->  // Method with String parameter and boolean return-type
  !s.matches("(?i).*((.).*\\2|\\d).*")
     //  Return whether the input does not match the regex

正则表达式说明：

String#matches隐式添加^...$。

^(?i).*((.).*\2|\d).*$
 (?i)                      Enable case insensitivity
^    .*                    Zero or more leading characters
       (       |  )        Followed by either:
        (.)                 Any character `C`
           .*               with zero or more characters in between
             \2             followed by that same character `C` again
               |           Or:
                \d          Any digit
                   .*$     Followed by zero or more trailing characters

APL（Dyalog Unicode），12个字节

匿名默认功能。

(∪≡~∘⎕D)819⌶

在线尝试！

819⌶ 小写

(…… ) 对此应用以下默认功能：

 ~∘⎕D从参数中 删除数字

 ∪≡ 该论点的独特元素是否与此相同？

Perl 6、22字节

{!(.uc~~/(.).*$0|\d/)}

在线尝试！

某些字符没有匹配项，然后是同一字符。隐式函数作为代码块，在$ _上隐式匹配，用反转书本!。添加了|\d（ta Adam）但也需要.uc~~，需要括号...

袋装替代品，23字节

{.uc.ords.Bag⊆65..97}

在线尝试！

然后将这一情况归一化，制作一个袋子（用发生率计数）。仅当所有成员都是比较包的成员并且所有事件计数均小于或等于比较包中的次数时，才设置subsub或等于true。因此，任何重复或数字都会使比较错误。

迅捷，81字节

let s=readLine()!.lowercased().characters;print(s.count<1||Set(s).count==s.count)

在线尝试！

Visual Basic应用程序（32位），102字节

s=LCase(InputBox(u)):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^Instr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0

使用以下事实：0^x如果x为零，则在VBA中产生1，否则为0。在立即（调试）窗口中运行。

编辑：正如泰勒在评论中指出的那样，这仅适用于MS Office的32位安装。

05AB1E，4个字节

lDÔQ

在线尝试！

说明

l      # convert input to lowercase
 D     # duplicate and push to stack
  Ô    # uniquify the list of characters
   Q   # check for equality

C（gcc），87 85 83字节

• 多亏了ceilingcat，节省了两个四个字节。

f(s,p,b,P)char*s,*p;{for(b=s;*s;++s)for(p=b*=*s>64;b&&p<s;b=(*s^*p++)&95?b:0);s=b;}

在线尝试！

K（ngn / k），18个字节

{(a^,/$!10)~?a:_x}

在线尝试！

CJam，11个字节

qelA,s+_L|=

在线尝试！

说明

基本思想是在每个数字后面附加一个数字，然后检查是否重复。由于附录确保每个数字已经存在一次，因此任何其他数字的存在都将重复，从而导致其返回false。

q      e# read the input:            | "MOoSE1"
el     e# convert to lowercase:      | "moose1"
A      e# push 10:                   | "moose1" 10
,      e# range [0,N):               | "moose1" [0 1 2 3 4 5 6 7 8 9]
s      e# string representation:     | "moose1" "0123456789"
+      e# concatenate:               | "moose10123456789"
_      e# duplicate:                 | "moose10123456789" "moose10123456789"
L|     e# union with the empty list: | "moose10123456789" "mose1023456789"
       e# (this gets rid of duplicates)
=      e# Equal to original:         | 0

红色，76字节

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]parse s[any[copy c a ahead not to c]]]

在线尝试！

Smalltalk，57个字节

在类String中定义的方法：

s^(self select:#isLetter)asUppercase asSet size=self size

这很可能是不言自明的。

Pyth，17个字节

.Am&!t/rz0d}dGrz0

测试套件

.Am&!t/rz0d}dGrz0 # Code
  m           rz0 # Map the following over the lowercase input:
      /rz0d       #  Count occurrences of d in lowercase input
     t            #   minus 1
    !             #    inverted (0 -> True)
   &              #     and
           }dG    #      d is in the lowercase alphabet
.A                # Print whether all values are truthy

z=input()
print(all(map(lambda d:not z.lower().count(d)-1and d in "abcdefghijklmnopqrstuvwxyz",z.lower())))

C＃，82个字节

bool f(string s)=>!!(s.GroupBy(c=>c).Any(c=>c.Count()>1|(!Char.IsLetter(c.Key))));

编辑：为字符添加测试

编辑：使用GroupBy将其缩短5个字节

APL（Dyalog Unicode），25 20 22字节

''≡'(.).*\1|\d'⎕S'&'⍠1

在线尝试！

返回1表示true，否则返回0。

@ H.PWiz节省了5个字节

固定，并通过@Adám保存了另一个字节

怎么样？

''≡'(.).*\1|\d'⎕S'&'⍠1 ⍝ Tacit fn
                    ⍠1 ⍝ Ignore case
               ⎕S'&'   ⍝ Search and return the match(es)
   '(.).*\1|\d'        ⍝ For this regex
''≡                    ⍝ And compare to the empty string

Tcl，114字节

proc I w {lmap c [set L [split $w ""]] {if {[regexp -all -nocase $c $w]>1|![string is alp $c]} {return 0}}
expr 1}

在线尝试！

proc I w {lmap c [set L [split $w ""]] {if {[llength [lsearch -al -noc $L $c]]>1|![string is alp $c]} {return 0}}
expr 1}

在线尝试！

我的口味还太久了！