Desafio

Aqui no PPCG, com certeza gostamos de nossas sequências, então aqui está outra divertida .

Vamos definir a(n)como sendo o menor inteiro não negativo Xque não seja igual a any a(k)( 0 < k < n) a(n-1)e Xnão compartilhe nenhum dígito decimal.a(0) = 0

Dada uma entrada n > 0, saída tal a(n).

Por exemplo, para entrada n = 13, temos a(13) = 20, desde a(12) = 11e 20é o menor inteiro não negativo que ainda não vimos que não compartilha nenhum dígito decimal 11.

Seqüência

Aqui estão os 20 primeiros termos para você começar. Esta é a sequência A067581 no OEIS.

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

Regras

• Pode-se presumir que a entrada e a saída se encaixam no tipo inteiro nativo do seu idioma.
• A entrada e saída podem ser fornecidas em qualquer formato conveniente .
• Você pode optar por um índice 0, como eu estou aqui nos meus exemplos, ou um índice para sua submissão. Por favor, indique o que você está fazendo.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Python 2 , 85 bytes

^{-1 byte graças 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]

Experimente online!

Japonês , 18 bytes

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

Teste online! Acabei de adicionar o grecurso usado aqui, mas é algo que pretendo adicionar há muito tempo (e isso me levou ao limite, porque minha não gsolução era de cerca de 35 bytes).

Explicação

@   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

Pitão , 20 bytes

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

Experimente online! ou Experimente a suíte de testes.

Haskell, 79 bytes

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

O código é terrivelmente ineficiente. Para calcular valores maiores, ou seja,> 12, adicione f x|x<11=xentre as duas linhas (implementado a gno link TIO).

Experimente online!

JavaScript (ES6), 82 bytes

Indexado a 0.

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

Demo

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

Casca , 18 bytes

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

Uma solução indexada em 1. Experimente online!

Editar: bug corrigido para +1 byte.

Explicação

A função de iteração interna do Husk ¡tem muitos significados. Aqui, estou usando "construir lista infinita acrescentando repetidamente novos elementos computados a partir dos existentes". A segunda linha é a função auxiliar que calcula um novo 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.

A primeira linha é a função principal:

!¡₁;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 bytes

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

Seria ainda mais eficiente se o segundo argumento !não fosse a lista de números vistos, mas de números invisíveis. Mas não posso fazer isso sem usar mais bytes.

Experimente online!

Mathematica 115 Bytes

Ainda há espaço para jogar golfe - e talvez use recursão (aumentando a velocidade).

(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)&

Código detalhado original, com a mesma ideia básica:

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
]