Vous recevrez un nombre entier positif (qui ne contiendra jamais de 0) en entrée. Votre tâche consiste à vérifier s'il s'agit d'un numéro Lynch-Bell ou non.

Un numéro est un numéro de Lynch-Bell si tous ses chiffres sont uniques et le nombre est divisible par chacun de ses chiffres.

En fait, il n'y a en fait que 548 numéros de Lynch-Bell, donc le codage en dur est une possibilité, mais sera certainement plus long.

126 est un numéro de Lynch-Bell car tous ses chiffres sont uniques et 126 est divisible par 1, 2 et 6.

Vous pouvez afficher n'importe quelle valeur véridique et fausse.

Exemples:

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

Il s'agit d' OEIS A115569 .

Mathematica, 42 octets

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

Je pense que 0!=##&@@d&&##&@@c'est une nouvelle faible lisibilité pour Mathematica ...

Explication

Une partie du sucre syntaxique de base utilisé ici:

• & a une très faible priorité et transforme tout ce qui en reste en une fonction sans nom.
• &&est juste l' Andopérateur.
• # est l'argument de la fonction sans nom englobante la plus proche.
• ##est une séquence de tous les arguments de la fonction.
• @est la notation de préfixe pour les appels de fonction, c'est-à-dire f@x == f[x].
• @@is Apply, qui transmet les éléments d'une liste en tant qu'arguments individuels à une fonction, c'est-à-dire f@@{a,b,c} == f[a,b,c].

Avec cela à l'écart ...

(d=IntegerDigits@#)

Cela devrait être assez explicite: cela nous donne une liste des chiffres décimaux de l'entrée et stocke le résultat dans d.

(...∣#)

Cela teste la divisibilité de l'entrée par chacun de ses chiffres (car l'opérateur de divisibilité est Listable). Cela nous donne une liste de Trues et Falses.

...&@@...

Nous appliquons la fonction sur le côté gauche à la liste des booléens, de sorte que chaque booléen est un argument distinct.

...&@@d

Nous appliquons une autre fonction à d, de sorte que les chiffres individuels soient donnés comme arguments séparés. La fonction est 0!=##&, ie . Il vérifie que tous les chiffres sont distincts (et qu'ils sont différents mais que cela est donné par le défi, et si ce n'était pas le cas, ce ne serait pas un diviseur de toute façon). est vraiment juste un économiseur de 1 octet sur l'utilisation de lui-même, et cela fonctionne parce qu'il y a un élément ( ) de 1 octet que nous savons absent. Donc, cette première chose vérifie que les chiffres sont uniques. Appelons ce résultatUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Encore une fois, c'est vraiment un raccourci pour And[U, ##]. Avec ##une séquence, les booléens individuels de la vérification de divisibilité initiale sont développés dans le And, nous obtenons donc les vérifications que les deux chiffres sont uniques et que chaque chiffre divise l'entrée.And[U, d1∣n, d2∣n, ...]

Python 3 , 56 octets

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

Essayez-le en ligne!

Sortie Falsesi c'est un numéro Lynch-Bell, Truesinon.

Brachylog , 10 octets

≠g;?z%ᵐ=h0

Essayez-le en ligne!

Explication

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

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

^{J'ai écrit cela dans le bloc-notes avant de tester dans Visual Studio, où cela fonctionnait bien, alors je viens de réaliser que je suis maintenant à ce niveau de nerd ...}

Version complète / formatée:

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 octets

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

Prend l'entrée sous forme de chaîne et renvoie trueou falseselon le cas. Edit: sauvé 1 octet grâce à @RickHitchcock. Autres versions:

Prend l'entrée sous forme de chaîne et retourne 0ou 1(c'est-à-dire l'inverse logique) pour 40 octets:

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

Prend l'entrée sous forme de nombre et renvoie 0ou 1pour 43 octets:

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

Prend l'entrée sous forme de nombre et renvoie 1ou 0pour 45 octets:

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

Gelée , 6 4 octets

Dg⁼Q

Essayez-le en ligne!

Comment ça marche

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 octets

Renvoie Falselorsqu'un numéro est un numéro de Lynch-Bell. Prend des chaînes en entrée. Je suis venu seul mais très similaire à celui de Rod. J'aurais commenté sous son post mais je n'ai pas encore de réputation.

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

Essayez-le en ligne!

Gelée , 8 octets

D⁼QaDḍ$Ạ

Essayez-le en ligne!

PHP, 62 48 octets

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

Exécuter en tant que pipe avec -nRou tester en ligne . Sortie vide pour faux, 1pour vrai.

panne

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 octets

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

Essayez-le en ligne!

Définit une fonction anonyme (#)=<<showqui, à partir d'un nombre, renvoie Trueou False.

05AB1E , 4 octets

ÑÃÙQ

Essayez-le en ligne!

Même algorithme que cette réponse à une question connexe .

05AB1E , 8 octets

SÖP¹DÙQ*

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Mathematica, 57 octets

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

Python 2 , 66 octets

Ceci est une solution en Python 2, dont le but est de produire Truepour la vérité et la Falsefausse:

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

Essayez-le en ligne!

Haskell, 260 241 201 162 octets

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)

Explication

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

Ont considérablement raccourci thanx à Laikoni

Japt , 15 14 11 10 9 octets

ì®yUÃ¥Uìâ

Essayez-le

Neim , 9 octets

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Essayez-le en ligne!

-2 grâce à Okx .

Hmm, il y a une symétrie sympa ... oO.O.O.Oo

Perl 6 , 27 octets

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

Essayez-le en ligne!

• .combest une méthode qui, sans argument, divise une chaîne en ses caractères individuels. Un nombre est implicitement converti en chaîne et .combrenvoie donc ses chiffres.
• .comb.all est une jonction de tous les chiffres.
• $_ %% .comb.allest une jonction de la divisibilité de l'argument d'entrée $_par tous ses chiffres. Par exemple, si $_c'est le cas 123, la jonction est all(True, False, True), qui s'effondre Falsedans un contexte véridique.
• [!=] .combréduit les chiffres de l'argument d'entrée avec l' !=opérateur, qui évalue Truesi les chiffres sont tous différents.

Rétine , 37 octets

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

^$

Essayez-le en ligne! Le lien inclut des cas de test. Explication: La première étape remplace tout chiffre en double par un zéro. La deuxième étape remplace chaque chiffre par sa représentation unaire suivie de la représentation unaire du nombre d'origine. La troisième étape calcule ensuite le reste de la division du nombre d'origine par chaque chiffre non nul. Si le numéro est un numéro Lynch-Bell, cela supprimera tout et cela sera testé par l'étape finale.

Ruby 2.4, 42 octets

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

(Pas encore de TIO, désolé)

CJam, 17 octets

CJam est le Java des langages de golf. Il est même interprété en Java!

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

Explication:

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

Salut à tous, ceci est mon tout premier post CG, et ma première tentative, alors j'espère avoir suivi toutes les règles ...

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

Cela peut être exécuté à partir du bloc-notes en ajoutant une ligne à la fin

Msgbox L(InputBox(""))

Et puis l'enregistrer en tant que .vbs, puis double-cliquez.

Explication:

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 est un peu un instrument contondant pour le golf, mais bon, je n'ai pas encore appris Ruby ...

PHP , 51 octets

imprime zéro pour vrai et un pour faux

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

Essayez-le en ligne!

PHP , 62 octets

imprime zéro pour vrai et un pour faux

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

Essayez-le en ligne!

Pyth , 10 octets

qiRQKjQT{K

Vérifiez tous les cas de test.

Comment?

qiRQKjQT {K ~ Programme complet.

     jQT ~ La liste des chiffres décimaux de l'entrée.
    K ~ Attribuer à une variable K.
 iRQ ~ Pour chaque chiffre décimal ...
 i Q ~ ... Obtenez le plus grand diviseur commun avec l'entrée elle-même.
        {K ~ K avec les éléments en double supprimés.
q ~ est égal? Sortie implicitement.

Pyth , 11 octets

&!f%sQsTQ{I

Vérifiez tous les cas de test.

Comment?

&! f% sQsTQ {I ~ Programme complet, avec entrée implicite.

  f Q ~ Filtrez la chaîne d'entrée.
   % sQsT ~ L'entrée convertie en un module entier le chiffre actuel.
             ~ Le conserve s'il est supérieur à 0 et le supprime sinon.
 ! ~ Négation. Si la liste est vide, renvoie True, sinon False.
& {I ~ Et l'entrée est-elle invariante sous déduplication? Sortie implicitement.

Perl 5 , 34 octets

33 octets de code + 1 pour l' -pindicateur

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

Essayez-le en ligne!

Sorties 0pour vérité, tout autre numéro pour fausse

Kotlin 1.1, 98 66 59 octets

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

Embellie

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

Tester

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 octets

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

Essayez-le en ligne!

Dfn simple, peut probablement être joué un peu plus. Rendement booléen APL standard 1 pour la vérité, 0 pour la fausse.

Il convient de mentionner que la fonction prend les arguments comme des chaînes plutôt que des entiers.

Comment:

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

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

rem.(x,d)est un vecteur contenant les restes après avoir divisé x par chaque chiffre de x. 0*unique(d)est un vecteur de longueur égale au nombre de chiffres uniques, avec toutes les valeurs nulles. Vérifiez s'ils sont égaux.

Essayez-le en ligne!

rubis -n , 40 octets

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

Essayez-le en ligne!

Lisez le nombre sous forme de chaîne. Remplacez chaque caractère (chiffre) par une occurrence ultérieure de ce caractère, s'il est présent, ou le nombre entier modulo ce chiffre. Il en résultera une chaîne de 0s uniquement si et seulement s'il s'agit d'un numéro de Lynch-Bell. Pourquoi? S'il y a un chiffre répété, chaque instance de la dernière reste la même, et puisque l'entrée ne contient pas de zéros, cela signifie un chiffre différent de zéro. Sinon, nous vérifions simplement si chaque chiffre divise également le nombre.

Puisqu'il n'y a pas de numéros de Lynch-Bell à 8 chiffres ou plus (preuve formelle: OEIS le dit), vérifier si la chaîne résultante est lexicographiquement plus tôt que la chaîne '00000000'équivaut à vérifier si ce sont tous des zéros.

R , 86 octets

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

Prend l'entrée sous forme de chaîne. J'ai l'impression que c'est jouable au golf.

Essayez-le en ligne!