Você receberá um número inteiro positivo (que nunca conterá um 0) como entrada. Sua tarefa é verificar se é um número Lynch-Bell ou não.

Um número é um número Lynch-Bell se todos os seus dígitos forem exclusivos e o número for divisível por cada um dos dígitos.

Na verdade, existem apenas 548 números da Lynch-Bell, então a codificação é uma possibilidade, mas quase certamente será mais longa.

126 é um número de Lynch-Bell porque todos os seus dígitos são únicos e 126 é divisível por 1, 2 e 6.

Você pode gerar qualquer valor verdadeiro e falso.

Exemplos:

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

Este é o OEIS A115569 .

Mathematica, 42 bytes

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

Eu acho que 0!=##&@@d&&##&@@é uma nova baixa legibilidade para o Mathematica ...

Explicação

Alguns dos açúcares sintáticos básicos usados ​​aqui:

• & tem precedência muito baixa e transforma tudo o que resta dele em uma função sem nome.
• &&é apenas o Andoperador.
• # é o argumento da função sem nome que o encerra mais próxima.
• ##é uma sequência de todos os argumentos da função.
• @é uma notação de prefixo para chamadas de função, ie f@x == f[x].
• @@é Apply, que passa os elementos de uma lista como argumentos individuais para uma função, ie f@@{a,b,c} == f[a,b,c].

Com isso fora do caminho ...

(d=IntegerDigits@#)

Isso deve ser bastante auto-explicativo: isso nos fornece uma lista dos dígitos decimais da entrada e armazena o resultado d.

(...∣#)

Isso testa a entrada quanto à divisibilidade de cada um de seus dígitos (porque o operador de divisibilidade é Listable). Isso nos dá uma lista de Trues e Falses.

...&@@...

Aplicamos a função no lado esquerdo à lista de booleanos, de modo que cada booleano seja um argumento separado.

...&@@d

Aplicamos outra função a d, para que os dígitos individuais sejam dados como argumentos separados. A função é 0!=##&, ie . Ele verifica se todos os dígitos são distintos (e que são distintos, mas isso é dado pelo desafio e, se não fosse, não seria um divisor de qualquer maneira). é realmente apenas uma economia de 1 byte no uso de si mesmo, e funciona porque há um elemento de 1 byte ( ) que sabemos que não está presente. Portanto, essa primeira coisa verifica se os dígitos são únicos. Vamos chamar esse resultadoUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Novamente, isso é realmente apenas uma abreviação para And[U, ##]. Com ##sendo uma sequência, as booleans individuais a partir da verificação inicial divisibilidade são expandidos para o And, então temos que verifica que ambos os dígitos são únicas e cada dígito divide a 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})

Experimente online!

Saída Falsese for um número Lynch-Bell, Truecaso contrário.

Braquilog , 10 bytes

≠g;?z%ᵐ=h0

Experimente online!

Explicação

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

^{Eu escrevi isso no bloco de notas antes de testar no Visual Studio, onde funcionou bem, então percebi que agora eu sou esse nível de nerd ...}

Versão completa / formatada:

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)

Recebe a entrada como uma sequência e retorna trueou falseconforme apropriado. Edit: Salvo 1 byte graças a @RickHitchcock. Outras versões:

Recebe a entrada como uma string e retorna 0ou 1( ou seja, inverso lógico) por 40 bytes:

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

Pega a entrada como um número e retorna 0ou 1para 43 bytes:

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

Pega a entrada como um número e retorna 1ou 0para 45 bytes:

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

Geléia , 6 4 bytes

Dg⁼Q

Experimente online!

Como 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

Retorna Falsequando um número é um número Lynch-Bell. Toma seqüências de caracteres como entrada. Surgiu sozinho, mas muito parecido com o de Rod. Eu teria comentado sob o post dele, mas ainda não tenho nenhuma reputação.

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

Experimente online!

Geléia , 8 bytes

D⁼QaDḍ$Ạ

Experimente online!

PHP, 62 48 bytes

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

Executar como tubo -nRou testá-lo on-line . Saída vazia por falsidade, 1por verdade.

demolir

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

Experimente online!

Define uma função anônima (#)=<<showque, dado um número, retorna Trueou False.

05AB1E , 4 bytes

ÑÃÙQ

Experimente online!

O mesmo algoritmo que esta resposta a uma pergunta relacionada .

05AB1E , 8 bytes

SÖP¹DÙQ*

Usa a codificação 05AB1E . Experimente online!

Mathematica, 57 bytes

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

Python 2 , 66 bytes

Esta é uma solução no Python 2, cujo objetivo é produzir Truepor verdade e Falsepor falsidade:

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

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

Explicação

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

Reduziram significativamente o thanx para Laikoni

Japt , 15 14 11 10 9 bytes

ì®yUÃ¥Uìâ

Tente

Neim , 9 bytes

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Experimente online!

-2 graças a Okx .

Hmm, há uma boa simetria ... oO.O.O.Oo

Perl 6 , 27 bytes

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

Experimente online!

• .combé um método que, quando não recebe argumentos, divide uma string em seus caracteres individuais. Um número é implicitamente convertido em uma sequência e, portanto,.comb retorna seus dígitos.
• .comb.all é uma junção e de todos os dígitos.
• $_ %% .comb.allé uma junção e da divisibilidade do argumento de entrada $_por todos os seus dígitos. Por exemplo, se $_for 123, a junção é all(True, False, True), que cai paraFalse entra em em um contexto de verdade.
• [!=] .combreduz os dígitos do argumento de entrada com o !=operador, que avalia Truese os dígitos são todos diferentes.

Retina , 37 bytes

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

^$

Experimente online! O link inclui casos de teste. Explicação: O primeiro estágio substitui qualquer dígito duplicado por um zero. O segundo estágio substitui cada dígito por sua representação unária, seguida pela representação unária do número original. O terceiro estágio calcula o restante da divisão do número original por cada dígito diferente de zero. Se o número for um número Lynch-Bell, isso excluirá tudo e será testado no estágio final.

Ruby 2.4, 42 bytes

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

(Nenhum TIO ainda, desculpe)

CJam, 17 bytes

CJam é o Java das linguagens de golfe. É até interpretado em Java!

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

Explicação:

{   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

Olá a todos, este é o meu primeiro post em CG, e a primeira tentativa, então espero ter seguido todas as regras ...

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

Isso pode ser executado no bloco de notas adicionando uma linha no final

Msgbox L(InputBox(""))

E, em seguida, salve-o como .vbs e clique duas vezes.

Explicação:

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

O VBScript é um instrumento sem corte para o golfe, mas, ainda não aprendi Ruby ...

PHP , 51 bytes

imprime zero para verdadeiro e um para falso

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

Experimente online!

PHP , 62 bytes

imprime zero para verdadeiro e um para falso

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

Experimente online!

Pitão , 10 bytes

qiRQKjQT{K

Verifique todos os casos de teste.

Quão?

qiRQKjQT {K ~ Programa completo.

     jQT ~ A lista de dígitos decimais da entrada.
    K ~ Atribuir a uma variável K.
 iRQ ~ Para cada dígito decimal ...
 i Q ~ ... Obtenha o maior divisor comum com a própria entrada.
        {K ~ K com os elementos duplicados removidos.
q ~ é igual? Saída implicitamente.

Pitão , 11 bytes

&!f%sQsTQ{I

Verifique todos os casos de teste.

Quão?

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

  f Q ~ Filtre a string de entrada.
   % sQsT ~ A entrada convertida em um número inteiro modula o dígito atual.
             ~ Mantém-no se for maior que 0 e o descarta.
 ! ~ Negação. Se a lista estiver vazia, retorna True, caso contrário, False.
& {I ~ E a entrada é invariável sob desduplicação? Saída implicitamente.

Perl 5 , 34 bytes

33 bytes de código + 1 para -psinalizador

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

Experimente online!

Saídas 0para verdade, qualquer outro número para falsidade

Kotlin 1.1, 98 66 59 bytes

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

Embelezado

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

Teste

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

Experimente online!

Dfn simples, provavelmente pode ser jogado um pouco mais. Rendimento booleanos APL padrão 1 para verdade, 0 para falsidade.

Vale ressaltar que a função aceita os argumentos como strings em vez de ints.

Quão:

{((,⍵)≡∪⍵)×∧/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)é um vetor que contém os restantes depois de dividir x por cada dígito em x. 0*unique(d)é um vetor com comprimento igual ao número de dígitos únicos, com todos os valores zero. Verifique se são iguais.

Experimente online!

ruby -n , 40 bytes

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

Experimente online!

Leia o número como uma sequência. Substitua cada caractere (dígito) por uma ocorrência subsequente desse caractere, se presente, ou o número inteiro module esse dígito. Isso resultará em uma sequência de apenas 0s se e somente se este for um número Lynch-Bell. Por quê? Se houver um dígito repetido, todas as instâncias da última permanecerão as mesmas e, como a entrada não contém zeros, isso significa um dígito diferente de zero. Caso contrário, estamos apenas verificando se cada dígito divide igualmente o número.

Como não há números de Lynch-Bell de 8 ou mais dígitos (prova formal: a OEIS diz isso), verificar se a sequência resultante é lexicograficamente mais cedo que a sequência '00000000'é equivalente a verificar se são todos os zeros.

R , 86 bytes

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

Recebe a entrada como uma sequência. Eu certamente sinto que isso é jogável.

Experimente online!