제목은 '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'값을 정의합니다 .

• 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 ...(건너 뛰는 1에서 n=0과 0에서를 n=1).
• 지원해야하는 최소 최대 지수는 25,000입니다. 참고 : 1,023,456,788다음 색인 행에는 10 자리 숫자가 모두 포함되어 있기 때문에 시퀀스는 index 에서 멈 춥니 다 .
• n원하는 경우 색인을 포함하여 전체 시퀀스의 배열 / 목록을 출력 / 반환 할 수 있습니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 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(끝) 을 앞에 붙여서 마지막 숫자 만 반환합니다 . 이 프로그램에서 반환 된 원시 값을 보려면 제거하십시오 .

작동 원리

u + Gf! |} TG @`H`T0hQY-전체 프로그램.

u ... hQY-왼쪽에서 오른쪽으로 hQ (입력 증가)를 줄입니다.
                       함수 ... (G, H), 시작 값 Y (빈 목록).
                       G는 현재 값이고 H는 반복 인덱스입니다.
   f 0-0부터 시작하는 첫 번째 정수이며 다음을 충족합니다.
      } TG-G로 표시됩니다 ...
     | @`H`T-또는 현재 색인 (H)과의 (문자열) 교차점은
                        비어 있지 않습니다.
    ! -논리 NOT (부울 부정).
 + G-위에서 얻은 값을 현재 값 (G)에 추가합니다.
                      이것은 다음 반복에 주어진 값이됩니다.
                    -모든 중간 결과를 내재적으로 인쇄하거나 인쇄에 e를 추가 
                      마지막 하나.

파이썬 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숫자 의 목록을 인쇄 합니다

훨씬 빠른 다른 접근 방식 :

파이썬 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

온라인으로 사용해보십시오!

하스켈, 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 -그렇지 않으면 누산기를 증가시키고 재귀하십시오.

파이썬 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 번째 까지 인쇄합니다 . 덕분에 데니스 에 대한  -4  -5 바이트!

자바 (오픈 JDK 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;}

온라인으로 사용해보십시오!

이동 , 217 205 바이트

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 mainos.Args가 필요할 때의 이월) 보다 짧음

자바 스크립트 (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]

기본 설명 :

• 외부 루프 및 내부 루프, 하나는 index i이고 다른 하나는 추가 할 값j

• 각각 에 대해 다음 중 하나가 충족되면 i계속 증가시킵니다 j.

  1. 모든는 j이전에 사용 된
  2. 이거 재미있어 먼저을 사용하여 각 숫자 값을 숫자로 구성된 벡터로 분할합니다 (예 : 10가 됨 [1 0]) int2str. 그런 다음를 사용하여 두 숫자를 비교하고 ismember(예 : [1 0]및 [2 1]return [1 0]) nnz열이 일치하는지 확인하십시오.

• 위의 어느 것도 충족되지 않으면 다음 번호가 표시됩니다! o출력 행렬에 추가

• 출력 행렬을 사용하여 원본 색인 인쇄

펄 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 바이트

Kevin Cruijssen 덕분에 -1 바이트

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이고 나머지는 True입니다 부울로 변환됩니다 .

온라인으로 사용해보십시오!

젤리 , 20 바이트

^{피스 는 젤리를 이겼다 . 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