Girdi olarak size pozitif, tam bir sayı (asla 0 içermeyecek) verilecektir. Göreviniz bunun bir Lynch-Bell numarası olup olmadığını kontrol etmektir.

Sayı, tüm basamakları benzersizse ve sayı, her bir basamak tarafından bölünebiliyorsa, bir Lynch-Bell sayısıdır.

Aslında, sadece 548 Lynch-Bell numarası var, bu nedenle kodlama bir olasılık, ancak neredeyse kesinlikle daha uzun olacak.

126 bir Lynch-Bell numarasıdır çünkü tüm rakamları benzersizdir ve 126, 1, 2 ve 6 ile bölünebilir.

Herhangi bir gerçeği ve sahte değeri çıkartabilirsiniz.

Örnekler:

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

Bu, OEIS A115569 .

Mathematica, 42 bayt

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

Bence 0!=##&@@d&&##&@@Mathematica'da okunabilirlikte yeni bir düşük ...

açıklama

Burada kullanılan temel sözdizimsel şekerlerden bazıları:

• & önceliği çok düşüktür ve kalan her şeyi adsız bir işleve dönüştürür.
• &&sadece Andoperatör.
• # En yakın çevreleyen adsız işlevin argümanıdır.
• ##fonksiyonun tüm argümanlarının bir dizisidir .
• @işlev çağrıları için önek notasyonu, yani f@x == f[x].
• @@olduğu Apply, yani bir fonksiyonu tek tek, bağımsız değişken olarak bir listesinin elemanları geçtiği, f@@{a,b,c} == f[a,b,c].

Bunun dışında ...

(d=IntegerDigits@#)

Bu oldukça açıklamalı olmalı: bu bize girişin ondalık basamaklarının bir listesini verir ve sonucu saklar d.

(...∣#)

Bu, bölünebilirlik girişini her bir basamak tarafından test eder (bölünebilirlik operatörü olduğu için Listable). Bu bize Trues ve Falses listesini verir .

...&@@...

Sol taraftaki işlevi, her bir boole ayrı bir argüman olacak şekilde boole listesine uygularız.

...&@@d

dBireysel basamaklara ayrı argümanlar olarak verilecek şekilde başka bir işlev uygularız . İşlev 0!=##&, yani . Tüm rakamların farklı olup olmadığını kontrol eder (ve onlardan farklı olduklarını, ancak zorluk tarafından verildiğini ve eğer olmasaydı, zaten bölen bir bölen olamazdı). gerçekten kendini kullanma konusunda sadece 1 baytlık bir koruyucudur ve çalıştığını bildiğinden 1 baytlık bir öğe ( ) olduğu için çalışır . Yani bu ilk şey, rakamların benzersiz olup olmadığını kontrol eder. Bu sonucu diyelimUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Yine, bu gerçekten sadece steno And[U, ##]. İle ##bir sekansları olan, ilk bölünebilme kontrol tek tek Boolean genişletilir Andbiz olsun, her iki basamak benzersiz ve her rakam giriş böler olan kontrol eder.And[U, d1∣n, d2∣n, ...]

Python 3 , 56 bayt

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

Çevrimiçi deneyin!

Çıktı Falseo olmazsa, bir Lynch-Çan numarası IS Trueaksi.

Brachylog , 10 bayt

≠g;?z%ᵐ=h0

Çevrimiçi deneyin!

açıklama

≠             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 bayt

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

^{Bunu Visual Studio'da test etmeden önce not defterine yazdım, iyi çalıştığı yerdeydi, şimdi fark ettim ki şu an nerd ...}

Tam / Biçimli Sürüm:

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 bayt

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

Girdiyi dizge olarak alır ve döndürür trueveya falseuygun şekilde. Düzenleme: @RickHitchcock sayesinde 1 bayt kaydedildi. Diğer sürümler:

Bir dize olarak girdi alır ve 40 bayt için 0veya 1(yani mantıksal ters) döndürür :

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

Bir sayı ve getiri olarak girdi Alır 0veya 143 bayt için:

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

Bir sayı ve döner gibi girdi alır 1ya da0 45 bayt için:

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

Jöle , 6 4 bayt

Dg⁼Q

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

İade FalseBir sayının Lynch-Çan sayı olduğu zaman. Dizeleri girdi olarak alır. Tek başıma geldi ama Rod'unkine çok benzer. Onun görevi altında yorum yapardım, ancak henüz hiç ünüm yok.

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

Çevrimiçi deneyin!

Jöle , 8 bayt

D⁼QaDḍ$Ạ

Çevrimiçi deneyin!

PHP, 62 48 bayt

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

İle boru olarak çalıştır -nR veya çevrimiçi olarak test edin . Sahte için boş çıktı, gerçek 1için.

Yıkmak

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 bayt

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

Çevrimiçi deneyin!

(#)=<<showSayı verilen Trueveya döndüren adsız bir işlevi tanımlar False.

05AB1E , 4 bayt

ÑÃÙQ

Çevrimiçi deneyin!

İlgili bir soruya bu cevap ile aynı algoritma .

05AB1E , 8 bayt

SÖP¹DÙQ*

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Mathematica, 57 bayt

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

Python 2 , 66 bayt

Bu, tüm amacı Truehakikat ve sahtekarlık için çıktı üretmek olan Python 2'deki bir çözümdür False:

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

Çevrimiçi deneyin!

Haskell, 260 241 201 162 bayt

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)

açıklama

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 için önemli ölçüde kısaltmak var

Japt , 15 14 11 10 9 bayt

ì®yUÃ¥Uìâ

Dene

Neim , 9 bayt

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Çevrimiçi deneyin!

-2 sayesinde Okx .

Güzel bir simetri var ... oO.O.O.Oo

Perl 6 , 27 bayt

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

Çevrimiçi deneyin!

• .combhiçbir argüman verilmediğinde, bir dizeyi kendi karakterlerine bölen bir yöntemdir. Sayı, örtük olarak bir dizgeye dönüştürülür ve.comb rakamlarını döndürür.
• .comb.all ve tüm rakamların bir birleşimidir.
• $_ %% .comb.allve giriş argümanının $_tüm rakamlarıyla bölünebilirliğinin bir birleşimidir . Örneğin, $_bir 123, bağlantı olup all(True, False, True), için katlandığıFalse bir truthy bağlamında.
• [!=] .comb!=işleci ile giriş argümanının rakamlarını azaltır, Truebu rakamların hepsinin farklı olup olmadığını değerlendirir .

Retina , 37 bayt

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

^$

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama: İlk aşamada yinelenen herhangi bir rakam sıfırla değiştirilir. İkinci aşama, her bir basamağın yerine tek tek gösterimi, ardından asıl sayının tek başına gösterimi ile değiştirilir. Üçüncü aşama, orijinal sayının sıfır olmayan her bir rakam ile bölünmesinin kalanını hesaplar. Sayı bir Lynch-Bell numarasıysa, bu her şeyi silecek ve bu son aşamada test edilecektir.

Yakut 2.4, 42 bayt

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

(Henüz TIO yok, üzgünüm)

CJam, 17 bayt

CJam, golf dillerinin Java'sıdır. Java'da bile yorumlanmış!

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

Açıklama:

{   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 bayt

Herkese selam, bu benim ilk CG yazım ve ilk denemem, umarım tüm kuralları takip etmişimdir ...

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

Bu, sonuna bir satır ekleyerek Not Defteri'nden çalıştırılabilir.

Msgbox L(InputBox(""))

Ve sonra .vbs olarak kaydedin, ardından çift tıklayın.

Açıklama:

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 golf oynamak için biraz kör bir enstrümandır, ancak hey, Ruby'yi henüz öğrenmedim ...

PHP , 51 bayt

doğru için sıfır, yanlış için bir tane yazdırır

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

Çevrimiçi deneyin!

PHP , 62 bayt

doğru için sıfır, yanlış için bir tane yazdırır

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

Çevrimiçi deneyin!

Pyth , 10 bayt

qiRQKjQT{K

Tüm test durumlarını doğrulayın.

Nasıl?

qiRQKjQT {K ~ Tam program.

     jQT ~ Girişin ondalık basamağının listesi.
    K ~ K değişkenine atayın
 iRQ ~ Her ondalık basamak için ...
 i Q ~ ... Girdiyle birlikte en büyük ortak böleni alın.
        {K ~ K kopya elemanlar kaldırıldı.
q ~ Eşittir? Örtük olarak çıktı ver.

Pyth , 11 bayt

&!f%sQsTQ{I

Tüm test durumlarını doğrulayın.

Nasıl?

&! f% sQsTQ {I ~ Tam giriş, örtülü giriş.

  f Q ~ Giriş dizgisi üzerinde filtre uygulayın.
   % sQsT ~ Geçerli basamaktaki bir tamsayı modüle dönüştürülmüş girdi.
             ~ 0'dan yüksekse onu tutar ve aksi takdirde atar.
 ! ~ Olumsuzluk. Liste boşsa, True, false değerini döndürür.
& {I ~ Ve girdi veri tekilleştirme altında değişmez mi? Örtük olarak çıktı ver.

Perl 5 , 34 bayt

-pBayrak için +1 kodunun 33 bayt

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

Çevrimiçi deneyin!

Çıkışlar 0truthy için, falsy başka bir numara

Kotlin 1.1, 98 66 59 bayt

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

Beautified

{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
}

Ölçek

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 bayt

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

Çevrimiçi deneyin!

Basit Dfn, muhtemelen biraz daha golf oynayabilir. Verim standardı APL booleans truthy için 1, falsy için 0'dır.

İşlevin argümanları ints yerine string olarak aldığından bahsetmeye değer.

Nasıl:

{((,⍵)≡∪⍵)×∧/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

Julia 1.0 , 39 bayt

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

rem.(x,d)x 'in her bir basamağa bölünmesinden sonra kalanları içeren bir vektördür x. 0*unique(d)sıfır değerleriyle, benzersiz basamak sayısına eşit uzunluktaki bir vektördür. Eşit olup olmadıklarını kontrol edin.

Çevrimiçi deneyin!

yakut -n , 40 bayt

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

Çevrimiçi deneyin!

Sayıyı bir dize olarak okuyun. Varsa her karakteri (basamak), sonradan bu karakterin ardından veya bu rakamın modulosunu değiştirerek değiştirin. Bu sadece bir 0s dizisine neden olur ve eğer bu sadece bir Lynch-Bell numarasıysa. Niye ya? Tekrarlanan bir rakam varsa, her son örneği aynı kalır ve giriş sıfır içermediğinden, sıfır olmayan rakam anlamına gelir. Aksi takdirde, sadece her basamağın sayının eşit şekilde bölünüp bölünmediğini kontrol ediyoruz.

8 ya da daha fazla basamaklı Lynch-Bell numarası olmadığından (resmi kanıt: OEIS öyle diyor), sonuçta elde edilen dizgenin dizgeden sözlü olarak daha erken '00000000'olup olmadığını kontrol etmek, sıfır olup olmadığını kontrol etmeye eşdeğerdir.

R , 86 bayt

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

Bir dize olarak girdi alır. Kesinlikle golf oynamak gibi hissediyorum.

Çevrimiçi deneyin!