Se le dará un número entero positivo (que nunca contendrá un 0) como entrada. Su tarea es verificar si es un número de Lynch-Bell o no.

Un número es un número de Lynch-Bell si todos sus dígitos son únicos y el número es divisible por cada uno de sus dígitos.

De hecho, en realidad solo hay 548 números de Lynch-Bell, por lo que la codificación es una posibilidad, pero seguramente será más larga.

126 es un número de Lynch-Bell porque todos sus dígitos son únicos, y 126 es divisible por 1, 2 y 6.

Puede generar cualquier valor verdadero y falso.

Ejemplos:

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

Este es OEIS A115569 .

Mathematica, 42 bytes

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

Creo que 0!=##&@@d&&##&@@es un nuevo bajo en legibilidad para Mathematica ...

Explicación

Algunos de los azúcares sintácticos básicos utilizados aquí:

• & tiene muy poca precedencia y convierte todo lo que queda en una función sin nombre.
• &&es solo el Andoperador.
• # es el argumento de la función sin nombre adjunta más cercana.
• ##es una secuencia de todos los argumentos de la función.
• @es la notación de prefijo para llamadas a funciones, es decir f@x == f[x].
• @@es decir Apply, que pasa los elementos de una lista como argumentos individuales a una función, es decir f@@{a,b,c} == f[a,b,c].

Con eso fuera del camino ...

(d=IntegerDigits@#)

Esto debería explicarse por sí mismo: esto nos da una lista de los dígitos decimales de la entrada y almacena el resultado en d .

(...∣#)

Esto prueba la entrada para la divisibilidad por cada uno de sus dígitos (porque el operador de divisibilidad es Listable). Esto nos da una lista de TruesyFalse s.

...&@@...

Aplicamos la función del lado izquierdo a la lista de booleanos, de modo que cada booleano es un argumento separado.

...&@@d

Aplicamos otra función a d, para que los dígitos individuales se den como argumentos separados. La función es 0!=##&, es decir . Comprueba que todos los dígitos son distintos (y que son distintos, pero eso está dado por el desafío, y si no fuera así, no sería un divisor de todos modos). en realidad es solo un ahorro de 1 byte en el uso de sí mismo, y funciona porque hay un elemento de 1 byte (Unequal[0, d1, d2, ...]00!=##&Unequal0 ) que sabemos que no está presente. Entonces, lo primero que verifica es que los dígitos son únicos. Llamemos a este resultadoU

...&&##

De nuevo, esto es realmente solo una abreviatura para And[U, ##]. Al ##ser una secuencia, los booleanos individuales de la verificación de divisibilidad inicial se expanden en la And, por lo que obtenemos qué comprobaciones de que ambos dígitos son únicos y que cada dígito divide la entrada.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})

Pruébalo en línea!

Salida Falsesi es IS un número de Lynch-Bell, de lo Truecontrario.

Brachylog , 10 bytes

≠g;?z%ᵐ=h0

Pruébalo en línea!

Explicación

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

^{Escribí esto en el bloc de notas antes de probar en Visual Studio, donde funcionó bien, así que me di cuenta de que ahora soy ese nivel de nerd ...}

Versión completa / formateada:

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 bytes

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

Toma la entrada como una cadena y devuelve trueofalse según corresponda. Editar: guardado 1 byte gracias a @RickHitchcock. Otras versiones:

Toma la entrada como una cadena y devuelve 0o 1(es decir, inversa lógica) para 40 bytes:

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

Toma la entrada como un número y devuelve 0o 1para 43 bytes:

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

Toma la entrada como un número y devuelve 1o 0para 45 bytes:

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

Jalea , 6 4 bytes

Dg⁼Q

Pruébalo en línea!

Cómo funciona

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

Devuelve Falsecuando un número es un número de Lynch-Bell. Toma cadenas como entrada. Se me ocurrió solo pero muy similar al de Rod. Hubiera comentado debajo de su publicación, pero todavía no tengo reputación.

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

Pruébalo en línea!

Jalea , 8 bytes

D⁼QaDḍ$Ạ

Pruébalo en línea!

PHP, 62 48 bytes

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

Ejecutar como tubería con -nRo probarlo en línea . Salida vacía para falsedad, 1para verdad.

Descompostura

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

Pruébalo en línea!

Define una función anónima (#)=<<showque, dado un número, devuelve Trueo False.

05AB1E , 4 bytes

ÑÃÙQ

Pruébalo en línea!

Mismo algoritmo que esta respuesta a una pregunta relacionada .

05AB1E , 8 bytes

SÖP¹DÙQ*

Utiliza la codificación 05AB1E . Pruébalo en línea!

Mathematica, 57 bytes

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

Python 2 , 66 bytes

Esta es una solución en Python 2, cuyo Trueúnico propósito es generar datos verdaderos y Falsefalsos:

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

Pruébalo en línea!

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)

Explicación

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

Han acortado significativamente gracias a Laikoni

Japt , 15 14 11 10 9 bytes

ì®yUÃ¥Uìâ

Intentalo

Neim , 9 bytes

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Pruébalo en línea!

-2 gracias a Okx .

Hmm, hay una buena simetría ... oO.O.O.Oo

Perl 6 , 27 bytes

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

Pruébalo en línea!

• .combes un método que, cuando no tiene argumentos, divide una cadena en sus caracteres individuales. Un número se convierte implícitamente en una cadena y, por lo tanto, .combdevuelve sus dígitos.
• .comb.all es una unión de todos los dígitos.
• $_ %% .comb.alles una unión y de la divisibilidad del argumento de entrada $_por todos sus dígitos. Por ejemplo, si $_es 123, la unión es all(True, False, True), que colapsa aFalse en un contexto verdadero.
• [!=] .combreduce los dígitos del argumento de entrada con el !=operador, que evalúa Truesi los dígitos son todos diferentes.

Retina , 37 bytes

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

^$

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: La primera etapa reemplaza cualquier dígito duplicado con un cero. La segunda etapa reemplaza cada dígito con su representación unaria seguida de la representación unaria del número original. La tercera etapa luego calcula el resto de la división del número original por cada dígito distinto de cero. Si el número es un número de Lynch-Bell, esto eliminará todo y esto se probará en la etapa final.

Ruby 2.4, 42 bytes

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

(No hay TIO todavía, lo siento)

CJam, 17 bytes

CJam es el Java de los lenguajes de golf. ¡Incluso se interpreta en Java!

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

Explicación:

{   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

Hola a todos, esta es mi primera publicación de CG, y mi primer intento, así que espero seguir todas las reglas ...

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

Esto se puede ejecutar desde el Bloc de notas agregando una línea al final

Msgbox L(InputBox(""))

Y luego guardarlo como .vbs, luego hacer doble clic.

Explicación:

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 es un instrumento un poco contundente para jugar al golf, pero bueno, todavía no he aprendido a Ruby ...

PHP , 51 bytes

imprime cero para verdadero y uno para falso

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

Pruébalo en línea!

PHP , 62 bytes

imprime cero para verdadero y uno para falso

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

Pruébalo en línea!

Pyth , 10 bytes

qiRQKjQT{K

Verifique todos los casos de prueba.

¿Cómo?

qiRQKjQT {K ~ Programa completo.

     jQT ~ La lista de dígitos decimales de la entrada.
    K ~ Asignar a una variable K.
 iRQ ~ Para cada dígito decimal ...
 i Q ~ ... Obtenga el máximo común divisor con la entrada en sí.
        {K ~ K con los elementos duplicados eliminados.
q ~ ¿Es igual? Salida implícita.

Pyth , 11 bytes

&!f%sQsTQ{I

Verifique todos los casos de prueba.

¿Cómo?

&! f% sQsTQ {I ~ Programa completo, con entrada implícita.

  f Q ~ Filtrar sobre la cadena de entrada.
   % sQsT ~ La entrada convertida en un módulo entero el dígito actual.
             ~ Lo mantiene si es mayor que 0, y lo descarta de lo contrario.
 ! ~ Negación. Si la lista está vacía, devuelve True, de lo contrario False.
& {I ~ ¿Y la entrada es invariante bajo deduplicación? Salida implícita.

Perl 5 , 34 bytes

33 bytes de código + 1 para -pbandera

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

Pruébalo en línea!

Salidas 0para la verdad, cualquier otro número para la falsedad

Kotlin 1.1, 98 66 59 bytes

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

Embellecido

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

Prueba

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=(⍎¨⍵)|⍎⍵}

Pruébalo en línea!

Dfn simple, probablemente se puede jugar un poco más. Rendimiento booleanos APL estándar 1 para verdadero, 0 para falso.

Vale la pena mencionar que la función toma los argumentos como cadenas en lugar de ints.

Cómo:

{((,⍵)≡∪⍵)×∧/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)es un vector que contiene los restos después de dividir x por cada dígito en x. 0*unique(d)es un vector con una longitud igual al número de dígitos únicos, con todos los valores cero. Comprueba si son iguales.

Pruébalo en línea!

ruby -n , 40 bytes

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

Pruébalo en línea!

Lea el número como una cadena. Sustituya cada carácter (dígito) con una aparición posterior de ese carácter, si está presente, o el número entero módulo de ese dígito. Esto dará como resultado una cadena de solo0 s si y solo si se trata de un número de Lynch-Bell. ¿Por qué? Si hay un dígito repetido, cada instancia del último permanece igual, y dado que la entrada no contiene ceros, eso significa un dígito distinto de cero. De lo contrario, solo estamos verificando si cada dígito divide equitativamente el número.

Dado que no hay números de Lynch-Bell de 8 o más dígitos (prueba formal: OEIS lo dice), verificar si la cadena resultante es lexicográficamente anterior a la cadena '00000000'es equivalente a verificar si todos son ceros.

R , 86 bytes

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

Toma la entrada como una cadena. Ciertamente siento que esto es golfable.

Pruébalo en línea!