入力として正の整数（決して0を含まない）が与えられます。あなたの仕事は、それがリンチベル番号かどうかをチェックすることです。

すべての数字が一意であり、数字が各数字で割り切れる場合、数字はリンチベルの数字です。

実際、リンチベルの数は実際には548個しかないため、ハードコーディングは可能ですが、ほぼ確実に長くなります。

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]。
• @@はApply、リストの要素を個々の引数として関数に渡しf@@{a,b,c} == f[a,b,c]ます。

邪魔にならないように...

(d=IntegerDigits@#)

これはかなり自明なはずです。これにより、入力の10進数のリストが得られ、結果がに格納され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でテストする前にメモ帳でこれを書きましたが、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、または143バイトの場合：

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

数戻るように入力を受け取り1、または045バイトの場合：

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、54バイト

False数値がLynch-Bell番号の場合に戻ります。入力として文字列を受け取ります。独力でやってきたが、Rodに非常に似ていた。私は彼の投稿の下でコメントしたでしょうが、まだ評判はありません。

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 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!!!

ライコニへの感謝を大幅に短縮した

Japt、15 14 11 10 9 バイト

ì®yUÃ¥Uìâ

それを試してみてください

ニーム、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 truthyコンテキストです。
• [!=] .comb入力引数の数字を!=演算子で減らします。演算子Trueは数字がすべて異なる場合に評価します。

網膜、37バイト

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

^$

オンラインでお試しください！リンクにはテストケースが含まれます。説明：第1段階では、重複する数字をゼロに置き換えます。2番目の段階では、各桁が単項表現に置き換えられ、その後に元の数値の単項表現が続きます。次に、第3ステージでは、元の数値をゼロ以外の数字で除算した残りの部分を計算します。番号がリンチベル番号である場合、これによりすべてが削除され、最終段階でテストされます。

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バイト

trueの場合は0、falseの場合は1を出力します

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

オンラインでお試しください！

PHP、62バイト

trueの場合は0、falseの場合は1を出力します

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

オンラインでお試しください！

Pyth、10バイト

qiRQKjQT{K

すべてのテストケースを確認します。

どうやって？

qiRQKjQT {K〜完全なプログラム。

     jQT〜入力の10進数のリスト。
    K〜変数Kに割り当てます。
 iRQ〜10進数ごとに...
 i Q〜...入力自体で最大公約数を取得します。
        {K〜K重複する要素を削除します。
q〜等しいか？暗黙的に出力します。

Pyth、11バイト

&!f%sQsTQ{I

すべてのテストケースを確認します。

どうやって？

＆！f％sQsTQ {I〜完全なプログラム、暗黙的な入力あり。

  f Q〜入力文字列をフィルターします。
   ％sQsT〜現在の桁を法とする整数に変換された入力。
             〜0より大きい場合は保持し、それ以外の場合は破棄します。
 ！〜否定。リストが空の場合はTrueを返し、そうでない場合はFalseを返します。
＆{I〜そして、重複排除の下で入力不変はありますか？暗黙的に出力します。

Perl 5、34バイト

33バイトのコード+ -pフラグ 用の1

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

オンラインでお試しください！

0真実の出力、偽のその他の数値

Kotlin 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を返します。

関数が引数をintではなく文字列としてとることに言及する価値があります。

どうやって：

{((,⍵)≡∪⍵)×∧/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桁以上のリンチベル番号がないため（正式な証明：OEISによると）、結果の文字列が辞書式に文字列より早い'00000000'かどうかを確認することは、すべてゼロかどうかを確認することと同等です。

R、86バイト

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

入力を文字列として受け取ります。確かにこれはゴルフができると感じています。

オンラインでお試しください！