Alcuni divisori di numeri interi positivi si odiano a vicenda e non amano condividere una o più cifre comuni.

Questi numeri interi sono chiamati Hostile Divisor Numbers ( HDN )

Esempi

Il numero 9566ha 4divisori: 1, 2, 4783 and 9566
(come puoi vedere, nessuno di loro condivide la stessa cifra ).
Pertanto, 9566 è un H ostile D ivisor N umber

Il numero NON9567 è HDN perché i suoi divisori ( ) condividono alcune cifre comuni. 1, 3, 9, 1063, 3189, 9567

Ecco i primi pochi HDN

1,2,3,4,5,6,7,8,9,23,27,29,37,43,47,49,53,59,67,73,79,83,86,87,89,97,223,227,229,233,239,257,263,267,269,277,283,293,307,337...       

Compito

L'elenco sopra riportato continua e il tuo compito è trovare l' ennesimo HDN

Ingresso

Un numero intero positivo nda 1a4000

Produzione

L' nth HDN

Casi test

ecco alcuni casi di test con 1 indice .
Indica quale sistema di indicizzazione usi nella tua risposta per evitare confusione.

input -> output     
 1        1     
 10       23       
 101      853     
 1012     26053     
 3098     66686      
 4000     85009      

Questo è code-golf , quindi vince il punteggio più basso in byte.

MODIFICARE

Buone notizie! Ho inviato la mia sequenza a OEIS e ...
I numeri divisori ostili sono ora OEIS A307636

05AB1E , 12 10 byte

µNNÑ€ÙSDÙQ

-2 byte grazie a @Emigna .

1-indicizzato

Provalo online o verifica la maggior parte dei casi di test (gli ultimi due casi di test vengono omessi, poiché scadono).

Spiegazione:

µ           # Loop while the counter_variable is not equal to the (implicit) input yet:
 N          #  Push the 0-based index of the loop to the stack
  NÑ        #  Get the divisors of the 0-based index as well
            #   i.e. N=9566 → [1,2,4783,9566]
            #   i.e. N=9567 → [1,3,9,1063,3189,9567]
    €Ù      #  Uniquify the digits of each divisor
            #   → ["1","2","4783","956"]
            #   → ["1","3","9","1063","3189","9567"]
      S     #  Convert it to a flattened list of digits
            #   → ["1","2","4","7","8","3","9","5","6"]
            #   → ["1","3","9","1","0","6","3","3","1","8","9","9","5","6","7"]
       D    #  Duplicate this list
        Ù   #  Unique the digits
            #   → ["1","2","4","7","8","3","9","5","6"]
            #   → ["1","3","9","0","6","8","5","7"]
         Q  #  And check if it is still equal to the duplicated list
            #   → 1 (truthy)
            #   → 0 (falsey)
            #  And if it's truthy: implicitly increase the counter_variable by 1
            # (After the loop: implicitly output the top of the stack,
            #  which is the pushed index)

Python 2 , 104 byte

n=input()
x=1
while n: 
 x=i=x+1;d={0};c=1
 while i:m=set(`i`*(x%i<1));c*=d-m==d;d|=m;i-=1
 n-=c
print x

Provalo online!

0-indicizzati.

JavaScript (ES6), 78 byte

1-indicizzati.

n=>eval("for(k=0;n;n-=!d)for(s=d=++k+'';k%--d||d*!s.match(`[${s+=d,d}]`););k")

Provalo online!

Versione più veloce, 79 byte

n=>{for(k=0;n;n-=!d)for(s=d=++k+'';k%--d||d*!s.match(`[${s+=d,d}]`););return k}

Provalo online!

Come?

Dato un intero $k>0$ , costruiamo la stringa $s$ come concatenazione di tutti i divisori di $k$ .

Poiché $k$ è sempre un divisore di se stesso, $s$ viene inizializzato in $k$ (costretto a una stringa) e il primo divisore che proviamo è $d=k-1$ .

$d$$k$$d$$s$$d$

Esempi

• $s=\text{"}956647832\text{"}$$d=1$"956647832".match(/[1]/)
• $s=\text{"}9567\text{"}$$d=3189$"9567".match(/[3189]/)

Commentate

Questa è la versione senza eval(), per leggibilità

n => {                   // n = input
  for(                   // for() loop:
    k = 0;               //   start with k = 0
    n;                   //   go on until n = 0
    n -= !d              //   decrement n if the last iteration resulted in d = 0
  )                      //
    for(                 //   for() loop:
      s =                //     start by incrementing k and
      d = ++k + '';      //     setting both s and d to k, coerced to a string
      k % --d ||         //     decrement d; always go on if d is not a divisor of k
      d *                //     stop if d = 0
      !s.match(          //     stop if any digit of d can be found in s
        `[${s += d, d}]` //     append d to s
      );                 //
    );                   //   implicit end of inner for() loop
                         // implicit end of outer for() loop
  return k               // return k
}                        //

Gelatina , 10 byte

ÆDQ€FQƑµ#Ṫ

Provalo online!

-1 byte grazie a ErikTheOutgolfer

Prende input da STDIN, il che è insolito per Jelly ma normale dove nfindviene utilizzato.

ÆDQ€FQƑµ#Ṫ  Main link
         Ṫ  Get the last element of
        #   The first <input> elements that pass the filter:
ÆD          Get the divisors
  Q€        Uniquify each (implicitly converts a number to its digits)
    F       Flatten the list
     QƑ     Does that list equal itself when deduplicated?

2-indicizzato

Perl 6 , 53 byte

{(grep {/(.).*$0/R!~~[~] grep $_%%*,1..$_},^∞)[$_]}

Provalo online!

1-indicizzati.

/(.).*$0/ corrisponde a qualsiasi numero con una cifra ripetuta.

grep $_ %% *, 1 .. $_restituisce un elenco di tutti i divisori del numero $_attualmente controllato per l'appartenenza all'elenco.

[~]concatena tutte queste cifre insieme, quindi R!~~abbina la stringa a destra con il motivo a sinistra. ( ~~è il solito operatore di corrispondenza, !~~è la negazione di Rquell'operatore ed è un metaoperatore che scambia gli argomenti di !~~.)

Python 2 (PyPy) , 117 114 byte

Utilizza 1-indicizzazione

k=input();n=0;r=range
while k:n+=1;k-=1-any(set(`a`)&set(`b`)for a in r(1,n+1)for b in r(1,a)if n%a<1>n%b)
print n

Provalo online!

Wolfram Language 103 byte

Utilizza 1-indicizzazione. Sono sorpreso che abbia richiesto così tanto codice.

(k=1;u=Union;n=2;l=Length;While[k<#,If[l[a=Join@@u/@IntegerDigits@Divisors@#]==l@u@a&@n,k++];n++];n-1)&

PowerShell , 112 byte

for($a=$args[0];$a-gt0){$z=,0*10;1..++$n|?{!($n%$_)}|%{"$_"|% t*y|sort -u|%{$z[+"$_"]++}};$a-=!($z|?{$_-ge2})}$n

Provalo online!

Prende 1 input indicizzato $args[0], lo memorizza in $a, scorre fino a quando non colpisce 0. Ogni iterazione, azzeriamo un array di dieci elementi $z(utilizzato per contenere i nostri conteggi delle cifre). Quindi costruiamo la nostra lista di divisori con 1..++$n|?{!($n%$_)}. Per ogni divisore, "$_"lo tlanciamo su una stringa , lo lanciamo oCharArra ye sortquelle cifre con la -ubandiera di nicchia (perché non ci interessa se un divisore stesso ha cifre duplicate). Quindi incrementiamo il conteggio delle cifre appropriato in $z. Quindi, diminuiamo $asolo se $zcontiene 0s e 1s (ovvero, abbiamo trovato un HDN). Se abbiamo terminato il nostro forciclo, ciò significa che abbiamo trovato il numero appropriato di HDN, quindi lasciamo $nsulla pipeline e l'output è implicito.

Python 3 , 115 byte

1-indicizzato

f=lambda n,x=1,s="",l="",d=1:n and(d>x+1and f(n-1,x+1)or{*s}&{*l}and f(n,x+1)or f(n,x,s+l,(1-x%d)*str(d),d+1))or~-x

Provalo online!

Questo utilizza molta ricorsione; anche con un aumento del limite di ricorsione, non può fare f(30). Penso che potrebbe essere ulteriormente giocabile a golf, e ho provato a trovare qualcosa con cui sostituire (1-x%d), ma non sono riuscito a trovare nulla ( -~-x%dha la precedenza sbagliata). Tutti i byte che possono essere rasati sono molto apprezzati.

Come funziona

# n: HDNs to go
# x: Currently tested number
# s: String of currently seen divisor digits
# l: String of digits of last tried divisor if it was a divisor, empty string otherwise
# d: Currently tested divisor

f=lambda n,x=1,s="",l="",d=1:n and(                    # If there are still numbers to go
                             d>x+1and f(n-1,x+1)or     # If the divisors have been
                                                       #  exhausted, a HDN has been found
                             {*s}&{*l}and f(n,x+1)or   # If there were illegal digits in
                                                       #  the last divisor, x isn't a HDN
                             f(n,x,s+l,(1-x%d)*str(d),d+1)
                                                       # Else, try the next divisor, and
                                                       #  check this divisor's digits (if
                                                       #  if is one) in the next call
                             )or~-x                    # Else, return the answer

Brachylog (v2), 14 byte

;A{ℕfdᵐc≠&}ᶠ⁽t

Provalo online!

Invio di funzioni; input da sinistra, output a destra. (Il collegamento TIO contiene un argomento della riga di comando per eseguire una funzione come se fosse un programma completo.)

Spiegazione

"È un numero divisore ostile?" decisionale problemacodice :

ℕfdᵐc≠
ℕ       number is ≥0 (required to match the question's definition of "nth solution")
 f      list of all factors of the number
   ᵐ    for each factor
  d       deduplicate its digits
    c   concatenate all the deduplications with each other
     ≠  the resulting number has no repeated digits

Questo è risultato sostanzialmente lo stesso di @ UnrelatedString, anche se l'ho scritto in modo indipendente.

wrapper "ennesima soluzione a un problema decisionale ":

;A{…&}ᶠ⁽t
    &      output the successful input to
  {  }ᶠ    the first n solutions of the problem
       ⁽   taking <n, input> as a pair
;A         form a pair of user input and a "no constraints" value
        t  take the last solution (of those first n)

Questo è uno di quei casi in cui il wrapper richiesto per produrre l'ennesimo output è significativamente più lungo del codice richiesto per testare ogni output a turno :-)

Ho inventato questo wrapper indipendentemente da @ UnrelatedString. È della stessa lunghezza e funziona secondo lo stesso principio, ma in qualche modo finisce per essere scritto in modo diverso. Ha un potenziale maggiore di miglioramento, in quanto potremmo aggiungere vincoli su quali valori stavamo cercando gratuitamente sostituendo Acon una variabile di vincolo, ma nessuna delle possibili variabili di vincolo salva byte. (Se esistesse una variabile di vincolo "numero intero non negativo", è possibile sostituirla Acon essa e quindi salvare un byte rendendo il ℕnon necessario.)

Java 10, 149 139 138 126 125 120 119 byte

n->{int r=0,i,d;for(;n>0;n-=d){var s="1";for(r+=d=i=1;i++<r;)if(r%i<1){d=s.matches(".*["+i+"].*")?0:d;s+=i;}}return r;}

-10 byte usando .matchesanziché .containsper cifra, ispirato alla risposta JavaScript di @Arnauld .
-5 byte grazie a @ValueInk
-1 byte grazie a @ceilingcat

1-indicizzato

Provalo online.

Spiegazione:

n->{                 // Method with integer as both parameter and return-type
  int r=0,           //  Result-integer, starting at 0
      i,             //  Index integer
      d;             //  Decrement integer
  for(;n>0;          //  Loop until the input `n` is 0:
      n-=d){         //    After every iteration: decrease `n` by the decrement integer `d`
    var s="1";       //   Create a String `s`, starting at "1"
    for(r+=d=i=1;    //   (Re)set the decrement and index integers to 1,
                     //   and increase the result by 1 as well
        i++<r;)      //   Inner loop `i` in the range [2, r]:
      if(r%i<1){     //    If `r` is divisible by `i`:
        d=s.matches(".*["+i+"].*")?
                     //     If string `s` contains any digits also found in integer `i`:
           0         //      Set the decrement integer `d` to 0
          :d;        //     Else: leave `d` unchanged
        s+=i;}}      //     And then append `i` to the String `s`
  return r;}         //  After the loops, return the result `r`

Brachylog , 16 byte

g{∧0<.fdᵐc≠∧}ᵘ⁾t

Provalo online!

Molto lento e il doppio di quanto sarebbe se questo fosse un problema decisionale . 1-indicizzati.

                    The output
               t    is the last
             ᵘ⁾     of a number of unique outputs,
g                   where that number is the input,
 {          }       from the predicate declaring that:
     .              the output
    <               which is greater than
   0                zero
  ∧                 (which is not the empty list)
      f             factorized
        ᵐ           with each factor individually
       d            having duplicate digits removed
          ≠         has no duplicate digits in
         c          the concatenation of the factors
           ∧        (which is not the output).

Wolfram Language (Mathematica) , 74 byte

Nest[1+#//.a_/;!Unequal@@Join@@Union/@IntegerDigits@Divisors@a:>a+1&,0,#]&

Provalo online!

Japt v2.0a0, 17 byte

_=â ®sâìUµZ¶â}f1

Provalo

Porta di questa risposta di Brachylog .

Credito: un risparmio totale di 4 byte grazie a Shaggy che ha anche suggerito una soluzione migliore che porta a molti più byte :)

Risposta originale approccio a 28 byte:

Èâ¬rÈ«è"[{Y}]" ©X+Y}Xs)«U´Ãa

Provalo

Porta di questa risposta JavaScript .

Icona , 123 byte

procedure f(n)
k:=m:=0
while m<n do{
k+:=1
r:=0
s:=""
every k%(i:=1 to k)=0&(upto(i,s)&r:=1)|s++:=i
r=0&m+:=1}
return k
end

Provalo online!

1-indicizzati. Davvero lento per grandi input.

Perl 6 , 74 byte

{(grep {!grep *>1,values [(+)] map *.comb.Set,grep $_%%*,1..$_},1..*)[$_]}

0-indicizzati. Solo i primi tre casi sono elencati su TIO poiché è troppo lento per testare il resto.

Provalo online!

Rubino , 110 97 92 84 byte

-13 byte sfruttando il controllo regex JavaScript di @ Arnauld .

-5 byte per scambiare il file times ciclo con un decrementatore e a while.

-8 byte cercando combinationqualcosa di più simile alle altre risposte.

->n{x=0;n-=1if(s='';1..x+=1).all?{|a|x%a>0||(e=/[#{a}]/!~s;s+=a.to_s;e)}while n>0;x}

Provalo online!

Perl 5 -p , 66 byte

map{1while(join$",map{$\%$_==0&&$_}1..++$\)=~/(\d).* .*\1/}1..$_}{

Provalo online!

1 indicizzato

J , ⁸⁷ 59 byte

-28 byte grazie a FrownFrog

0{(+1,1(-:~.)@;@(~.@":&.>@,i.#~0=i.|])@+{.)@]^:(>{:)^:_&0 0

Provalo online!

originale

J , 87 byte

[:{:({.@](>:@[,],([:(-:~.)[:-.&' '@,/~.@":"0)@((]#~0=|~)1+i.)@[#[)}.@])^:(#@]<1+[)^:_&1

Provalo online!

Yikes.

Questo è atrocemente lungo per J, ma non vedo grandi modi per abbatterlo.

spiegazione

Aiuta a introdurre un paio di verbi helper per vedere cosa sta succedendo:

d=.(]#~0=|~)1+i.
h=. [: (-:~.) [: -.&' '@,/ ~.@":"0

• d restituisce un elenco di tutti i divisori del suo argomento
• hti dice che un tale elenco è ostile. Stringe e deduplica ogni numero ~.@":"0, che restituisce una matrice quadrata in cui i numeri più corti sono riempiti di spazi. -.&' '@,/appiattisce la matrice e rimuove gli spazi, e infine (-:~.)ti dice se quel numero ha ripetizioni o meno.

Con questi due aiutanti il ​​nostro verbo generale, non golfato diventa:

[: {: ({.@] (>:@[ , ] , h@d@[ # [) }.@])^:(#@] < 1 + [)^:_&1

Qui manteniamo un elenco il cui capo è il nostro "candidato attuale" (che inizia da 1), e la cui coda sono tutti i numeri ostili trovati finora.

Aumentiamo la testa dell'elenco >:@[su ogni iterazione e aggiungiamo il "candidato corrente" solo se è ostile h@d@[ # [. Continuiamo a farlo fino a quando la lunghezza della nostra lista raggiunge 1 + n:^:(#@] < 1 + [)^:_ .

Alla fine, quando abbiamo finito, restituiamo l'ultimo numero di questo elenco [: {:che è l'ennesimo numero ostile.