O título é composto, a partir de 'Sequence Index Digit Not'.

Desafio:

Dado um número inteiro nque é >= 0, produza o n'número th da seguinte sequência.
Aqui estão os 50 primeiros itens, com o índice (indexado 0) acima:

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

Como essa sequência funciona?

O número no índice ndeve ser o primeiro na ordem em que não há nenhum dígito em comum ne ainda não ocorreu nos índices anteriores. Então, quando olhamos para uma sequência normal como esta em 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

Definimos os n'th th values ​​assim:

• 0: O primeiro número ( 0) contém o mesmo dígito, portanto, procuramos o próximo ( 1), que não contém o mesmo dígito. Então n=0saídas 1.
• 1: O primeiro número ( 0) não contém o mesmo dígito, então n=1gera 0.
• 2: Já encontramos 0e 1, e o próximo dígito ( 2) contém o mesmo dígito, procuramos o próximo ( 3), que não contém o mesmo dígito. Então n=2saídas 3.
• ...
• 10: Já encontramos 0-9, então o próximo da fila é 10. 10-19contém o dígito correspondente 1, 20contém o dígito correspondente 0, 21contém o dígito correspondente 1novamente, 22é válido, portanto, é n=10emitido 22.
• etc.

Regras do desafio:

• Se o seu idioma estiver indexado em 1 (ou você optar por), você poderá iniciar a sequência em 3 2 5 4 7 ...(pulando 1at n=0e 0at n=1).
• O maior índice mínimo que você deve oferecer suporte é 25,000. NOTA: A sequência para no índice 1,023,456,788, porque o próximo índice na linha contém todos os 10 dígitos.
• Você também tem permissão para produzir / retornar uma matriz / lista de toda a sequência, incluindo o índice, nse desejar.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

Essa sequência realmente criou pares em relação ao índice e às saídas. Se o índice ngerar o, o índice ogera n. Assim, você pode inserir a esquerda ou a direita e a saída será do outro lado:

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

Aqui está uma pasta dos primeiros 25.001 casos de teste, se você quiser experimentar outros.

Pitão , 18 bytes

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

Experimente aqui! ou Verifique mais casos de teste!

Observe que isso retorna a sequência inteira até o índice N , mas o link retorna apenas o último número, acrescentando um e(final). Se você deseja ver o valor bruto retornado por este programa, basta removê-lo .

Como funciona

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

u ... hQY - Reduza hQ (a entrada incrementada) da esquerda para a direita, com o
                       função ... (G, H), com valor inicial Y (a lista vazia).
                       G é o valor atual e H é o índice de iteração.
   f 0 - Primeiro número inteiro iniciando em 0, que satisfaz o seguinte:
      } TG - Aparece em G ...
     | @ `H`T - Ou sua interseção (string) com o índice atual (H) é
                        não vazio.
    ! - NÃO lógico (negação booleana).
 + G - Acrescente o valor obtido acima ao valor atual (G).
                      Este se torna o valor fornecido para a próxima iteração.
                    - Imprima implicitamente todos os resultados intermediários ou adicione e para imprimir 
                      o último.

Python 2 , 92 91 89 88 bytes

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

Experimente online!

Imprime uma lista dos primeiros n+1números

Abordagem diferente, que é muito mais rápida:

Python 2 , 96 bytes

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

Experimente online!

Haskell, 80 69 bytes

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

Experimente online!

Muito lento para grandes 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]

Edit: @Laikoni salvou 10 bytes. Obrigado!

APL (Dyalog) , 39 bytes

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

Usos ⎕IO←0.

Experimente online!

Quão?

Recursão.

0=⍵:1 - Adivinhe.

~⍺∊0∇¨⍳⍵ - arg esquerdo (acumulador) ainda não está em resultados anteriores

∧⊃∧/≠/⍕¨⍺⍵ - e a representação em cadeia do acumulador e n são diferentes

:⍺ - depois devolva o acumulador.

⍵∇⍨⍺+1 - caso contrário, incremente o acumulador e recorra.

Python 3 , 92 bytes

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

Experimente online!

Tudo isso imprime os termos até o N º um. Agradecimentos a Dennis por  -4  -5 bytes!

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

Não acredito que não voltei ktodo esse 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;}

Experimente online!

Go , 217 205 bytes

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

Versão alternativa (programa em vez de um pacote): Experimente online!

Melhorias:

• espaço removido após o exterior for , usando várias atribuições parai,k
• importar "fmt";+ fmt.Printé mais curto que os.Stdout.WriteString( package mainpermanência de quando os.Args era necessário)

JavaScript (ES6), 103 88 81

Edit Revised incluindo muitas idéias inteligentes por @Neil

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

Ponto de partida

Ideia básica: um loop de 0 a n, e um loop interno que verifica os valores ainda não utilizados

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
}

Versão atual mais legível

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

Teste

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>

Oitava , 114 bytes

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]

Experimente online!

Agradecimentos a Kevin Cruijssen e Dlosc pela comparação de personagens no golfe.

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]

Explicação básica:

• Loop externo e loop interno, um para índice i e outro para adicionar valorj

• Para cada um i, continue a incrementarj se um dos seguintes itens for atendido:

  1. Qualquer j já foi usado antes
  2. Este fica divertido. Primeiro, divida cada valor numérico em um vetor de dígitos (por exemplo, 10torna-se [1 0]) usando int2str. Em seguida, compare os dois números usando ismember(por exemplo, [1 0]e [2 1]retornaria [1 0]) e depois nnzpara ver se alguma coluna corresponde.

• Se nenhuma das opções acima for atendida, você terá o próximo número! Anexar a o, matriz de saída

• Imprimir índices originais com matriz de saída

Perl 5 , 60 bytes

Código de 59 bytes + 1 para -p.

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

Experimente online! (Inclui -lpara fins visuais e $-=0;para redefinir cada iteração)

Pip , 30 bytes

29 bytes de código, +1 para -psinalizador.

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

Experimente online!

Mostra a lista inteira. Aviso: altamente ineficiente; a2231 estojo de entrada está em execução há mais de 35 minutos no meu laptop e ainda não terminou.

Explicação

                               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 bytes

-1 byte graças 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

Faz um loop, gerando termos anteriores na sequência para comparar posteriormente. Em seguida, itera o número como uma string procurando correspondências.

Abusa do sistema de digitação do VB.NET. Por exemplo, jé uma sequência, mas adicionar uma se converte em um número inteiro para mim. Os números inteiros são convertidos em booleanos, onde 0está Falsee o restante éTrue .

Experimente online!

Gelatina , 20 bytes

^{Pyth vence Jelly. Vá, Sr. Xcoder!}

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

Um programa completo, com entrada do STDIN e saída no formato de lista, usando a representação de lista do Jelly *. Usa a indexação baseada em 0 padrão.

* as listas de elementos únicos não têm ambiente [], portanto as 0saídas 1, enquanto as 1saídas [1, 0]etc.

Experimente online!

Quão?

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