Reto

Aquí en PPCG, seguro que nos gustan nuestras secuencias, así que aquí hay otra divertida .

Vamos a definir a(n)como el menor entero no negativo Xque no es igual a cualquier a(k)( 0 < k < n), y a(n-1), y Xno comparten ninguna dígitos decimales.a(0) = 0

Dada una entrada n > 0, salida tal a(n).

Por ejemplo, para la entrada n = 13, tenemos a(13) = 20, ya que a(12) = 11y 20es el número entero no negativo más pequeño que no hemos visto todavía y que no comparte ningún dígito decimal 11.

Secuencia

Aquí están los primeros 20 términos para comenzar. Esta es la secuencia A067581 en OEIS.

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

Reglas

• Se puede suponer que la entrada y la salida encajan en el tipo de entero nativo de su idioma.
• La entrada y la salida se pueden dar en cualquier formato conveniente .
• Puede optar por 0-index, como estoy aquí en mis ejemplos, o 1-index para su envío. Por favor, indique lo que está haciendo.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Python 2 , 85 bytes

^{-1 byte gracias 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]

Pruébalo en línea!

Japt , 18 bytes

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

¡Pruébalo en línea! Acabo de agregar la gfunción utilizada aquí, pero es algo que he querido agregar durante mucho tiempo (y esto me empujó al límite, porque mi falta de gsolución era de alrededor de 35 bytes).

Explicación

@   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 bytes

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

Pruébalo en línea! o Prueba la suite de prueba.

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

El código es horriblemente ineficiente. Para calcular valores mayores, es decir,> 12, agregue f x|x<11=xentre las dos líneas (implementado a gen el enlace TIO).

Pruébalo en línea!

JavaScript (ES6), 82 bytes

0 indexado.

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

Manifestación

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

Casco , 18 bytes

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

Una solución indexada 1. Pruébalo en línea!

Editar: error corregido para +1 byte.

Explicación

La función de iteración incorporada de Husk ¡tiene muchos significados. Aquí, estoy usando "construir lista infinita agregando repetidamente nuevos elementos calculados a partir de los existentes". La segunda línea es la función auxiliar que calcula un nuevo 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 primera línea es la función 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![]!!)

Sería aún más eficiente si el segundo argumento !no fuera la lista de números vistos sino de números no vistos. Pero no puedo hacer eso sin usar más bytes.

Pruébalo en línea!

Mathematica 115 Bytes

Todavía hay espacio para jugar golf, y tal vez usar la recursividad (acelerando así).

(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 detallado original, con la misma idea 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
]