Herausforderung

Hier bei PPCG mögen wir unsere Sequenzen, also hier ist ein lustiger anderer.

Nehmen wir definieren a(n)als die kleinste nicht-negative ganze Zahl ist, Xdie zu einem nicht gleich ist a(k)( 0 < k < n), und a(n-1)und Xhaben keine Dezimalziffern nicht teilen.a(0) = 0

Bei einer Eingabe n > 0, Ausgabe wie z a(n).

Für die Eingabe n = 13haben wir zum Beispiel, a(13) = 20da a(12) = 11und 20die kleinste nicht negative Ganzzahl ist, die wir noch nicht gesehen haben und mit der keine Dezimalstellen geteilt werden 11.

Sequenz

Hier sind die ersten 20 Begriffe, mit denen Sie beginnen können. Dies ist die Sequenz A067581 in OEIS.

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

Regeln

• Es kann davon ausgegangen werden, dass die Eingabe und Ausgabe in den systemeigenen Ganzzahltyp Ihrer Sprache passen.
• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen .
• Sie können zwischen 0-Index, wie ich es in meinen Beispielen sehe, und 1-Index für Ihre Einreichung wählen. Bitte geben Sie an, was Sie tun.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Python 2 , 85 Bytes

^{-1 Byte dank 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]

Probieren Sie es online!

Japt , 18 Bytes

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

Online testen! Ich habe gerade das ghier verwendete Feature hinzugefügt , aber es ist etwas, das ich seit langem hinzufügen möchte (und das hat mich über den Rand gedrängt, weil meine Nicht- gLösung etwa 35 Byte groß war).

Erläuterung

@   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

Probieren Sie es online! oder Probieren Sie die Testsuite aus.

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

Der Code ist schrecklich ineffizient. Um größere Werte zu berechnen, dh> 12, addieren Sie f x|x<11=xzwischen den beiden Zeilen (implementiert gin der TIO-Verknüpfung).

Probieren Sie es online!

JavaScript (ES6), 82 Byte

0-indiziert.

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

Schale , 18 Bytes

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

Eine 1-indizierte Lösung. Probieren Sie es online!

Edit: Fehler für +1 Byte behoben.

Erläuterung

Die integrierte Iterationsfunktion von Husk ¡hat viele Bedeutungen. Hier verwende ich "Unendliche Liste durch wiederholtes Anhängen neuer Elemente erstellen, die aus den vorhandenen berechnet wurden". Die zweite Zeile ist die Hilfsfunktion, die ein neues Element berechnet:

ḟȯ¬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.

Die erste Zeile ist die Hauptfunktion:

!¡₁;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![]!!)

Es wäre noch effizienter, wenn das zweite Argument !nicht die Liste der gesehenen Zahlen, sondern der unsichtbaren Zahlen wäre. Aber ich kann das nicht tun, ohne mehr Bytes zu verwenden.

Probieren Sie es online!

Mathematica 115 Bytes

Noch Platz zum Golfspielen - und evtl. Rekursion nutzen (damit beschleunigen).

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

Ursprünglicher ausführlicher Code mit derselben Grundidee:

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
]