Il titolo è composto da "Sequence Index Digit Not".

Sfida:

Dato un numero intero nche è >= 0, genera il n'numero numero della sequenza seguente.
Ecco i primi 50 elementi, con l'indice (indicizzato 0) sopra di esso:

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

Come funziona questa sequenza?

Il numero all'indice ndeve essere il primo nell'ordine in cui non ci sono cifre in comune ne non si è ancora verificato per gli indici precedenti. Quindi, quando osserviamo una sequenza normale come questa da 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

Definiamo i n'valori in questo modo:

• 0: Il primo numero ( 0) contiene la stessa cifra, quindi cerchiamo il prossimo ( 1), che non contiene la stessa cifra. Quindi n=0uscite 1.
• 1: Il primo numero ( 0) non contiene la stessa cifra, quindi n=1genera 0.
• 2: Abbiamo già riscontrato 0e 1, e la cifra successiva ( 2) contiene la stessa cifra, quindi cerchiamo la prossima ( 3), che non contiene la stessa cifra. Quindi n=2uscite 3.
• ...
• 10: Ci siamo già incontrati 0-9, quindi il prossimo in linea è 10. 10-19contiene la cifra corrispondente 1, 20contiene la cifra corrispondente 0, 21contiene di 1nuovo la cifra corrispondente , 22è valida, quindi gli n=10output 22.
• eccetera.

Regole della sfida:

• Se la tua lingua è 1-indicizzata (o scegli di farlo), puoi iniziare la sequenza in 3 2 5 4 7 ...(saltando 1at n=0e at 0at n=1).
• L'indice minimo più grande che dovresti supportare è 25,000. NOTA: la sequenza si arresta all'indice 1,023,456,788, poiché l'indice successivo in linea contiene tutte e 10 le cifre.
• Puoi anche generare / restituire un array / elenco dell'intera sequenza fino all'indice incluso, nse lo desideri.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

Questa sequenza ha effettivamente creato coppie riguardanti l'indice e gli output. Se l'indice ngenera o, indicizza le ouscite n. Quindi puoi inserire sia a sinistra che a destra, e l'uscita sarà dall'altra parte:

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

Ecco una pastebin dei primi 25.001 casi di test se vuoi provarne altri.

Pyth , 18 byte

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

Provalo qui! oppure Controlla altri casi di test!

Si noti che questo restituisce l'intera sequenza fino all'indice N , ma il collegamento restituisce solo l'ultimo numero, anteponendo una e(fine). Se vuoi vedere il valore grezzo restituito da questo programma, rimuovilo .

Come funziona

u + Gf! |} TG @ `H`T0hQY - Programma completo.

u ... hQY - Riduci hQ (input incrementato) da sinistra a destra, con
                       funzione ... (G, H), con valore iniziale Y (elenco vuoto).
                       G è il valore corrente e H è l'indice di iterazione.
   f 0 - Primo numero intero a partire da 0, che soddisfa quanto segue:
      } TG - Appare in G ...
     | @ `H`T - O la sua intersezione (stringa) con l'indice corrente (H) è
                        non vuoto.
    ! - NOT logico (negazione booleana).
 + G - Aggiunge il valore ottenuto sopra al valore corrente (G).
                      Questo diventa il valore dato per la successiva iterazione.
                    - Stampa implicitamente tutti i risultati intermedi o aggiungi e per stampare 
                      l'ultimo.

Python 2 , 92 91 89 88 byte

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

Provalo online!

Stampa un elenco dei primi n+1numeri

Approccio diverso, che è molto più veloce:

Python 2 , 96 byte

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

Provalo online!

Haskell, 80 69 byte

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

Provalo online!

Molto lento per grandi 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]

Modifica: @Laikoni ha salvato 10 byte. Grazie!

APL (Dyalog) , 39 byte

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

Usi ⎕IO←0.

Provalo online!

Come?

Ricorsione.

0=⍵:1 - prova a indovinare.

~⍺∊0∇¨⍳⍵ - left arg (accumulatore) non è già nei risultati precedenti

∧⊃∧/≠/⍕¨⍺⍵- e la rappresentazione in formato stringa dell'accumulatore e nsono diverse

:⍺ - quindi restituire l'accumulatore.

⍵∇⍨⍺+1 - in caso contrario, incrementare l'accumulatore e il consumo.

Python 3 , 92 byte

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

Provalo online!

Questo stampa tutti i termini fino all'N . Grazie a Dennis per  -4  -5 byte!

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

Non posso credere di non essere semplicemente tornato per ktutto questo tempo ...

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

Provalo online!

Vai , 217 205 byte

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

Versione alternativa (programma anziché pacchetto): provalo online!

miglioramenti:

• rimosso lo spazio dopo l'esterno forutilizzando l'assegnazione multipla peri,k
• l'importazione "fmt";+ fmt.Printè più breve di os.Stdout.WriteString( package mainholdover da quando era necessario os.Args)

JavaScript (ES6), 103 88 81

modificare Revisionato con molte idee intelligenti di @Neil

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

Punto di partenza

Idea di base: un ciclo da 0 a n e un ciclo interno che controlla i valori non ancora utilizzati

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
}

Versione corrente più leggibile

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

Test

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>

Ottava , 114 byte

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]

Provalo online!

Grazie a Kevin Cruijssen e Dlosc per il confronto tra i personaggi del golf.

Ungolfed

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]

Spiegazione di base:

• Ciclo esterno e ciclo interno, uno per l'indice ie un altro per il valore da aggiungerej

• Per ciascuno i, continua ad aumentare jse si verifica una delle seguenti condizioni:

  1. Qualcuno jè stato usato prima
  2. Questo si diverte. Innanzitutto, dividi ciascun valore numerico in un vettore di cifre (ad esempio, 10diventa [1 0]) utilizzando int2str. Quindi, confronta i due numeri usando ismember(ad esempio, [1 0]e [2 1]ritornerebbe [1 0]) e quindi nnzper vedere se le colonne corrispondono.

• Se nessuna delle precedenti è soddisfatta, hai il prossimo numero! Aggiungi a o, la matrice di output

• Stampa gli indici originali con matrice di output

Perl 5 , 60 byte

59 byte codice + 1 per -p.

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

Provalo online! (Include -lper scopi visivi e $-=0;per ripristinare ogni iterazione)

seme , 30 byte

29 byte di codice, +1 per la -pbandiera.

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

Provalo online!

Emette l'intero elenco. Avvertenza: altamente inefficiente; la 2231custodia di input ha funzionato per oltre 35 minuti sul mio laptop e non è ancora terminata.

Spiegazione

                               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 byte

-1 byte grazie a 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

Passa attraverso, generando i termini precedenti nella sequenza per poi confrontarli in seguito. Quindi scorre il numero come una stringa in cerca di corrispondenze.

Abusa del sistema di battitura di VB.NET. Ad esempio, jè una stringa, ma l'aggiunta di uno converte in un numero intero per me. I numeri interi vengono convertiti in booleani dove 0è Falsee il resto sono True.

Provalo online!

Gelatina , 20 byte

^{Pyth batte Jelly. Vai Mr. Xcoder!}

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

Un programma completo che prende input da STDIN e produce l'opzione del formato elenco usando la rappresentazione elenco Jelly *. Utilizza l'indicizzazione basata su 0 standard.

* gli elenchi di singoli elementi non hanno contorni [], quindi gli 0output1 , mentre 1output [1, 0]ecc.

Provalo online!

Come?

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