Sie erhalten eine positive ganze Zahl (die niemals eine 0 enthält) als Eingabe. Ihre Aufgabe ist es zu überprüfen, ob es sich um eine Lynch-Bell-Nummer handelt oder nicht.

Eine Zahl ist eine Lynch-Bell-Zahl, wenn alle Ziffern eindeutig sind und die Zahl durch jede Ziffer teilbar ist.

Tatsächlich gibt es nur 548 Lynch-Bell-Nummern. Eine Hardcodierung ist also möglich, wird aber mit ziemlicher Sicherheit länger dauern.

126 ist eine Lynch-Bell-Zahl, da alle Ziffern eindeutig sind und 126 durch 1, 2 und 6 teilbar ist.

Sie können jeden wahrheitsgemäßen und falschen Wert ausgeben.

Beispiele:

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

Dies ist OEIS A115569 .

Mathematica, 42 Bytes

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

Ich denke, 0!=##&@@d&&##&@@Mathematica hat eine neue Lesbarkeitsschwäche ...

Erläuterung

Einige der hier verwendeten syntaktischen Grundzucker:

• & hat eine sehr niedrige Priorität und verwandelt alles, was davon übrig bleibt, in eine unbenannte Funktion.
• &&ist nur der AndBetreiber.
• # ist das Argument der nächsten umschließenden unbenannten Funktion.
• ##ist eine Folge aller Argumente der Funktion.
• @ist die Präfixnotation für Funktionsaufrufe, dh f@x == f[x].
• @@ist Apply, das die Elemente einer Liste als einzelne Argumente an eine Funktion übergibt, dh f@@{a,b,c} == f[a,b,c].

Damit aus dem Weg ...

(d=IntegerDigits@#)

Dies sollte ziemlich selbsterklärend sein: Dies gibt uns eine Liste der Dezimalstellen der Eingabe und speichert das Ergebnis in d.

(...∣#)

Dies testet die Eingabe auf Teilbarkeit durch jede ihrer Ziffern (weil der Teilbarkeitsoperator ist Listable). Dies gibt uns eine Liste von Trues und Falses.

...&@@...

Wir wenden die Funktion auf der linken Seite auf die Liste der Booleschen Werte an, sodass jeder Boolesche Wert ein separates Argument ist.

...&@@d

Wir wenden eine andere Funktion an d, so dass die einzelnen Ziffern als separate Argumente angegeben werden. Die Funktion ist 0!=##&, dh . Es prüft, ob alle Ziffern verschieden sind (und ob sie verschieden sind von, aber das ist durch die Herausforderung gegeben, und wenn es nicht so wäre, wäre es sowieso kein Divisor). ist wirklich nur ein 1-Byte-Sparer bei der Verwendung von sich selbst, und es funktioniert, weil es ein 1-Byte-Element ( ) gibt, von dem wir wissen, dass es nicht vorhanden ist. Das erste, was überprüft, dass die Ziffern eindeutig sind. Nennen wir dieses ErgebnisUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Auch dies ist wirklich nur eine Abkürzung für And[U, ##]. Da ##es sich um eine Sequenz handelt, werden die einzelnen Booleschen Werte aus der anfänglichen Teilbarkeitsprüfung in die erweitert And, sodass überprüft wird, ob beide Ziffern eindeutig sind und jede Ziffer die Eingabe teilt.And[U, d1∣n, d2∣n, ...]

Python 3 , 56 Bytes

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

Probieren Sie es online!

FalseWird ausgegeben, wenn es sich um eine Lynch-Bell-Nummer handelt, Trueansonsten.

Brachylog , 10 Bytes

≠g;?z%ᵐ=h0

Probieren Sie es online!

Erläuterung

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

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

^{Ich habe das vor dem Testen in Visual Studio in Notepad geschrieben, wo es gut funktioniert hat. Ich habe gerade gemerkt, dass ich jetzt so ein Nerd bin ...}

Voll / Formatierte Version:

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)

Nimmt die Eingabe als eine Zeichenfolge und kehrt trueoder falsegegebenenfalls. Bearbeiten: 1 Byte dank @RickHitchcock gespeichert. Andere Versionen:

Übernimmt die Eingabe als Zeichenfolge und gibt für 40 Bytes 0oder 1(dh die logische Umkehrung) zurück:

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

Nimmt die Eingabe als Zahl und gibt 0oder 1für 43 Bytes zurück:

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

Nimmt die Eingabe als Zahl und gibt 1oder 0für 45 Bytes zurück:

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

Gelee , 6 4 Bytes

Dg⁼Q

Probieren Sie es online!

Wie es funktioniert

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 Bytes

Gibt zurück, Falsewenn eine Zahl eine Lynch-Bell-Zahl ist. Nimmt Strings als Eingabe. Kam auf eigene Faust, aber sehr ähnlich wie Rod. Ich hätte unter seinem Beitrag kommentiert, aber ich habe noch keinen Ruf.

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

Probieren Sie es online!

Gelee , 8 Bytes

D⁼QaDḍ$Ạ

Probieren Sie es online!

PHP, 62 48 Bytes

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

Laufen Sie als Pipe mit -nRoder testen Sie es online . Leere Ausgabe für falsch, 1für wahr.

Nervenzusammenbruch

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 Bytes

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

Probieren Sie es online!

Definiert eine anonyme Funktion, (#)=<<showdie unter Angabe einer Nummer Trueoder zurückgibt False.

05AB1E , 4 Bytes

ÑÃÙQ

Probieren Sie es online!

Gleicher Algorithmus wie diese Antwort auf eine verwandte Frage .

05AB1E , 8 Bytes

SÖP¹DÙQ*

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Mathematica, 57 Bytes

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

Python 2 , 66 Bytes

Dies ist eine Lösung in Python 2, deren gesamter Zweck darin besteht, Truefür die Wahrheit und Falsefür die Falschheit auszugeben:

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

Probieren Sie es online!

Haskell, 260 241 201 162 Bytes

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)

Erläuterung

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

Habe Danke an Laikoni deutlich gekürzt

Japt , 15 14 11 10 9 Bytes

ì®yUÃ¥Uìâ

Versuch es

Neim , 9 Bytes

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Probieren Sie es online!

-2 danke an Okx .

Hmm, da ist eine schöne Symmetrie ... oO.O.O.Oo

Perl 6 , 27 Bytes

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

Probieren Sie es online!

• .combist eine Methode, die, wenn keine Argumente angegeben werden, einen String in seine einzelnen Zeichen aufteilt. Eine Zahl wird implizit in eine Zeichenfolge konvertiert und gibt daher .combihre Ziffern zurück.
• .comb.all ist eine Verknüpfung aller Ziffern.
• $_ %% .comb.allist eine Verknüpfung der Teilbarkeit des Eingabearguments $_durch alle seine Ziffern. Wenn zum Beispiel $_ist 123, ist die Kreuzung all(True, False, True), die Falsein einem wahrheitsgemäßen Kontext zusammenbricht.
• [!=] .combReduziert die Ziffern des Eingabearguments mit dem !=Operator, der auswertet, Trueob die Ziffern alle unterschiedlich sind.

Retina , 37 Bytes

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

^$

Probieren Sie es online! Link enthält Testfälle. Erläuterung: Die erste Stufe ersetzt jede doppelte Ziffer durch eine Null. Die zweite Stufe ersetzt jede Ziffer durch ihre unäre Darstellung, gefolgt von der unären Darstellung der ursprünglichen Nummer. Die dritte Stufe berechnet dann den Rest der Division der ursprünglichen Zahl durch jede Ziffer ungleich Null. Handelt es sich bei der Nummer um eine Lynch-Bell-Nummer, wird alles gelöscht und dies wird in der Endphase geprüft.

Ruby 2.4, 42 Bytes

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

(Noch kein TIO, sorry)

CJam, 17 Bytes

CJam ist das Java der Golfsprachen. Es ist sogar in Java interpretiert!

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

Erläuterung:

{   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 allerseits, dies ist mein allererster CG-Beitrag und der erste Versuch, also hoffe ich habe alle Regeln befolgt ...

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

Dies kann über den Editor ausgeführt werden, indem am Ende eine Zeile hinzugefügt wird

Msgbox L(InputBox(""))

Und dann als .vbs speichern, dann doppelklicken.

Erläuterung:

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 ist ein stumpfes Instrument zum Golfen, aber hey, ich habe Ruby noch nicht gelernt ...

PHP , 51 Bytes

gibt null für wahr und eins für falsch aus

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

Probieren Sie es online!

PHP , 62 Bytes

gibt null für wahr und eins für falsch aus

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

Probieren Sie es online!

Pyth , 10 Bytes

qiRQKjQT{K

Überprüfen Sie alle Testfälle.

Wie?

qiRQKjQT {K ~ Volles Programm.

     jQT ~ Die Liste der Dezimalstellen der Eingabe.
    K ~ Einer Variablen K zuordnen
 iRQ ~ Für jede Dezimalstelle ...
 i Q ~ ... Holen Sie sich den größten gemeinsamen Divisor mit dem Eingang selbst.
        {K ~ K mit entfernten doppelten Elementen.
q ~ Ist gleich? Implizit ausgeben.

Pyth , 11 Bytes

&!f%sQsTQ{I

Überprüfen Sie alle Testfälle.

Wie?

&! f% sQsTQ {I ~ Volles Programm mit impliziter Eingabe.

  f Q ~ Filtern Sie über die Eingabezeichenfolge.
   % sQsT ~ Die Eingabe, die in eine Ganzzahl umgewandelt wurde, moduliert die aktuelle Ziffer.
             ~ Behält es bei, wenn es höher als 0 ist, und wirft es ansonsten ab.
 ! ~ Verneinung. Wenn die Liste leer ist, wird True zurückgegeben, andernfalls False.
& {I ~ Und ist die Eingabe invariant unter Deduplizieren? Implizit ausgeben.

Perl 5 , 34 Bytes

33 Byte Code + 1 für -pFlag

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

Probieren Sie es online!

Ausgaben 0für Wahrheiten, andere Zahlen für Falschheiten

Kotlin 1.1, 98 66 59 Bytes

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

Verschönert

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

Prüfung

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 Byte

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

Probieren Sie es online!

Simple Dfn, kann wohl etwas mehr golfen werden. Yield-Standard-APL-Boolesche Werte 1 für Wahrhaftigkeit, 0 für Falschheit.

Es ist erwähnenswert, dass die Funktion die Argumente eher als Zeichenfolgen als als Ints verwendet.

Wie:

{((,⍵)≡∪⍵)×∧/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)ist ein Vektor, der die Reste enthält, nachdem x durch jede Ziffer in geteilt wurde x. 0*unique(d)ist ein Vektor mit einer Länge, die der Anzahl der eindeutigen Stellen entspricht, mit allen Nullwerten. Überprüfen Sie, ob sie gleich sind.

Probieren Sie es online!

Ruby-n , 40 Bytes

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

Probieren Sie es online!

Lesen Sie die Nummer als Zeichenfolge ein. Ersetzen Sie jedes Zeichen (Ziffer) durch ein nachfolgendes Vorkommen dieses Zeichens, falls vorhanden, oder die ganze Zahl, die diese Ziffer moduliert. Dies führt 0nur dann zu einer Zeichenfolge von s, wenn es sich um eine Lynch-Bell-Nummer handelt. Warum? Wenn es eine wiederholte Ziffer gibt, bleibt jede Instanz der letzten gleich, und da die Eingabe keine Nullen enthält, bedeutet dies, dass die Ziffer nicht Null ist. Ansonsten prüfen wir nur, ob jede Ziffer die Zahl gleichmäßig teilt.

Da es keine 8-stelligen oder mehrstelligen Lynch-Bell-Zahlen gibt (formaler Beweis: OEIS sagt dies), ist die Überprüfung, ob die resultierende Zeichenfolge lexikografisch früher als die Zeichenfolge '00000000'ist, gleichbedeutend mit der Überprüfung, ob es sich nur um Nullen handelt.

R , 86 Bytes

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

Übernimmt die Eingabe als Zeichenfolge. Ich halte das auf jeden Fall für Golf.

Probieren Sie es online!