Sfida

Qui a PPCG, ci piacciono sicuramente le nostre sequenze, quindi eccone un'altra divertente .

Definiamo a(n)come essendo il più piccolo intero non negativo X, che non è uguale a qualsiasi a(k)( 0 < k < n), e a(n-1)e Xnon condividere cifre decimali.a(0) = 0

Dato un input n > 0, output tale a(n).

Ad esempio, per l'input n = 13, abbiamo a(13) = 20, poiché a(12) = 11ed 20è il numero intero non negativo più piccolo che non abbiamo ancora visto che non condivide cifre decimali 11.

Sequenza

Ecco i primi 20 termini per iniziare. Questa è la sequenza A067581 su OEIS.

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22, 11, 20, 13, 24, 15, 23, 14, 25

Regole

• Si può presumere che l'input e l'output si adattino al tipo intero nativo della tua lingua.
• L'input e l'output possono essere forniti in qualsiasi formato conveniente .
• Puoi scegliere di 0-index, come sono qui nei miei esempi, o 1-index per la tua presentazione. Si prega di indicare ciò che si sta facendo.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Python 2 , 85 byte

^{-1 byte grazie a Dead Possum}

n=0,
exec"i=0\nwhile set(`i`)&set(`n[-1]`)or i in n:i+=1\nn+=i,;"*input()
print n[-1]

Provalo online!

Japt , 18 byte

@A{!ZøA «As oX}a}g

Provalo online! Ho appena aggiunto la gfunzionalità utilizzata qui, ma è qualcosa che intendevo aggiungere da molto tempo (e questo mi ha spinto oltre il limite, perché la mia non gsoluzione era di circa 35 byte).

Spiegazione

@   A{!ZøA «  As oX}a}g
XYZ{A{!ZøA &&!As oX}a}gU
                           Implicit: U = input integer
   {                 }gU   Starting with [0, 1], return the U'th item generated by
XYZ{                 }     this function: (X = previous item, Y = index, Z = full array)
    A{             }a        Return the smallest non-negative integer A where
      !ZøA &&                  Z does not contain A (A is not yet in the sequence), and
             !As oX            A.toString() does not contain any of the same chars as X.
                           Implicit: output result of last expression

Pyth , 20 byte

eu+Gf!|/GT@`eG`T0Q]0

Provalo online! oppure Prova la suite di test.

Haskell, 79 byte

f 0=0
f x=[i|i<-[1..],all((/=i).f)[1..x-1],all(`notElem`show(f$x-1))$show i]!!0

Il codice è orribilmente inefficiente. Per calcolare valori più grandi, ovvero> 12, aggiungere f x|x<11=xtra le due righe (implementato a gnel collegamento TIO).

Provalo online!

JavaScript (ES6), 82 byte

0-indicizzati.

f=(n,x=[1,p=0])=>n--?f(x[(g=k=>x[k]||(k+'').match(`[${p}]`)?g(k+1):p=k)(0)]=n,x):p

dimostrazione

f=(n,x=[1,p=0])=>n--?f(x[(g=k=>x[k]||(k+'').match(`[${p}]`)?g(k+1):p=k)(0)]=n,x):p

for(n = 0; n < 50; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Buccia , 18 byte

!¡₁;0
ḟȯ¬V€d→⁰d-⁰N

Una soluzione con 1 indice. Provalo online!

Modifica: corretto bug per +1 byte.

Spiegazione

La funzione di iterazione integrata di Husk ¡ha molti significati. Qui sto usando "costruisci un elenco infinito aggiungendo ripetutamente nuovi elementi calcolati da quelli esistenti". La seconda riga è la funzione di supporto che calcola un nuovo elemento:

ḟȯ¬V€d→⁰d-⁰N  Takes a list of existing elements, e.g. x = [0,1,...,10]
           N  The positive integers
         -⁰   with elements of x removed:        [11,12,13,...
ḟȯ            Find an element n of this list that satisfies:
        d     Digits of n.
   V          Is any of them
    €         an element of
     d        the digits of
      →⁰      the last element of x?
  ¬           Negate.
              Returns 22.

La prima riga è la funzione principale:

!¡₁;0  Takes an integer k.
 ¡     Iterate adding new elements to the list
   ;0  [0]
  ₁    using the helper function,
!      take k'th element of result.

Haskell, 78 byte

n!k|r:_<-[j|j<-[1..],all(/=j)k,all(`notElem`show n)$show j]=n:r!(r:k)
(0![]!!)

Sarebbe ancora più efficace se il secondo argomento !non fosse l'elenco di numeri visti ma di numeri invisibili. Ma non posso farlo senza usare più byte.

Provalo online!

Mathematica 115 byte

C'è ancora spazio per giocare a golf e forse usare la ricorsione (accelerando così).

(For[z={0};i=1,Length@z<#,
For[i=1,!FreeQ[z,i]||!DisjointQ@@IntegerDigits/@{l,i},i++];
z~AppendTo~i;l=Last@z;
];l)&

Codice verboso originale, con la stessa idea di base:

MakeSequenceA067581[n_]:=Module[{list={0}, innerCounter=1},

While[Length@list<n,
innerCounter=1;
(* inner loop *)While[Or[MemberQ[list,innerCounter],Intersection[IntegerDigits[Last@list],IntegerDigits[innerCounter]]!={}],innerCounter++];
AppendTo[list,innerCounter];
];
list
]