您将得到一个正整数（永远不会包含0）作为输入。您的任务是检查它是否是Lynch-Bell号码。

如果数字的所有数字都是唯一的并且该数字可被其每个数字整除，则该数字为Lynch-Bell数字。

实际上，实际上只有548个Lynch-Bell数字，因此可以进行硬编码，但几乎可以肯定会更长。

126是Lynch-Bell号码，因为其所有数字都是唯一的，并且126可被1、2和6整除。

您可以输出任何真实值和虚假值。

例子：

7 -> truthy
126 -> truthy
54 -> falsy
55 -> falsy
3915 -> truthy

这是OEIS A115569。

Mathematica，42个字节

0!=##&@@d&&##&@@((d=IntegerDigits@#)∣#)&

我认为这0!=##&@@d&&##&@@是Mathematica可读性的新低...

说明

这里使用的一些基本语法糖：

• & 优先级非常低，并将剩下的所有东西变成一个未命名的函数。
• &&只是And操作员。
• # 是最接近的未命名函数的参数。
• ##是该函数所有参数的序列。
• @是函数调用的前缀表示法，即f@x == f[x]。
• @@is Apply，它将列表的元素作为单个参数传递给函数，即f@@{a,b,c} == f[a,b,c]。

有了这个...

(d=IntegerDigits@#)

这应该是不言自明的：这为我们提供了输入的十进制数字列表，并将结果存储在 d。

(...∣#)

这将通过其每个数字来检验输入的可除性（因为可除运算符为Listable）。这给出了Trues和Falses 的列表。

...&@@...

我们将左侧的函数应用于布尔值列表，这样每个布尔值都是一个单独的参数。

...&@@d

我们将另一个函数应用于d，以便将各个数字作为单独的参数给出。函数是0!=##&，即。它检查所有数字是否都不同（并且它们是否与众不同，但这是挑战所提供的，如果不是，则无论如何都不是除数）。实际上只是一个使用自身的1字节保护程序，它之所以有效，是因为存在一个我们知道不存在的1字节元素（）。因此，这第一件事检查数字是否唯一。我们称这个结果Unequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

同样，这实际上只是的简写And[U, ##]。与##作为一个序列，从初始检查整除单个布尔值被扩展到And，所以我们得到其中检查这两个数字是独一无二的，每一个数字将输入。And[U, d1∣n, d2∣n, ...]

Python 3，56个字节

lambda n:any(int(n)%int(x)for x in n)or len(n)>len({*n})

在线尝试！

False如果它是Lynch-Bell号码，True则输出，否则。

Brachylog，10个字节

≠g;?z%ᵐ=h0

在线尝试！

说明

≠             All digits are different
 g;?z         Zip the input with each of its digits
     %ᵐ       Map mod
       =      All results are equal
        h0    The first one is 0

C＃，87 83字节

using System.Linq;s=>s.Distinct().Count()==s.Length&s.All(c=>int.Parse(s)%(c-48)<1)

^{我在Visual Studio上进行测试之前在记事本中编写了此文件，它在这里工作得很好，所以才意识到我现在是那种书呆子...}

完整/格式化版本：

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<string, bool> f = s => s.Distinct().Count() == s.Length
                                  & s.All(c => int.Parse(s) % (c - 48) < 1);

        Console.WriteLine(f("7"));
        Console.WriteLine(f("126"));
        Console.WriteLine(f("54"));
        Console.WriteLine(f("55"));
        Console.WriteLine(f("3915"));

        Console.ReadLine();
    }
}

JavaScript（ES6），42 41字节

s=>![...s].some((e,i)=>s%e|s.search(e)<i)

将输入作为字符串并返回true或false适当地返回。编辑：由于@RickHitchcock，节省了1个字节。其他版本：

将输入作为字符串并返回40字节的0或1（即逻辑逆）：

s=>/(.).*\1/.test(s)|[...s].some(e=>s%e)

将输入作为数字并返回0或1为43个字节：

n=>/(.).*\1/.test(n)|[...''+n].some(e=>n%e)

将输入作为数字并返回1或0为45个字节：

n=>!/(.).*\1/.test(n)&![...''+n].some(e=>n%e)

果冻，6 4字节

Dg⁼Q

在线尝试！

怎么运行的

Dg⁼Q  Main link. Argument: n

D     Decimal; convert n to base 10.
 g    Take the GCD of each decimal digit k and n.
      For each k, this yields k if and only if k divides n evenly.
   Q  Unique; yield n's decimal digits, deduplicated.
  ⁼   Test the results to both sides for equality.

Python 3 3，54个字节

False当数字是Lynch-Bell数字时返回。将字符串作为输入。是我自己提出的，但与Rod's非常相似。我会在他的帖子下发表评论，但我还没有任何声誉。

lambda s:len({*s})<len(s)+any(int(s)%int(c)for c in s)

在线尝试！

果冻，8字节

D⁼QaDḍ$Ạ

在线尝试！

PHP，62 48字节

while($i=$argn[$k++])$r|=$argn%$i|$$i++;echo!$r;

作为管道运行-nR或在线测试。空输出代表虚假，1真实。

分解

while($i=$argn[$k++])   # loop through digits
    $r|=                    # set $r to true if
        $argn%$i            # 1. number is not divisible by $i
        |$$i++;             # 2. or digit has been used before
echo!$r;                # print negated $r

Haskell，61个字节

(#)=<<show
(d:r)#n=notElem d r&&mod n(read[d])<1&&r#n
_#_=0<3

在线尝试！

定义一个匿名函数(#)=<<show，给定一个数字，该函数返回True或False。

05AB1E，4个字节

ÑÃÙQ

在线尝试！

与此算法相关的问题的答案相同。

05AB1E，8个字节

SÖP¹DÙQ*

使用05AB1E编码。在线尝试！

Mathematica，57个字节

Tr@Boole[IntegerQ/@Union[s=#/IntegerDigits@#]]==Length@s&

Python 2，66字节

这是Python 2中的解决方案，其全部目的是为了输出True真实性和False虚假性：

lambda n:len(set(n))==len(n)and not any((int(n)%int(x)for x in n))

在线尝试！

Haskell中，260个 241 201 162字节

f([x])=1<2
f(x:xs)=not(x`elem`xs)&&(f xs)
r n i= n`mod`(read[(show n!!i)]::Int)==0
q n 0=r n 0 
q n i=r n i&&q n(i-1)
p n=length(show n)-1
s n=q n(p n)&&f(show n)

说明

f ([x]) = True                                           f function checks for                                                       
f (x:xs) = not(x `elem` xs) && (f xs)                    repeated digits              
r n i = n `mod` (read [(show n !! i)] :: Int) == 0       checks whether num is 
                                                         divisible by i digit
q n 0 = r n 0                                            checks wether n divisible
q n i = r n i && q n (i-1)                               by all of its digits                             
p n = length (show n) -                                  gets length of number                             
s n = (q n (p n)) && (f (show n))                        sums it all up!!!

大大缩短了到Laikoni的 thanx

Japt，15 14 11 10 9 字节

ì®yUÃ¥Uìâ

试试吧

Neim，9个字节

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

在线尝试！

-2感谢Okx.

嗯，对称性很好... oO.O.O.Oo

Perl 6，27个字节

{$_%%.comb.all&&[!=] .comb}

在线尝试！

• .comb是一种方法，当不提供任何参数时，它将字符串拆分成各个字符。数字被隐式转换为字符串，因此.comb返回其数字。
• .comb.all 是所有数字的和。
• $_ %% .comb.all是输入参数$_的所有数字可整除的和。例如，如果$_is 123，则结点为all(True, False, True)，False在真实上下文中会崩溃为。
• [!=] .comb用!=运算符减少输入参数的位数，该运算符将求出True位数是否全部不同。

视网膜，37字节

(.).*\1
0
.
<$&$*1>$_$*
<(1+)>\1+

^$

在线尝试！链接包括测试用例。说明：第一阶段将任何重复的数字替换为零。第二阶段将每个数字替换为其一元表示形式，然后是原始数字的一元表示形式。然后，第三阶段计算原始数字除以每个非零数字的余数。如果该号码是Lynch-Bell号码，则它将删除所有内容，并在最后阶段对其进行测试。

Ruby 2.4，42个字节

->x{(r=x.digits)|[]==r&&r.none?{|f|x%f>0}}

（尚未发布TIO，对不起）

CJam，17个字节

CJam是高尔夫语言的Java。它甚至用Java解释！

{_Ab__L|=@@f%:+>}

说明：

{   e# Stack:              3915
_   e# Duplicate:          3915 3915
Ab  e# Digits in base 10:  3915 [3 9 1 5]
__  e# Duplicate twice:    3915 [3 9 1 5] [3 9 1 5] [3 9 1 5]
L|  e# Remove duplicates:  3915 [3 9 1 5] [3 9 1 5] [3 9 1 5]
=   e# Test equality:      3915 [3 9 1 5] 1
@@  e# Rotate twice:       1 3915 [3 9 1 5]
f%  e# Modulo each:        1 [0 0 0 0]
:+  e# Sum:                1 0
>   e# Greater than:       1
}   e# Output:             1 (truthy)

VBScript，177字节

嘿，这是我的第一篇CG文章，也是第一次尝试，所以希望我遵循所有规则...

Function L(s)
dim i,j,k,m,n
j = Len(s)
redim a(j)
n = 0
for i = 0 to j-1
   A(i) = Mid(s,i+1,1)   
   m = m + s Mod A(i)   
   if j = 1 then         
   else                             
        for k = 0 to i - 1        
            if A(i)  = A(k) then n = n + 1   
        next
   end if
next
if m + n = 0 then L = "y" else L = "n"
End Function

可以在记事本中运行，方法是在末尾添加一行

Msgbox L(InputBox(""))

然后将其另存为.vbs，然后双击。

说明：

Function L(s)                  'creates the function "L" taking test number as input
dim i,j,k,t,m,n                'variables
j = Len(s)                     '"j" gets length of test number
redim a(j)                     'creates array "a", size is length of test number 
n = 0                          'sets repeat character counter "n" to zero
for i = 0 to j-1               'for length of string
   A(i) = Mid(s,i+1,1)         'each array slot gets one test number character
   m = m + s Mod A(i)          '"m" accumulates moduli as we test divisibility of each digit
   if j = 1 then               'if test number is of length 1, it passes (do nothing)
   else                        'otherwise, gotta test for repeats     
        for k = 0 to i - 1     'for each digit already in array, test against current digit   
            if A(i)  = A(k) then n = n + 1  
                               'repeat char counter "n" stores no of repeats  
        next                   'proceed through array looking for repeat  
   end if
next                           'test next digit for divisibility and repeats
if m + n = 0 then L = "y" else L = "n"      
                               'check for any repeats and moduli,
                               'then return yes or no for LynchBelledness
End Function

VBScript是打高尔夫球的钝器，但是，我还没学过Ruby ...

PHP，51字节

打印零为真，打印为假

for(;$c=$argn[$i++];$$c=1)$t|=$$c||$argn%$c;echo$t;

在线尝试！

的PHP，62字节

打印零为真，打印为假

for($a=$argn;$c=$a[$i];)$t|=strpos($a,$c)<+$i++||$a%$c;echo$t;

在线尝试！

Pyth，10个字节

qiRQKjQT{K

验证所有测试用例。

怎么样？

qiRQKjQT {K〜完整程序。

     jQT〜输入的十进制数字列表。
    K〜分配给变量K。
 iRQ〜每个十进制数字...
 i Q〜...通过输入本身获得最大的公约数。
        {K〜K，删除重复元素。
q〜是否相等？隐式输出。

Pyth，11个字节

&!f%sQsTQ{I

验证所有测试用例。

怎么样？

＆！f％sQsTQ {I〜完整程序，带有隐式输入。

  f Q〜过滤输入字符串。
   ％sQsT〜将输入转换为当前数字取模的整数。
             〜如果大于0，则保留它，否则将其丢弃。
 ！〜否定。如果列表为空，则返回True，否则返回False。
＆{I〜重复数据删除过程中的输入不变吗？隐式输出。

Perl 5，34个字节

33个字节的代码+ 1个-p标志

$n=$_;$\|=$n%$_|$k{$_}++for/./g}{

在线尝试！

输出0为真，任何其他数字为假

科特林 1.1，98 66 59个字节

{i->i.none{i.toInt()%(it-'0')>0}&&i.length==i.toSet().size}

美化

{i ->
    // None of the digits are not factors
    i.none { i.toInt() % (it-'0') > 0 }
    // AND
    &&
    // None of the digits are repeated
    i.length == i.toSet().size
}

测试

var L:(String)-> Boolean =
{i->i.none{i.toInt()%(it-'0')>0}&&i.length==i.toSet().size}
data class TestData(val input: String, val output: Boolean)

fun main(args: Array<String>) {
    var inputs = listOf(
        TestData("7", true),
        TestData("126", true),
        TestData("54", false),
        TestData("55", false),
        TestData("3915", true)
    )

    for (test in inputs) {
        if (L(test.input) != test.output) {
            throw AssertionError(test.toString())
        }
    }
    println("Test Passed")
}

APL（Dyalog Unicode），24字节

{((,⍵)≡∪⍵)×∧/0=(⍎¨⍵)|⍎⍵}

在线尝试！

简单的Dfn，可能还会打更多的高尔夫球。收益标准APL为真，布尔值为1，对于虚假为0。

值得一提的是，该函数将参数作为字符串而不是整数。

怎么样：

{((,⍵)≡∪⍵)×∧/0=(⍎¨⍵)|⍎⍵} ⍝ Dfn, argument ⍵.
                      ⍎⍵  ⍝ Convert ⍵ to integer
                     |    ⍝ Modulus
                (⍎¨⍵)     ⍝ Each digit in ⍵
              0=          ⍝ Equals 0? Returns a vector of booleans
            ∧/            ⍝ Logical AND reduction
           ×              ⍝ multiplied by (the result of)
  (     ∪⍵)               ⍝ unique elements of ⍵
       ≡                  ⍝ Match
   (,⍵)                   ⍝ ⍵ as a vector; the Match function then returns 1 iff all digits in ⍵ are unique

朱莉娅 1.0，39字节

f(x,d=digits(x))=rem.(x,d)==0*unique(d)

rem.(x,d)是一个向量，其中包含x除以中的每个数字后的余数x。0*unique(d)是一个向量，长度等于唯一数字的个数，所有值均为零。检查它们是否相等。

在线尝试！

ruby -n，40个字节

p gsub(/./){$'[$&]||$_.to_i%$&.hex}<?0*8

在线尝试！

以数字形式读入数字。将每个字符（数字）替换为该字符（如果存在）的后续出现，或以该数字为模的整数。0当且仅当这是一个Lynch-Bell数字时，这将导致仅s 的字符串。为什么？如果存在重复的数字，则最后一个实例的每个实例均保持不变，并且由于输入不包含零，因此表示一个非零数字。否则，我们只是在检查每个数字是否均分数字。

由于没有8位数或更多的Lynch-Bell数字（正式证明：OEIS如此说），因此，在字典上检查所得字符串是否早于该字符串'00000000'，等同于检查其是否均为零。

R，86字节

x=scan(,'');a=as.double;all(table(utf8ToInt(x))==1)&&all(!a(x)%%a(el(strsplit(x,""))))

将输入作为字符串。我当然觉得这是可以打高尔夫球的。

在线尝试！