Bạn sẽ được cung cấp một số nguyên, dương (sẽ không bao giờ chứa 0) làm đầu vào. Nhiệm vụ của bạn là kiểm tra xem đó có phải là số Lynch-Bell hay không.

Số là số Lynch-Bell nếu tất cả các chữ số của nó là duy nhất và số này chia hết cho mỗi chữ số của nó.

Trên thực tế, thực tế chỉ có 548 số Lynch-Bell, vì vậy mã hóa cứng là một khả năng, nhưng gần như chắc chắn sẽ dài hơn.

126 là số Lynch-Bell vì tất cả các chữ số của nó là duy nhất và 126 chia hết cho 1, 2 và 6.

Bạn có thể xuất bất kỳ giá trị trung thực và giả.

Ví dụ:

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

Đây là OEIS A115569 .

Toán học, 42 byte

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

Tôi nghĩ 0!=##&@@d&&##&@@là mức độ dễ đọc mới đối với Mathicala ...

Giải trình

Một số đường cú pháp cơ bản được sử dụng ở đây:

• & có độ ưu tiên rất thấp và biến mọi thứ còn lại của nó thành một chức năng không tên.
• &&chỉ là Andnhà điều hành.
• # là đối số của hàm không tên kèm theo gần nhất.
• ##là một chuỗi tất cả các đối số của hàm.
• @là ký hiệu tiền tố cho các cuộc gọi chức năng, tức là f@x == f[x].
• @@là Apply, nó chuyển các phần tử của một danh sách dưới dạng các đối số riêng lẻ cho một hàm, nghĩa là f@@{a,b,c} == f[a,b,c].

Với cách đó ...

(d=IntegerDigits@#)

Điều này khá tự giải thích: điều này cung cấp cho chúng tôi danh sách các chữ số thập phân của đầu vào và lưu kết quả vào d.

(...∣#)

Điều này kiểm tra đầu vào cho khả năng chia hết cho từng chữ số của nó (bởi vì toán tử chia là Listable). Điều này cho chúng tôi một danh sách của Trues và Falses.

...&@@...

Chúng tôi áp dụng hàm ở phía bên trái vào danh sách các booleans, sao cho mỗi boolean là một đối số riêng.

...&@@d

Chúng tôi áp dụng một hàm khác để dcác chữ số riêng lẻ được đưa ra dưới dạng các đối số riêng biệt. Các chức năng là 0!=##&, tức là . Nó kiểm tra xem tất cả các chữ số có khác biệt không (và chúng khác biệt với nhưng được đưa ra bởi thử thách và nếu không, nó sẽ không phải là một ước số). thực sự chỉ là trình tiết kiệm 1 byte khi sử dụng chính nó và nó hoạt động vì có phần tử 1 byte ( ) mà chúng ta biết là không có. Vì vậy, điều đầu tiên này kiểm tra rằng các chữ số là duy nhất. Hãy gọi kết quả nàyUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Một lần nữa, đây thực sự chỉ là tốc ký cho And[U, ##]. Với ##việc là một chuỗi, các booleans riêng lẻ từ kiểm tra chia hết ban đầu được mở rộng thành And, do đó chúng ta sẽ kiểm tra xem cả hai chữ số là duy nhất và mỗi chữ số chia đầu vào.And[U, d1∣n, d2∣n, ...]

Python 3 , 56 byte

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

Hãy thử trực tuyến!

Đầu ra Falsenếu nó là một con số Lynch-Bell, Truebằng cách khác.

Brachylog , 10 byte

≠g;?z%ᵐ=h0

Hãy thử trực tuyến!

Giải trình

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

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

^{Tôi đã viết nó trong notepad trước khi thử nghiệm trong Visual Studio, nơi nó hoạt động tốt, vì vậy tôi nhận ra rằng bây giờ tôi đã ở mức độ mọt sách ...}

Phiên bản đầy đủ / định dạng:

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 byte

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

Lấy đầu vào dưới dạng một chuỗi và trả về truehoặc falsekhi thích hợp. Chỉnh sửa: Đã lưu 1 byte nhờ @RickHitchcock. Các phiên bản khác:

Lấy đầu vào dưới dạng một chuỗi và trả về 0hoặc 1(nghĩa là nghịch đảo logic) cho 40 byte:

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

Lấy đầu vào dưới dạng số và trả về 0hoặc 1cho 43 byte:

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

Lấy đầu vào dưới dạng số và trả về 1hoặc 0cho 45 byte:

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

Thạch , 6 4 byte

Dg⁼Q

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

Trả về Falsekhi một số là số Lynch-Bell. Lấy chuỗi làm đầu vào. Tự mình đến nhưng rất giống với Rod. Tôi đã bình luận dưới bài viết của anh ấy nhưng tôi chưa có tiếng tăm nào.

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

Hãy thử trực tuyến!

Thạch , 8 byte

D⁼QaDḍ$Ạ

Hãy thử trực tuyến!

PHP, 62 48 byte

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

Chạy như ống với -nRhoặc kiểm tra nó trực tuyến . Đầu ra trống cho giả, 1cho sự thật.

phá vỡ

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 byte

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

Hãy thử trực tuyến!

Xác định một hàm ẩn danh (#)=<<show, cho một số, trả về Truehoặc False.

05AB1E , 4 byte

ÑÃÙQ

Hãy thử trực tuyến!

Thuật toán tương tự như câu trả lời này cho một câu hỏi liên quan .

05AB1E , 8 byte

SÖP¹DÙQ*

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Toán học, 57 byte

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

Python 2 , 66 byte

Đây là một giải pháp trong Python 2, với toàn bộ mục đích là đầu ra Truecho sự thật và giả mạo False:

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

Hãy thử trực tuyến!

Haskell, 260 241 201 162 byte

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)

Giải trình

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

Đã rút ngắn đáng kể sox đến Laikoni

Japt, 15 14 11 10 9 bytes

ì®yUÃ¥Uìâ

Try it

Neim, 9 bytes

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Try it online!

-2 thanks to Okx.

Hmm, there's a nice symmetry... oO.O.O.Oo

Perl 6, 27 bytes

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

Try it online!

• .comb is a method which, when given no arguments, splits a string into its individual characters. A number is implicitly converted into a string, and so .comb returns its digits.
• .comb.all is an and-junction of all of the digits.
• $_ %% .comb.all is an and-junction of the divisibility of the input argument $_ by all of its digits. For example, if $_ is 123, the junction is all(True, False, True), which collapses to False in a truthy context.
• [!=] .comb reduces the digits of the input argument with the != operator, which evaluates to True if the digits are all different.

Retina, 37 bytes

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

^$

Try it online! Link includes test cases. Explanation: The first stage replaces any duplicate digit with a zero. The second stage replaces each digit with its unary representation followed by the unary representation of the original number. The third stage then computes the remainder of the division of original number by each non-zero digit. If the number is a Lynch-Bell number then this will delete everything and this is tested for by the final stage.

Ruby 2.4, 42 bytes

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

(No TIO yet, sorry)

CJam, 17 bytes

CJam is the Java of golfing languages. It's even interpreted in Java!

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

Explanation:

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

Hey all, this is my very first CG post, and first attempt, so hope I followed all the rules...

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

This can be run from Notepad by adding a line at the end

Msgbox L(InputBox(""))

And then saving it as .vbs, then double click.

Explanation:

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 is a bit of blunt instrument for golfing, but hey, I haven't learned Ruby yet...

PHP, 51 bytes

prints zero for true and one for false

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

Try it online!

PHP, 62 bytes

prints zero for true and one for false

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

Try it online!

Pyth, 10 bytes

qiRQKjQT{K

Verify all the test cases.

How?

qiRQKjQT{K  ~ Full program.

     jQT    ~ The list of decimal digits of the input.
    K       ~ Assign to a variable K.
 iRQ        ~ For each decimal digit...
 i Q          ~ ... Get the greatest common divisor with the input itself.
        {K  ~ K with the duplicate elements removed.
q           ~ Is equal? Output implicitly.

Pyth, 11 bytes

&!f%sQsTQ{I

Verify all the test cases.

How?

&!f%sQsTQ{I  ~ Full program, with implicit input.

  f     Q    ~ Filter over the input string.
   %sQsT     ~ The input converted to an integer modulo the current digit.
             ~ Keeps it if it is higher than 0, and discards it otherwise.
 !           ~ Negation. If the list is empty, returns True, else False.
&        {I  ~ And is the input invariant under deduplicating? Output implicitly.

Perl 5, 34 bytes

33 bytes of code + 1 for -p flag

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

Try it online!

Outputs 0 for truthy, any other number for falsy

Kotlin 1.1, 98 66 59 bytes

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

Test

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 bytes

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

Try it online!

Simple Dfn, can probably be golfed a bit more. Yield standard APL booleans 1 for truthy, 0 for falsy.

It's worth to mention that the function takes the arguments as strings rather than ints.

How:

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

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

rem.(x,d) is a vector containing the remainders after dividing x by each digit in x. 0*unique(d) is a vector with length equal to the number of unique digits, with all zero values. Check if they are equal.

Try it online!

ruby -n, 40 bytes

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

Try it online!

Read in the number as a string. Substitute each character (digit) with a subsequent occurrence of that character, if present, or the whole number modulo that digit. This will result in a string of only 0s if and only if this is a Lynch-Bell number. Why? If there's a repeated digit, every instance of the last stays the same, and since the input doesn't contain zeroes that means a non-zero digit. Otherwise, we're just checking whether every digit evenly divides the number.

Since there are no 8-or-more-digit Lynch-Bell numbers (formal proof: OEIS says so), checking whether the resulting string is lexicographically earlier than the string '00000000' is equivalent to checking whether it's all zeroes.

R, 86 bytes

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

Takes input as a string. I certainly feel like this is golfable.

Try it online!