양의 정수 시퀀스를 정의 해 봅시다. 짝수에 대한 순서를 이전 항의 두 배로 정의합니다. 시퀀스의 홀수 인덱스는 시퀀스에 아직 나타나지 않은 가장 작은 양의 정수입니다.

첫 커플 용어는 다음과 같습니다.

1,2,3,6,4,8,5,10,7,14,9,18,11,22,12,24,13,26,15,30

이것을 연결 쌍 (n, 2n) 의 목록으로 생각할 수도 있습니다. 여기서 n 은 가장 사용되지 않은 양의 정수입니다.

태스크

입력 으로 숫자 n이 주어지면 이 순서에서 n 번째 항을 계산하십시오 .

이것은 코드 골프 이므로 바이트 단위로 측정 할 때 소스 코드의 크기를 최소화해야합니다.

OEIS A036552

하스켈, 40 바이트

l(a:r)=a:2*a:l[x|x<-r,x/=2*a]
(l[1..]!!)

제로 기반. l남아있는 정수의 게으른 목록에서 시퀀스를 점진적으로 빌드합니다.

자바 스크립트 (ES6), 92 82 69 67 65 바이트

n=>(F=i=>i^n?F(a[b=i&1?2*b:(g=k=>a[k]?g(k+1):k)(1)]=-~i):b)(a={})

방법?

우리는 다음을 추적합니다.

• 마지막으로 삽입 된 값 b .
• 조회 테이블에서 이전에 발견 된 모든 값 a .

내부적으로 우리는 0 기반 인덱스 i를 사용하고 있습니다. 따라서 홀수 및 짝수 동작이 반전됩니다.

• 홀수 위치에서 다음 값은 단순히 2 * b입니다.

• 짝수 위치에서 재귀 함수 g () 와 조회 테이블 a 를 사용하여 가장 작은 일치 값을 식별합니다.

  (g = k => a[k] ? g(k + 1) : k)(1)

몇 바이트를 절약하기 위해 i{} 대신 로 초기화됩니다 0. 이것은 우리에게 다음을 사용하도록 강요합니다.

• i^n비교 I를 가진 N 때문에 ({}) ^ n === n반면 ({}) - n가 평가 NaN.
• -~i문자열을 생성 하기 때문에 i 를 증가시킵니다 ({}) + 1.

데모

let f =

n=>(F=i=>i^n?F(a[b=i&1?2*b:(g=k=>a[k]?g(k+1):k)(1)]=-~i):b)(a={})

for(n = 1; n <= 20; n++) {
  console.log('a[' + n + '] = ' + f(n));
}

파이썬 3 , 80 72 69 바이트

^{Mr. Xcoder 덕분에 -7 바이트 !}

f=lambda n:n and[f(n-1)*2,min({*range(n+1)}-{*map(f,range(n))})][n%2]

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

젤리 , 15 바이트

Jḟ⁸ḢðḤṭṭ
0Ç¡Ḋị@

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

수학 , 56 53 바이트

^{JungHwan Min 감사합니다 -3 바이트 !}

(w={};Do[w~FreeQ~k&&(w=w~Join~{k,2k}),{k,#}];w[[#]])&

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

OEIS 링크에 제공된 Mathematica 표현을 기반으로합니다.

PHP , 64 바이트

for(;$argn-$i++;)if($i&$$e=1)for(;${$e=++$n};);else$e*=2;echo$e;

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

PHP , 77 바이트

for(;$argn-$i++;$r[]=$e)if($i&1)for(;in_array($e=++$n,$r););else$e*=2;echo$e;

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

PHP , 78 바이트

for(;$argn-$i++;)$e=$r[]=$i&1?end(array_diff(range($i,1),$r?:[])):2*$e;echo$e;

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

PHP, 56 바이트

while($$n=$i++<$argn)for($n*=2;$i&$$k&&$n=++$k;);echo$n;

PHP, 75 72 바이트

for($a=range(1,$argn);$i++<$argn;)$a[~-$n=$i&1?min($a):2*$n]=INF;echo$n;

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

05AB1E , 16 15 14 바이트

1- 색인.
시퀀스에서 홀수 인덱스에있는 요소의 이진 표현이 짝수의 0으로 끝나는 사실을 사용합니다. A003159 .

Lʒb1¡`gÈ}€x¹<è

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

설명

L                 # range [1 ... input]
 ʒ      }         # filter, keep only elements whose
  b               # ... binary representation
   1¡             # ... split at 1's
     `gÈ          # ... ends in an even length run
         €x       # push a doubled copy of each element in place
           ¹<è    # get the element at index (input-1)

파이썬 2 , 59 51 49 바이트

f=lambda n,k=2:2/n%-3*(1-k)or f(n+~(k&-k)%-3,k+1)

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

배경

모든 양의 n 정수는 n = 2 ^{o (n)} c (n)으로 고유하게 표현 될 수 있습니다 . 여기서 c (n) 은 홀수입니다.

하자 ⟨a _N을 ⟩ _{N> 0} 도전 사양에서 순서합니다.

모든 양의 정수 n 에 대해 o (a _2n-1 ) 은 짝수입니다. 이후 O (a _2N ) = O (2A _2N-1 ) = O이 (a _2N-1 ) + (1) ,이 주장에 상당 O (a _2N를 ) 홀수 항상.

클레임이 거짓이라고 가정하고 2m-1 이 시퀀스의 첫 번째 홀수 인덱스가되어 o (a _2m-1 ) 가 홀수라고 가정합니다. 이것은 2m을 시퀀스의 첫 번째 짝수 인덱스로 만들어 o (a _2m-1 ) 이 짝수 임을 유의하십시오 .

O (a _2m-1 ) 홀수 및 0 있도록 짝수 _2m-1 로 나누어 2 . 정의에 의하면, _2m-1 은 IS 아직 순서에 표시되지 작은 양의 정수 즉, _2m-1 / 2 출두해야합니다. 하자 k는 의 (제 1) 수의 인덱스 _2m-1 / 2 에 .

이후 O (a _K ) = O (a _2m-1 / 2) = O (a _2m-1 ) - 1 , 심지어는 minimality 인 N 을 의미 k는 홀수이다. 차례로,이 수단 _{K + 1} = 2A의 _K = A _2m-1 의 정의 모순 _2m-1 .

작동 원리

아직 오지 않았다

R , 70 69 65 바이트

function(n){for(i in 2*1:n)F[i-1:0]=which(!1:n%in%F)[1]*1:2
F[n]}

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

하나의 인수를 취하는 익명 함수 F기본값 FALSE또는 0너무 알고리즘이 정확하게 어떤 양의 정수가 아직 순서 없음을 평가하는 것이.

알고리즘은 한 쌍의 생성 for(이하 방식으로 루프 i에서 진행 2하는 2n작성자 2)

           which(!1:n%in%l)[1]     # the missing value
                              *1:2 # keep one copy the same and double the next
l[i-1:0]=                         # store into l at the indices i-1 and i

하스켈 , 63 바이트

g x=[2*g(x-1),[a|a<-[1..],a`notElem`map g[1..x-1]]!!0]!!mod x 2

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

이것은 하스켈의 게으른 평가를 최대한 남용합니다.

펄 6 , 50 바이트

{(1,{@_%2??2*@_[*-1]!!first *∉@_,1..*}...*)[$_]}

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

• 1, { ... } ... *는 첫 번째 이후의 각 항이 중괄호로 구분 된 코드 블록에 의해 제공되는 지연 생성 무한 시퀀스입니다. 블록이@_ 배열을 배열의 전체 현재 시퀀스를받습니다.
• 현재 요소 수가 홀수 ( @_ % 2) 이면 짝수 색인 요소를 생성하므로 다음 요소는 지금까지 마지막 요소의 두 배 2 * @_[*-1]입니다.
• 그렇지 않으면 시퀀스에 아직 나타나지 않은 첫 번째 양의 정수를 얻습니다 first * ∉ @_, 1..*.
• $_외부 함수에 대한 인수입니다. 함수의 반환 값을 제공하여 무한 시퀀스로 인덱싱합니다.

수학, 82 바이트

(s={};a=1;f=#;While[f>0,If[s~FreeQ~a,s~AppendTo~{a,2a}];a++;f--];Flatten[s][[#]])&

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

k, 27 bytes

*|{x,*(&^x?!y;|2*x)2!y}/!2+

1-indexed. Try it online!

Using (!y)^x instead of &^x?!y works too.

C# (Visual C# Interactive Compiler), 82 bytes

x=>{int y=1;for(var s="";x>2;x-=2)for(s+=2*y+":";s.Contains(++y+""););return x*y;}

Try it online!

-6 bytes thanks to @ASCIIOnly!

Clojure, 102 bytes

#(nth(loop[l[0 1 2 3]i %](if(= i 0)l(recur(conj l(*(last l)2)(nth(remove(set l)(range))0))(dec i))))%)

Iterates n times to build up the sequence and returns the nth item, 1-indexed.

Ruby, 60 bytes

->n,*a{eval"v+=1while a[v];a[v]=a[2*v]=v+v*n%=2;"*(n/2+v=1)}

0-indexed. We loop n/2+1 times, generating two values each time and storing them by populating an array at their indices. v+v*n%2 gives the output, either v or v*2 depending on the parity of n.

Ruby, 49 bytes

->n{*s=t=0;s|[t+=1]==s||s<<t<<t*2until s[n];s[n]}

Start with [0], add pairs to the array until we have at least n+1 elements, then take the n+1th (1-based)

Try it online!

JavaScript (ES6), 60 65 bytes

An iterative solution.

n=>eval("for(s={},i=0;n;)s[++i]?0:(s[i+i]=--n)?--n?0:i+i:i")

Less golfed

n=>{
  s = {}; //hashtable for used values
  for(i=0; n; )
  {
    if ( ! s[++i] )
    {
      s[i*2] = 1; // remember i*2 is already used
      if (--n)
        if (--n)
          0;
        else
          result = i*2;
      else
        result = i;
    }
  }
  return result;  
}

Test

F=
n=>eval("for(s={},i=0;n;)s[++i]?0:(s[i+i]=--n)?--n?0:i+i:i")

for (a=1; a < 50; a++)
  console.log(a,F(a))

Jelly, 13 12 10 bytes

ḤRọ2ḂĠZFị@

This uses the observation from my Python answer.

Try it online!

How it works

ḤRọ2ḂĠZFị@  Main link. Argument: n

Ḥ           Unhalve; yield 2n.
 R          Range; yield [1, ... , 2n].
  ọ2        Compute the order of 2 in the factorization of each k in [1, ..., 2n].
    Ḃ       Bit; compute the parity of each order.
     G      Group the indices [1, ..., 2n] by the corresponding values.
      Z     Zip/transpose the resulting 2D array, interleaving the indices of 0
            with the indices of 1, as a list of pairs.
       F    Flatten. This yields a prefix of the sequence.
        ị@  Take the item at index n.