标题由“ Sequence Index Digit Not”组成。

挑战：

给定的整数n，其是>= 0，输出的n“日数以下序列组成。
以下是前50个项目，其上方是（0索引）索引：

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

这个序列如何运作？

索引处的数字n必须是第一个，以便与，，，，，，n和没有相同的数字。因此，当我们从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

我们这样定义n'th值：

• 0：第一个数字（0）包含相同的数字，因此我们寻找下一个（1），该数字不包含相同的数字。因此n=0输出1。
• 1：第一个数字（0）不包含相同的数字，因此n=1输出0。
• 2：：我们已经遇到过0和1，下一个数字（2）包含相同的数字，因此我们寻找3不包含相同数字的下一个（）。因此n=2输出3。
• ...
• 10：我们已经遇到过0-9，所以下一个是10。10-19包含匹配数字1，20包含匹配数字0，再次21包含匹配数字1，22是有效的，因此n=10输出22。
• 等等

挑战规则：

• 如果您的语言使用1索引（或选择使用），则可以从处开始序列3 2 5 4 7 ...（跳过1at n=0和0at n=1）。
• 您应支持的最小最大索引为25,000。注意：该序列在index处停止1,023,456,788，因为该行中的下一个index包含所有10位数字。
• 如果需要，您还可以输出/返回整个序列的数组/列表，包括索引n。

一般规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
• 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法和返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能，请为您的代码添加一个带有测试的链接。
• 另外，如有必要，请添加说明。

测试用例：

该序列实际上创建了有关索引和输出的对。如果n输出o索引，则o输出索引n。因此，您可以输入左侧或右侧，而输出将是另一侧：

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

如果您想尝试其他测试用例，这里是前25,001个测试用例的粘贴框。

Pyth，18个字节

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

在这里尝试！或检查更多的测试用例！

请注意，这将返回直到索引N的整个序列，但是链接通过在前面加上一个e（end），仅返回最后一个数字。如果要查看此程序返回的原始值，只需将其删除。

怎么运行的

u + Gf！|} TG @`H`T0hQY-完整程序。

u ... hQY-用从左到右减小hQ（输入递增）
                       函数...（G，H），起始值为Y（空列表）。
                       G是当前值，H是迭代索引。
   f 0-从0开始的第一个整数，满足以下条件：
      } TG-出现在G ...
     | @`H`T-或它与当前索引（H）的（字符串）交点为
                        非空。
    ！-逻辑非（布尔取反）。
 + G-将以上获得的值附加到当前值（G）。
                      这成为下一次迭代的给定值。
                    -隐式打印所有中间结果，或添加e以打印 
                      最后一个。

Python 2中，92个 91 89 88字节

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

在线尝试！

打印第一个n+1数字的列表

不同的方法，速度更快：

Python 2，96个字节

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

在线尝试！

Haskell，80 69字节

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

在线尝试！

大的非常慢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]

编辑：@Laikoni保存了10个字节。谢谢！

APL（Dyalog），39字节

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

用途⎕IO←0。

在线尝试！

怎么样？

递归。

0=⍵:1 - 猜一下。

~⍺∊0∇¨⍳⍵ -左arg（累加器）尚未在以前的结果中

∧⊃∧/≠/⍕¨⍺⍵-与累加器的字符串表示n形式不同

:⍺ -然后返回蓄能器。

⍵∇⍨⍺+1 -否则，增加累加器并递归。

Python 3，92个字节

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

在线尝试！

这将打印所有术语，直到第N个。感谢Dennis的 -4  -5个字节！

的Java（OpenJDK的8） ，218 217 213 210 202 200 172 171 170 168 167字节

我不敢相信我一直都没有回国k...

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

在线尝试！

Go，217205字节

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

备用版本（程序而不是程序包）：在线尝试！

改进之处：

• for通过使用多个分配来删除外部后的空间i,k
• 导入"fmt";+ fmt.Print的时间比os.Stdout.WriteString（package main需要os.Args时的 保持时间）短

JavaScript（ES6），103 88 81

编辑修订，包括@Neil的许多聪明的主意

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

初始点

基本思想：从0到n的循环，并且仍未使用检查值的内部循环

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
}

当前版本更具可读性

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

测试

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>

八度，114字节

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]

在线尝试！

多亏了Kevin Cruijssen和Dlosc进行的高尔夫角色比较。

不打高尔夫球

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]

基本说明：

• 外循环和内循环，一个用于索引i，另一个用于添加值j

• 对于每个i，j如果满足以下任一条件，则继续增加：

  1. 任何j以前曾经使用过
  2. 这个很有趣。首先，使用将每个数值拆分为数字向量（例如，10变为[1 0]）int2str。然后，使用ismember（例如[1 0]和[2 1]将返回[1 0]）比较两个数字，然后nnz查看是否有任何列匹配。

• 如果以上都不满足，则您有下一个号码！附加到o，输出矩阵

• 使用输出矩阵打印原始索引

Perl 5，60个字节

59个字节的代码+ 1个-p。

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

在线尝试！（包括-l用于视觉目的和$-=0;重置每次迭代）

点，30字节

29个字节的代码，-p标志+1 。

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

在线尝试！

输出整个列表。警告：效率极低；该2231输入的情况下已经运行了我的笔记本电脑35+分钟，仍然没有完成。

说明

                               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字节

-1字节感谢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

遍历，在序列中生成先前的项，然后进行比较。然后将数字迭代为字符串以查找匹配项。

滥用VB.NET的键入系统。例如，j是一个字符串，但是对我来说加一个将转换为整数。整数将转换为，其中0is为False，其余为are的布尔值True。

在线尝试！

果冻，20 字节

^{Pyth击败了Jelly。去Xcoder先生！}

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

一个完整的程序，从STDIN接收输入，并使用Jelly的列表表示*以列表格式选项输出。使用基于0的标准索引。

*单个元素列表周围没有[]，因此0输出1，而1输出[1, 0]等。

在线尝试！

怎么样？

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