È un numero di Lynch-Bell?


25

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 .


1
Relazionato. (Chiede tutti i numeri invece di porre un problema decisionale.)
Martin Ender il

2
Posso prendere input come stringa?
TheLethalCoder

2
@TheLethalCoder Certo che puoi, è una domanda stupida.
Okx,

10
@Okx Non tutti i poster di sfida sono flessibili nei loro input consentiti, così vale sempre la pena chiedere.
TheLethalCoder

Risposte:


27

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, ...]


6
##&@@d&&##&@@? Che cosa fa anche quello?
Okx,

@Okx Aggiunta una spiegazione.
Martin Ender,

Potresti essere in grado di sostituire 0!=con 0<?
sergiol,

@sergiol Dovrei ordinare le cifre per farlo.
Martin Ender,

Nuova bassa leggibilità, infatti, normalmente Mathematica sembra un mucchio di sintassi-zucchero attorno ad alcuni nomi di funzioni che posso capire, non ero a conoscenza che potresti fare un programma completamente senza zucchero: p (ovviamente, la tua eccellente spiegazione fammi vedere che ovviamente non è tutto zucchero, ma comunque, davvero impressionante!)
mbrig

11

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.


1
Questo sta introducendo come una stringa?
Calcolatrice

2
Ciò ha due problemi: 1) non fornisce risposte di verità / falsità come specificato (sono solo 4 byte!); 2) genera un'eccezione sull'ingresso "10". Altrimenti, molto gentile e conciso!
CR Drost,

@CalculatorFeline Sì.
CR Drost,

@CRDrost 1) l'uscita ben definita quindi non ci sono problemi (di solito) 2) non ci sarà mai 0nell'input
Rod

1
1) Voglio dire, c'è un problema, ovvero che hanno chiesto X e tu non l'hai dato. 2) Ah, hai perfettamente ragione, me lo sono perso del tutto.
CR Drost,

8

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

6

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();
    }
}

5
Xkcd

6

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)

Non avevo familiarità con l'opzione \ n per i riferimenti a ritroso. +1. È possibile spostare la logica di test su un metodo per salvare un byte:s=>![...s].some((e,i)=>s%e|s.search(e)<i)
Rick Hitchcock,

Quando l'ho usato [...new Array(9999999)].map((_,n)=>n+1+"").filter(s=>![...s].some((e,i)=>s%e|s.search(e)<i)).lengthho ottenuto 5081invece del previsto 548, quindi questo non è corretto come scritto. Codice davvero stretto, però.
CR Drost,

Mi dispiace, ritiro il mio commento su questo non è corretto. Il mio codice di prova non è corretto perché il poster originale prevede che gli zeri siano già stati filtrati. Con un extra .filter(x => x.indexOf('0')===-1)questo restituisce 548 come promesso.
CR Drost,

6

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.

3
C'è anche gQV=se preferisci una soluzione solo ASCII.
Dennis,

5

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!


2
Benvenuti in PPCG!
Stephen,

Benvenuto! Come Rod's, la tua funzione genera un'eccezione sull'ingresso "10".
CR Drost,

1
@CRDrost "Ti verrà dato un numero intero positivo (che non conterrà mai uno 0) come input."
C McAvoy,

Bene, ho pubblicato commenti ovunque mi sono lamentato di questo, ma a quanto pare mi è mancato questo. Scusa, ritratta!
CR Drost,

@CRDrost Nessun problema!
C McAvoy,


2

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

2

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.


Questa funzione non riesce sull'ingresso 10.
CR Drost,

Siamo spiacenti, mi sbaglio a tale proposito: ho perso che non è necessario fornire alcuna risposta per gli input che contengono 0.
CR Drost,



1

Mathematica, 57 byte

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

1
È possibile salvare numerosi byte se si utilizza il comando incorporatoIsLynchBellNumber
Okx

1
perché non fai la stessa offerta a Martin?
J42161217

@Okx ma è meno divertente in questo modo.
QBrute,

@QBrute Puoi fare uno scherzo?
Okx,

1
@Okx Sarebbe stato più credibile LynchBellNumberQ. ;)
Martin Ender il

1

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!


1

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


1
Benvenuti in particolare al golf PPCG e Haskell! Questa risposta può essere notevolmente ridotta rimuovendo gli spazi superflui, ad esempio quelli attorno ai segni di uguale o accanto alla parentesi.
Laikoni,


@Laikoni Grazie per il tuo consiglio! Ci sto esaminando
Sergii Martynenko Jr


0

Neim , 9 byte

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

Provalo online!

-2 grazie a Okx .

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


Puoi giocare 𝐂D𝐮𝔼a golf 𝐮ℚ(unificare, verificare la parità ignorando i tipi)
Okx

C'è ancora spazio per giocare a golf lì;)
Okx

@Okx Hmm ... Non vedo nulla di particolarmente interessante lì.
Erik the Outgolfer,

0

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.

0

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.


0

Ruby 2.4, 42 byte

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

(Nessun TIO ancora, scusa)


0

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)

0

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


Non riesci a rimuovere alcuni degli spazi bianchi come 'L = "y"'
Okx

Tecnicamente sì! Avrei dovuto farlo ... a proposito, sto guardando le lingue di codegolf che potrebbero essere interessanti da imparare, ma per la maggior parte, la documentazione è minima o inesistente ... qualcuno può consigliare una buona lingua che è ben documentata? Stavo provando "Veramente / Seriamente" ma
ho incontrato


0

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.

0

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à


0

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")
}

0

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

0

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!


0

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.


0

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!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.