Ti verrà dato un numero intero positivo (che non conterrà mai uno 0) come input. Il tuo compito è controllare se si tratta di un numero Lynch-Bell o meno.

Un numero è un numero di Lynch-Bell se tutte le sue cifre sono univoche e il numero è divisibile per ciascuna delle sue cifre.

In realtà, in realtà ci sono solo 548 numeri Lynch-Bell, quindi la codifica è una possibilità, ma quasi sicuramente sarà più lunga.

126 è un numero di Lynch-Bell perché tutte le sue cifre sono univoche e 126 è divisibile per 1, 2 e 6.

È possibile generare qualsiasi valore di verità e falsità.

Esempi:

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

Questo è OEIS A115569 .

Mathematica, 42 byte

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

Penso che 0!=##&@@d&&##&@@sia un nuovo basso livello di leggibilità per Mathematica ...

Spiegazione

Alcuni degli zuccheri sintattici di base usati qui:

• & ha una priorità molto bassa e trasforma tutto ciò che ne rimane in una funzione senza nome.
• &&è solo l' Andoperatore.
• # è l'argomento della funzione anonima che racchiude più vicina.
• ##è una sequenza di tutti gli argomenti della funzione.
• @è la notazione del prefisso per le chiamate di funzione, ad es f@x == f[x].
• @@è Apply, che passa gli elementi di un elenco come singoli argomenti a una funzione, ad es f@@{a,b,c} == f[a,b,c].

Con quello fuori mano ...

(d=IntegerDigits@#)

Questo dovrebbe essere abbastanza autoesplicativo: questo ci dà un elenco delle cifre decimali dell'input e memorizza il risultato d.

(...∣#)

Questo verifica l'input per la divisibilità per ciascuna delle sue cifre (perché l'operatore di divisibilità è Listable). Questo ci dà un elenco di Trues e Falses.

...&@@...

Applichiamo la funzione sul lato sinistro all'elenco dei booleani, in modo tale che ogni booleano sia un argomento separato.

...&@@d

Applichiamo un'altra funzione a d, in modo che le singole cifre siano fornite come argomenti separati. La funzione è 0!=##&, ad es . Verifica che tutte le cifre siano distinte (e che siano distinte da ma ciò è dato dalla sfida, e se non lo fosse, non sarebbe comunque un divisore). è davvero solo un risparmiatore di 1 byte sull'uso di se stesso e funziona perché c'è un elemento di 1 byte ( ) che sappiamo che non è presente. Quindi questa prima cosa controlla che le cifre siano uniche. Chiamiamo questo risultatoUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Ancora una volta, questa è davvero solo una scorciatoia per And[U, ##]. Con ##essendo una sequenza, i singoli booleani dal controllo divisibilità iniziale espandono nella And, in modo da ottenere che controlli che entrambe le cifre sono unici e ogni cifra divide l'ingresso.And[U, d1∣n, d2∣n, ...]

Python 3 , 56 byte

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

Provalo online!

Uscita Falsese è un numero Lynch-Bell, Truealtrimenti.

Brachylog , 10 byte

≠g;?z%ᵐ=h0

Provalo online!

Spiegazione

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

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

^{L'ho scritto nel blocco note prima di eseguire i test in Visual Studio, dove ha funzionato bene, quindi ho appena capito che ora sono quel livello di secchione ...}

Versione completa / formattata:

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)

Prende l'input come stringa e restituisce trueo falsecome appropriato. Modifica: salvato 1 byte grazie a @RickHitchcock. Altre versioni:

Prende input come stringa e restituisce 0o 1(cioè inverso logico) per 40 byte:

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

Accetta input come numero e restituisce 0o 1per 43 byte:

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

Accetta input come numero e restituisce 1o 0per 45 byte:

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

Gelatina , 6 4 byte

Dg⁼Q

Provalo online!

Come funziona

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 byte

Restituisce Falsequando un numero è un numero Lynch-Bell. Accetta le stringhe come input. Sono venuto da solo ma molto simile a quello di Rod. Avrei commentato sotto il suo post ma non ho ancora alcuna reputazione.

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

Provalo online!

Gelatina , 8 byte

D⁼QaDḍ$Ạ

Provalo online!

PHP, 62 48 byte

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

Esegui come pipe con -nR o testalo online . Uscita vuota per falsy, 1per verità.

abbattersi

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 byte

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

Provalo online!

Definisce una funzione anonima (#)=<<showche, in base a un numero, restituisce Trueo False.

05AB1E , 4 byte

ÑÃÙQ

Provalo online!

Stesso algoritmo di questa risposta a una domanda correlata .

05AB1E , 8 byte

SÖP¹DÙQ*

Utilizza la codifica 05AB1E . Provalo online!

Mathematica, 57 byte

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

Python 2 , 66 byte

Questa è una soluzione in Python 2, il cui scopo è quello di produrre Trueverità e Falsefalsità:

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

Provalo online!

Haskell, 260 241 201 162 byte

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)

Spiegazione

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

Grazie in modo significativo grazie a Laikoni

Japt , 15 14 11 10 9 byte

ì®yUÃ¥Uìâ

Provalo

Neim , 9 byte

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Provalo online!

-2 grazie a Okx .

Hmm, c'è una bella simmetria ... oO.O.O.Oo

Perl 6 , 27 byte

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

Provalo online!

• .combè un metodo che, quando non viene fornito alcun argomento, divide una stringa nei suoi singoli caratteri. Un numero viene convertito implicitamente in una stringa e così.comb restituisce le sue cifre.
• .comb.all è una giunzione e di tutte le cifre.
• $_ %% .comb.allè una e-giunzione della divisibilità dell'argomento di input $_per tutte le sue cifre. Ad esempio, se lo $_è 123, la giunzione è all(True, False, True), che collassa aFalse in un contesto veritiero.
• [!=] .combriduce le cifre dell'argomento di input con l' !=operatore, che valuta Truese le cifre sono tutte diverse.

Retina , 37 byte

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

^$

Provalo online! Il link include casi di test. Spiegazione: Il primo stadio sostituisce qualsiasi cifra duplicata con uno zero. Il secondo stadio sostituisce ogni cifra con la sua rappresentazione unaria seguita dalla rappresentazione unaria del numero originale. Il terzo stadio calcola quindi il resto della divisione del numero originale per ciascuna cifra diversa da zero. Se il numero è un numero Lynch-Bell, questo eliminerà tutto e questo verrà testato dalla fase finale.

Ruby 2.4, 42 byte

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

(Nessun TIO ancora, scusa)

CJam, 17 byte

CJam è la Java dei linguaggi del golf. È persino interpretato in Java!

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

Spiegazione:

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

Ciao a tutti, questo è il mio primo post in CG e il primo tentativo, quindi spero di aver seguito tutte le regole ...

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

Questo può essere eseguito dal Blocco note aggiungendo una riga alla fine

Msgbox L(InputBox(""))

E poi salvandolo come .vbs, quindi fai doppio clic.

Spiegazione:

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 è un po 'uno strumento smussato per il golf, ma ehi, non ho ancora imparato Ruby ...

PHP , 51 byte

stampa zero per vero e uno per falso

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

Provalo online!

PHP , 62 byte

stampa zero per vero e uno per falso

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

Provalo online!

Pyth , 10 byte

qiRQKjQT{K

Verifica tutti i casi di test.

Come?

qiRQKjQT {K ~ Programma completo.

     jQT ~ L'elenco delle cifre decimali dell'input.
    K ~ Assegna a una variabile K.
 iRQ ~ Per ogni cifra decimale ...
 i Q ~ ... Ottieni il massimo comune divisore con l'input stesso.
        {K ~ K con gli elementi duplicati rimossi.
q ~ È uguale? Uscita implicita.

Pyth , 11 byte

&!f%sQsTQ{I

Verifica tutti i casi di test.

Come?

&! f% sQsTQ {I ~ Programma completo, con input implicito.

  f Q ~ Filtra sulla stringa di input.
   % sQsT ~ L'input ha convertito in un numero intero il numero corrente.
             ~ Lo mantiene se è maggiore di 0 e lo scarta in caso contrario.
 ! ~ Negazione. Se l'elenco è vuoto, restituisce True, altrimenti False.
& {I ~ E l'input è invariante sotto la deduplicazione? Uscita implicita.

Perl 5 , 34 byte

33 byte di codice + 1 per -pflag

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

Provalo online!

Uscite 0per verità, qualsiasi altro numero per falsità

Kotlin 1.1, 98 66 59 byte

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

Abbellire

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

Test

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

Provalo online!

Dfn semplice, probabilmente può essere giocato a golf un po 'di più. La resa standard APL booleana 1 per la verità, 0 per la falsità.

Vale la pena ricordare che la funzione accetta gli argomenti come stringhe anziché come inte.

Come:

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

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

rem.(x,d)è un vettore contenente i resti dopo aver diviso x per ogni cifra in x. 0*unique(d)è un vettore con lunghezza uguale al numero di cifre univoche, con tutti i valori zero. Controlla se sono uguali.

Provalo online!

ruby -n , 40 byte

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

Provalo online!

Leggere il numero come una stringa. Sostituisci ogni carattere (cifra) con un'occorrenza successiva di quel carattere, se presente, o l'intero numero modulo di quella cifra. Ciò comporterà una stringa di soli 0se e solo se si tratta di un numero Lynch-Bell. Perché? Se c'è una cifra ripetuta, ogni istanza dell'ultima rimane la stessa, e poiché l'ingresso non contiene zero, ciò significa una cifra diversa da zero. Altrimenti, stiamo solo verificando se ogni cifra divide uniformemente il numero.

Poiché non ci sono numeri Lynch-Bell di 8 o più cifre (prova formale: OEIS lo dice), controllare se la stringa risultante è lessicograficamente precedente alla stringa '00000000'equivale a controllare se sono tutti zero.

R, 86 bytes

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

Takes input as a string. I certainly feel like this is golfable.

Try it online!