Défi

Ici à PPCG, nous aimons vraiment nos séquences, alors voici un autre amusant .

Définissons a(n)comme étant le plus petit entier non négatif Xqui ne correspond pas à une a(k)( 0 < k < net) a(n-1)et Xne partagent pas les chiffres décimaux.a(0) = 0

Étant donné une entrée n > 0, une sortie telle a(n).

Par exemple, pour l'entrée n = 13, nous avons a(13) = 20, car a(12) = 11et 20est le plus petit entier non négatif que nous n'avons pas encore vu qui ne partage aucun chiffre décimal avec 11.

Séquence

Voici les 20 premiers termes pour vous aider à démarrer. Il s'agit de la séquence A067581 sur OEIS.

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

Règles

• L'entrée et la sortie peuvent être supposées correspondre au type d'entier natif de votre langue.
• L'entrée et la sortie peuvent être données dans n'importe quel format pratique .
• Vous pouvez choisir entre 0-index, comme je suis ici dans mes exemples, ou 1-index pour votre soumission. Veuillez indiquer ce que vous faites.
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Python 2 , 85 octets

^{-1 octet grâce à 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]

Essayez-le en ligne!

Japt , 18 octets

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

Testez-le en ligne! Je viens d'ajouter la gfonctionnalité utilisée ici, mais c'est quelque chose que je voulais ajouter depuis longtemps (et cela m'a poussé à bout, car ma non- gsolution était d'environ 35 octets).

Explication

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

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

Essayez-le en ligne! ou Essayez la suite de tests.

Haskell, 79 octets

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

Le code est horriblement inefficace. Pour calculer des valeurs plus grandes, c'est-à-dire> 12, ajoutez f x|x<11=xentre les deux lignes (implémenté a gdans le lien TIO).

Essayez-le en ligne!

JavaScript (ES6), 82 octets

0 indexé.

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

Démo

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

Husk , 18 octets

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

Une solution indexée 1. Essayez-le en ligne!

Edit: correction d'un bug pour +1 octet.

Explication

La fonction d'itération intégrée de Husk ¡a de nombreuses significations. Ici, j'utilise "construire une liste infinie en ajoutant à plusieurs reprises de nouveaux éléments calculés à partir des éléments existants". La deuxième ligne est la fonction d'assistance qui calcule un nouvel élément:

ḟȯ¬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 première ligne est la fonction 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 octets

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

Il serait encore plus efficace que le deuxième argument à !ne soit pas la liste des nombres vus mais des nombres invisibles. Mais je ne peux pas faire ça sans utiliser plus d'octets.

Essayez-le en ligne!

Mathematica 115 octets

Il reste encore de la place pour jouer au golf - et peut-être utiliser la récursion (l'accélérant ainsi).

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

Code détaillé original, avec la même idée de 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
]