Le titre est composé de 'Sequence Index Digit Not'.

Défi:

Étant donné un entier nqui est >= 0, sortez le n'ème numéro de la séquence suivante.
Voici les 50 premiers éléments, avec son index (0 indexé) au-dessus:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
1 0 3 2 5 4 7 6 9 8 22 20 30 24 23 26 25 28 27 32 11 33 10 14 13 16 15 18 17 31 12 29 19 21 50 40 41 42 44 45 35 36 37 51 38 39 52 53 55 56 34

Comment fonctionne cette séquence?

Le numéro à l'index ndoit être le premier dans l'ordre qui n'a pas de chiffres en commun avec n, et ne s'est pas encore produit pour les index précédents. Donc, quand nous regardons une séquence normale comme celle-ci à partir de 0-60:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

Nous définissons les n'th valeurs comme ceci:

• 0: Le premier nombre ( 0) contient le même chiffre, nous recherchons donc le suivant ( 1), qui ne contient pas le même chiffre. Donc, les n=0sorties 1.
• 1: Le premier nombre ( 0) ne contient pas le même chiffre, donc n=1sort 0.
• 2: Nous avons déjà rencontré 0et 1, et le chiffre suivant ( 2) contient le même chiffre, nous recherchons donc le suivant ( 3), qui ne contient pas le même chiffre. Donc, les n=2sorties 3.
• ...
• 10: Nous avons déjà rencontré 0-9, donc la prochaine ligne est 10. 10-19contenir le chiffre correspondant 1, 20contient le chiffre correspondant 0, 21contient le chiffre correspondant de 1nouveau, 22est valide, de sorte que les n=10sorties 22.
• etc.

Règles du défi:

• Si votre langue est indexée 1 (ou si vous le souhaitez), vous êtes autorisé à démarrer la séquence à 3 2 5 4 7 ...(en sautant 1at n=0et 0at n=1).
• L'indice minimum le plus grand que vous devriez prendre en charge est 25,000. REMARQUE: la séquence s'arrête à l'index 1,023,456,788, car l'index suivant dans la ligne contient les 10 chiffres.
• Vous êtes également autorisé à produire / renvoyer un tableau / liste de la séquence entière jusqu'à et y compris l'index nsi vous le souhaitez.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

Cette séquence a en fait créé des paires concernant l'index et les sorties. Si l'index nsort o, l'index osort n. Vous pouvez donc saisir la gauche ou la droite, et la sortie sera de l'autre côté:

0      <->  1       (this test case is optional)
2      <->  3
10     <->  22
12     <->  30
34     <->  50
89     <->  100
111    <->  200
112    <->  300
199    <->  322
2231   <->  4456
9605   <->  11118
19235  <->  46000
23451  <->  60668
25000  <->  13674

Voici une boîte à pâte des 25 001 premiers cas de test si vous voulez en essayer d'autres.

Pyth , 18 octets

u+Gf!|}TG@`H`T0hQY

Essayez-le ici! ou Vérifiez plus de cas de test!

Notez que cela renvoie la séquence entière jusqu'à l'index N , mais le lien ne renvoie que le dernier nombre, en ajoutant un e(fin). Si vous voulez voir la valeur brute retournée par ce programme, supprimez-la simplement .

Comment ça marche

u + Gf! |} TG @ `H`T0hQY - Programme complet.

u ... hQY - Réduisez hQ (l'entrée incrémentée) de gauche à droite, avec le
                       fonction ... (G, H), avec la valeur de départ Y (la liste vide).
                       G est la valeur actuelle et H est l'indice d'itération.
   f 0 - Premier entier à partir de 0, qui satisfait à ce qui suit:
      } TG - Apparaît dans G ...
     | @ `H`T - Ou son intersection (chaîne) avec l'index courant (H) est
                        non vide.
    ! - NON logique (négation booléenne).
 + G - Ajouter la valeur obtenue ci-dessus à la valeur actuelle (G).
                      Cela devient la valeur donnée pour la prochaine itération.
                    - Imprimez implicitement tous les résultats intermédiaires, ou ajoutez e pour imprimer 
                      le dernier.

Python 2 , 92 91 89 88 octets

a=()
i=0
exec"x=0\nwhile set(`x`)&set(`i`)or x in a:x+=1\na+=x,;i+=1;"*-~input()
print a

Essayez-le en ligne!

Imprime une liste des premiers n+1nombres

Approche différente, beaucoup plus rapide:

Python 2 , 96 octets

n=input()
r=range(9*n)
i=0
exec"x=0\nwhile set(`r[x]`)&set(`i`):x+=1\nprint r.pop(x),;i+=1;"*-~n

Essayez-le en ligne!

Haskell, 80 69 octets

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

Essayez-le en ligne!

Très lent pour les grands n.

f n=
    [x|x<-[0..]     ] !!0          -- pick the first of all 'x' from [0..]
                                   -- where
      all(`notElem`show n)$show x  -- no digit of 'n' appears in 'x', and
      all(/=x)                     -- 'x' is not seen before, i.e. not in the list
               f<$>[0..n-1]        -- 'f' mapped to [0..n-1]

Modifier: @Laikoni a enregistré 10 octets. Merci!

APL (Dyalog) , 39 octets

0∘{0=⍵:1⋄(~⍺∊0∇¨⍳⍵)∧⊃∧/≠/⍕¨⍺⍵:⍺⋄⍵∇⍨⍺+1}

Utilise ⎕IO←0.

Essayez-le en ligne!

Comment?

Récursivité.

0=⍵:1 - devinez.

~⍺∊0∇¨⍳⍵ - l'argument gauche (accumulateur) n'est pas déjà dans les résultats précédents

∧⊃∧/≠/⍕¨⍺⍵- et la représentation sous forme de chaîne de l'accumulateur et nsont différentes

:⍺ - puis renvoyez l'accumulateur.

⍵∇⍨⍺+1 - sinon, incrémenter l'accumulateur et recurse.

Python 3 , 92 octets

o=1,
for i in range(int(input())):
 x=0
 while{*str(x),x}&{*str(~i),*o}:x+=1
 o+=x,
print(o)

Essayez-le en ligne!

Ceci imprime tous les termes jusqu'au N ème. Merci à Dennis pour  -4  -5 octets!

Java (OpenJDK 8) , 218 217 213 210 202 200 172 171 170 168 167 octets

Je ne peux pas croire que je ne suis pas revenu ktout ce temps ...

i->{int j=-1,k=0,y=1;for(String r=" ",e=r;j++<i;r+=~-k+e,y=1)for(k=0;y>0;k++)for(int f:(k+(y=0)+"").getBytes())y+=(e+j).indexOf(f)<0&!r.contains(e+k+e)?0:1;return~-k;}

Essayez-le en ligne!

Aller , 217 205 octets

package g;import("fmt";"strconv";"strings");var(
d=make(map[int]int)
a=strconv.Itoa)
func G(L int){k,i:=0,0;for;i<=L;i++{s:=a(i);k=0;for d[k]>0||strings.ContainsAny(a(k),s){k++;}
d[k]=1;}
fmt.Print(a(k));}

Version alternative (programme au lieu d'un package): Essayez-le en ligne!

Améliorations:

• supprimé l'espace après l'extérieur foren utilisant plusieurs affectations pouri,k
• l'importation de "fmt";+ fmt.Printest plus courte que os.Stdout.WriteString(conservation à partir du package mainmoment où os.Args était nécessaire)

JavaScript (ES6), 103 88 81

Modifier révisé, y compris de nombreuses idées intelligentes par @Neil

n=>eval("for(r=[j=i=0];i<=n;)j=r[j]||(i+'').match(`[${j}]`)?j+1:!(r[k=j]=++i);k")

Point de départ

Idée de base: une boucle de 0 à n, et une boucle interne vérifiant les valeurs toujours non utilisées

n=>{
  var r=[]
  for(i=0;i<=n;i++)
  {
    s=new Set(i+'')
    for(j=-1;s;)
    {
      if (!r[++j] && ![...j+''].some(d=>s.has(d)))
      {
        r[j]=1
        console.log(i,j)
        s=0
      }
    }
  }
  return j
}

Version actuelle plus lisible

n=>{
  for(r = [j=i=0]; i <= n; )
    if (r[j] || (i+'').match(`[${j}]`))
      ++j
    else
      r [k=j] = ++i,
      j = 0;
  return k
}

Tester

var f=
n=>eval("for(r=[j=i=0];i<=n;)j=r[j]||(i+'').match(`[${j}]`)?j+1:!(r[k=j]=++i);k")

update=_=>{
  var i=+I.value
  if (i < 1e4 || confirm("Really?")) {
    O.textContent=i + ' -> ...'
    setTimeout(_=>O.textContent=i + ' -> ' + f(i), 100)
  }
}  

update()

<input id=I value=100 type=number max=1023456788>
<button onclick='update()'>Go</button>
(slow when input > 1000)
<pre id=O></pre>

Octave , 114 octets

N=input("");o=[1];for i=1:N;j=0;while(any(o==j)||nnz(ismember(int2str(i),int2str(j))));j++;end;o=[o,j];end;[0:N;o]

Essayez-le en ligne!

Merci à Kevin Cruijssen et Dlosc pour la comparaison des personnages au golf.

Non golfé

N=input("");o=[1];

for i=1:N;
    j=0;
    while(any(o==j)||nnz(ismember(int2str(i),int2str(j))));
        j++;
    end;
    o=[o,j];
end;
[0:N;o]

Explication de base:

• Boucle externe et boucle interne, une pour l'index iet une autre pour la valeur à ajouterj

• Pour chacun i, continuez à incrémenter jsi l'une des conditions suivantes est remplie:

  1. Tout ja déjà été utilisé
  2. Celui-ci s'amuse. Tout d'abord, divisez chaque valeur numérique en un vecteur de chiffres (par exemple, 10devient [1 0]) en utilisant int2str. Ensuite, comparez les deux nombres en utilisant ismember(par exemple, [1 0]et [2 1]reviendriez [1 0]), puis nnzpour voir si des colonnes correspondent.

• Si aucune de ces conditions n'est remplie, vous avez le numéro suivant! Ajouter à o, la matrice de sortie

• Imprimer les index originaux avec la matrice de sortie

Perl 5 , 60 octets

Code 59 octets + 1 pour -p.

$_="@{[0..($;=++$_)*9]}";$_=eval's/\b[^ $-]+ //;$-++;$&;'x$

Essayez-le en ligne! (Comprend -là des fins visuelles et $-=0;pour réinitialiser chaque itération)

Pip , 30 octets

29 octets de code, +1 pour l' -pindicateur.

Fn,a+1{Y0WyNl|_NyMSn++ylPBy}l

Essayez-le en ligne!

Sort la liste entière. Avertissement: très inefficace; le 2231boîtier d'entrée fonctionne depuis plus de 35 minutes sur mon ordinateur portable et n'est toujours pas terminé.

Explication

                               a is cmdline arg, l is [] (implicit)
Fn,a+1{                    }   For each n in range(a+1):
       Y0                       Yank 0 into y
         W                      While...
          yNl|                  y is in l, or...
              _Ny               lambda function: arg is in y
                 MSn            mapped to digits of n and result list summed
                                (i.e., any digit of n is in y):
                    ++y          Increment y
                       lPBy     Once we have a y that meets the criteria, push it to
                                the back of l
                            l  Output l (formatted with -p flag)

Visual Basic .NET (.NET 4.5) , 260 259 octets

-1 octet grâce à Kevin Cruijssen

Function A(n)
Dim p=New System.Collections.Generic.List(Of Long),j="0",g=0
For i=0To n
j=0
While 1
If Not p.Contains(j)Then
g=1
For Each c In i.ToString
If j.Contains(c)Then g=0
Next
If g Then Exit While
End If
j+=1
End While
p.Add(j)
Next
A=p(n)
End Function

Boucle à travers, générant des termes précédents dans la séquence pour ensuite comparer plus tard. Ensuite, itère le nombre sous forme de chaîne à la recherche de correspondances.

Abuse le système de frappe de VB.NET. Par exemple, jest une chaîne, mais l'ajout d'un convertit pour moi un entier. Les entiers sont convertis en booléens où 0est Falseet le reste sont True.

Essayez-le en ligne!

Gelée , 20 octets

^{Pyth bat Jelly. Allez M. Xcoder!}

Df⁹LD¤ȯeṆ
0ç1#ɓ;
1Ç¡

Un programme complet prenant l'entrée de STDIN et la sortie dans l'option de format de liste en utilisant la représentation de liste de Jelly *. Utilise l'indexation standard basée sur 0.

* les listes d'éléments simples n'ont pas d'environnement [], donc les 0sorties 1, tandis que les 1sorties [1, 0]etc.

Essayez-le en ligne!

Comment?

Df⁹LD¤ȯeṆ - Link 1, can append n to current? n, number; current, list
D         - convert n to decimal list
     ¤    - nilad followed by link(s) as a nilad:
  ⁹       -   chain's right argument, current
   L      -   length
    D     -   convert to a decimal list
 f        - filter discard from left if not in right
       e  - n exists in current?
      ȯ   - left logical OR right (empty lists are falsey)
        Ṇ - logical NOT

0ç1#ɓ; - Link 2, append next number: current, List
   #   - n find (count up finding first n matches):
  1    - ...finding: 1 match
0      - ...stating at: n=0
 ç     - ...doing: the last link as a dyad (left=n, right=current)
    ɓ  - new swapped-arg-dyadic chain (left = current, right = list of the found n)
     ; - concatenate

1Ç¡ - Main link: no arguments
1   - initialise the return value to 1
  ¡ - repeat input() times:
 Ç  -   last link (2) as a monad
    - implicit print