Is it a Lynch-Bell number? You will be given a positive, whole number (that will never contain a 0) as input. Your task is to check whether it is a Lynch-Bell number or not.

A number is a Lynch-Bell number if all of its digits are unique and the number is divisible by each of its digits.

In fact, there are actually only 548 Lynch-Bell numbers, so hard-coding is a possibility, but will almost certainly be longer.

126 is a Lynch-Bell number because all of its digits are unique, and 126 is divisible by 1, 2, and 6.

You can output any truthy and falsy value.

Examples:

7 -&gt; truthy
126 -&gt; truthy
54 -&gt; falsy
55 -&gt; falsy
3915 -&gt; truthy


This is OEIS A115569.
Mathematica, 42 bytes

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


I think 0!=##&amp;@@d&amp;&amp;##&amp;@@ is a new low in readability for Mathematica...

Explanation

Some of the basic syntactic sugar used here:


&amp; has very low precedence and turns everything left of it into an unnamed function.
&amp;&amp; is just the And operator.
# is the argument of the nearest enclosing unnamed function.
## is a sequence of all of the function's arguments.
@ is prefix notation for function calls, i.e. f@x == f[x].
@@ is Apply, which passes the elements of a list as individual arguments to a function, i.e. f@@{a,b,c} == f[a,b,c].


With that out of the way...

(d=IntegerDigits@#)


This should be fairly self-explanatory: this gives us a list of the input's decimal digits and stores the result in d.

(...∣#)


This tests the input for divisibility by each of its digits (because the divisibility operator is Listable). This gives us a list of Trues and Falses.

...&amp;@@...


We apply the function on the left-hand side to the list of booleans, such that each boolean is a separate argument.

...&amp;@@d


We apply another function to d, so that the individual digits are given as separate arguments. The function is 0!=##&amp;, i.e. Unequal[0, d1, d2, ...]. It checks that all the digits are distinct (and that they are distinct from 0 but that's given by the challenge, and if it wasn't, it wouldn't be a divisor anyway). 0!=##&amp; is really just a 1-byte saver on using Unequal itself, and it works because there's a 1-byte element (0) that we know is not present. So this first thing checks that the digits are unique. Let's call this result U

...&amp;&amp;##


Again, this is really just shorthand for And[U, ##]. With ## being a sequences, the individual booleans from the initial divisibility check are expanded into the And, so we get And[U, d1∣n, d2∣n, ...] which checks that both the digits are unique and each digit divides the input.