당신의 작업은 매우 간단합니다 .A190810 의 n 번째 요소를 계산하십시오 .

A190810의 요소는 다음 규칙에 따라 계산됩니다.

1. 첫 번째 요소는 1
2. 순서가 증가하고 있습니다
3. 경우 x다음 순서로 발생 2x+1하고 3x-1또한 할

1 기반 또는 0 기반 인덱싱을 사용할 수 있지만 0 기반 인덱싱을 사용하는 경우 답변에서 말하십시오.

테스트 사례

a(1) = 1
a(2) = 2
a(3) = 3
a(4) = 5
a(5) = 7
a(10) = 17
a(20) = 50
a(30) = 95
a(55) = 255

이것이 코드 골프이기 때문에 바이트 단위의 최단 답변이 이깁니다!

젤리 , 16 바이트

×3’;Ḥ‘$;
1Ç¡ṢQ³ị

매우 비효율적입니다. 온라인으로 사용해보십시오!

작동 원리

1Ç¡ṢQ³ị   Main link. Argument: n (integer)

1         Set the return value to 1.
 Ç¡       Execute the helper link n times.
   Ṣ      Sort the resulting array.
    Q     Unique; deduplicate the sorted array.
     ³ị   Retrieve its n-th element.


×3’;Ḥ‘$;  Helper link. Argument: A (array)

×3        Multiply all elements of A by 3.
  ’       Decrement the resulting products.
      $   Combine the two links to the left into a monadic chain.
    Ḥ     Unhalve; multiply all elements of A by 2.
     ‘    Increment the resulting products.
   ;      Concatenate 3A-1 and 2A+1.
       ;  Concatenate the result with A.

파이썬 2, 88 83 72 바이트

이 답변의 프로그램을 역순으로 읽으십시오 ...

Dennis 덕분에 여전히 느리고 짧습니다.

L=1,;exec'L+=2*L[0]+1,3*L[0]-1;L=sorted(set(L))[1:];'*input()
print L[0]

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

이것은 빠르게 실행되지 않지만 더 짧습니다 ( 83 바이트) . 각 반복을 정렬하고 제거하고 첫 번째 요소를 제거하면 목록에 인덱스가 필요하지 않습니다. 결과는 단순히 n반복 후 첫 번째 요소 입니다.

데니스를 골라 낸 것 같습니다. :디

L=[1]
n=input()
while n:L+=[2*L[0]+1,3*L[0]-1];n-=1;L=sorted(set(L))[1:]
print L[0]

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

이 버전 ( 88 바이트 ) 이하는 정말 빠르게 실행되어 약 2 초 안에 500000 번째 요소를 찾습니다.

꽤 간단합니다. n추가 된 모든 요소가 최대 2 개의 고유 한 요소를 추가 할 수 있으므로 요소보다 3 배 더 많은 요소가있을 때까지 목록의 요소를 계산 하십시오. 그런 다음 중복 n요소를 제거하고 th 요소를 정렬하고 인쇄하십시오 (인덱싱되지 않음).

L=[1]
i=0
n=input()
while len(L)<3*n:L+=[2*L[i]+1,3*L[i]-1];i+=1
print sorted(set(L))[n]

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

파이썬 2, 59 바이트

t={1}
exec'm=min(t);t=t-{m}|{2*m+1,3*m-1};'*input()
print m

@ mbomb007의 Python answer을 기반으로 합니다. Ideone에서 테스트하십시오 .

하스켈, 76 73 69 바이트

a#b=mod a b<1&&t(div a b)
t x=x<2||(x-1)#2||(x+1)#3
(filter t[1..]!!)

0부터 시작하는 인덱스를 사용합니다. 사용 예 : (filter t[1..]!!) 54-> 255.

반복적으로 삽입 2x+1하고 3x-1대부분의 다른 답변에서 볼 수 있듯이 목록을 작성하는 대신 모든 정수 1를 반복하여 반복적으로 적용 (x-1) / 2하거나 (x+1) / 3나눌 수 있는지 감소시킬 수 있는지 확인합니다 .

하스켈, 77 74 바이트

import Data.List
i=insert
f(x:y)=x:f(i(2*x+1)$i(3*x-1)y)
a=(!!)(nub$f[1])

이것은 an 번째 항목에 대한 기능 을 제공합니다 . 인덱스가 0입니다. 또는 a=nub$f[1]전체 목록을 게으르게 만듭니다.

Reinhard Zumkeller Set코드 의 목록 변형입니다 .

파이썬 2, 88 84 바이트

g=lambda k:g(k%2*k/2)|g(k%3/2*-~k/3)if k>1else k
f=lambda n,k=1:n and-~f(n-g(k),k+1)

Ideone에서 테스트하십시오 .

Pyth, 20 19 바이트

hutS{+G,hyhGt*3hGQ0

온라인으로 사용해보십시오. 테스트 스위트.

0부터 시작하는 인덱싱을 사용합니다.

Brachylog , 45 바이트

:1-I,?:?*:1ydo:Im.
1.|:1-:1&I(:3*:1-.;I*:1+.)

N = 1000내 컴퓨터에서 약 6 초 안에 계산 합니다.

이것은 1 인덱스입니다. 예 :

run_from_file('code.brachylog',1000,Z).
Z = 13961 .

설명

• 주요 술어 :

  :1-I,               I = Input - 1
       ?:?*           Square the Input
           :1y        Find the first Input*Input valid outputs of predicate 1
              do      Remove duplicates and order
                :Im.  Output is the Ith element
  

• 술어 1 :

  1.                  Input = Output = 1
  |                   Or
  :1-:1&I             I is the output of predicate 1 called with Input - 1 as input
         (            
           :3*:1-.      Output is 3*I-1
         ;            Or
           I*:1+.       Output is 2*I+1
         )
  

호출 할 때 술어 1에 입력을 전달하지 않습니다 y - Yield. 제약 조건 전파로 인해 1.올바른 입력 값을 전파하는 절 에 도달하면 올바른 입력을 찾습니다 .

MATL, 19, 18 17 바이트

1w:"tEQy3*qvSu]G)

이것은 매우 비효율적 인 알고리즘입니다. 온라인 인터프리터에 13보다 큰 입력에 대한 메모리가 부족합니다.

Luis Mendo 덕분에 1 바이트가 절약되었습니다!

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

이 버전은 더 길지만 더 효율적입니다 (21 바이트)

1`tEQy3*qvSutnG3*<]G)

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

설명:

논리적 인 방법은 i 번째 요소를 잡을 수있을 때까지 배열에 요소를 추가하는 것입니다. 그것이 효율적인 방법입니다. golfy (비효율적)을 할 수있는 방법은 바로 배열의 크기를 증가시키는 것이다 난의 시간을.

먼저 시작 배열을 정의합니다 1. 그런 다음 맨 위 두 요소를 바꾸어 입력이 맨 위에 오도록합니다. w. 이제로 입력을 반복합니다 :". 그래서 나는 시간 :

t             %Duplicate our starting (or current) array.
 EQ           %Double it and increment
   y          %Push our starting array again
    3*q       %Multiply by 3 and decrement
       v      %Concatenate these two arrays and the starting array
        Su    %Sort them and remove all duplicate elements.

자, 우리는 거대한 배열을 가지고 있습니다 . (계산하는 데 필요한 것 이상) 그래서 우리는 반복을 멈추고, (1 인덱스) ]를 사용 하여이 배열에서 i 번째 숫자를 가져옵니다.G)

자바 스크립트 (ES6), 63 바이트

 f=(n,a=[1],i=0)=>a[i++]?--n?f(n,a,a[i*2]=a[i*3-2]=1):i:f(n,a,i)

아마도 재귀로 인해 빨리 포기할 것입니다.

망막, 57

^.+
$*¶¶1
¶¶(1(1*))
¶1$1$1¶$2$1$1
O`
}`(¶1+)\1\b
$1
G2`
1

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

인덱스가 0입니다. 자주 사용되는 알고리즘을 따른다 : 현재 세트로부터 최소값 제거를 호출 x하고, 추가 2x+1및 3x-1횟수가 입력 같게 설정 한 다음 선두 번호 결과이다. Retina의 "세트"는 반복적으로 정렬되어 고유 한 요소 만 포함하도록 만들어진 목록입니다. 골프 알고리즘에 교묘 한 비트가 추가되었으며, 시간이 더 있으면 설명하겠습니다.

약 20 바이트를 골라 낸 Martin에게 감사합니다!

Clojure에서, 114 108 바이트

#(loop[a(sorted-set 1)n 1](let[x(first a)](if(= n %)x(recur(conj(disj a x)(+(* 2 x)1)(-(* 3 x)1))(inc n)))))

이것이 상당한 금액으로 골프 / 축소 될 수 있지만 놀랍지 않을 것입니다. 그러나 setn 번째를 지원하지 않으면 실제로 내 생각의 기차를 해칠 수 있습니다.

온라인으로 시도

공백이있는 버전 :

#(loop [a (sorted-set 1)
        n 1]
  (let [x (first a)]
    (if (= n %)
      x
      (recur (conj (disj a x) (+ (* 2 x) 1) (- (* 3 x) 1)) (inc n))
      )))

05AB1E, 18 17 바이트

CP-1252 인코딩을 사용합니다 .

$Fз>s3*<)˜Ù}ï{¹è

설명

$                  # initialize with 1
 F          }      # input number of times do
  Ð                # triplicate current list/number
   ·>              # double one copy and add 1
     s3*<          # multiply one copy by 3 and subtract 1
         )˜Ù       # combine the 3 lists to 1 list and remove duplicates
             ï{    # convert list to int and sort
               ¹è  # take the element from the list at index input

적은 수의 온라인으로 사용해보십시오

아주 느린.
0 기반 인덱싱을 사용합니다.

C ++, 102 바이트

[](int i){int t;map<int,int>k;for(k[1];i--;k.erase(t))t=k.begin()->first,k[t*2+1],k[t*3-1];return t;};

이 람다 함수에는 #include <map>및 이 필요합니다 using std::map.

다음 map은 단지 키 모음입니다. 해당 값은 무시됩니다. map삽입을위한 간결한 코드의 이점을 얻으려면 사용합니다 .

k[1]; // inserts the key 1 into the map

의 정렬 순서 덕분에 map가장 작은 요소가에 의해 추출됩니다 k.begin()->first.

실제로 27 바이트

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E

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

이 프로그램은 0 기반 인덱싱을 사용합니다. 이 접근 방식은 매우 무차별 적이므로 더 큰 입력을 위해 온라인 인터프리터에서 작동하지 않을 것으로 예상됩니다.

설명:

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E
╗                            save input (n) in register 0
 1#                          push [1]
   ╜                         push n
    `;;2*1+)3*1@-#++╔S`n     do the following n times:
     ;;                        make two copies of the list
       2*1+                    apply 2x+1 to each element in one copy
           )3*1@-              and 3x-1 to each element in the other copy
                 #             workaround for a weird list bug
                  ++           append those two lists to the original list
                    ╔S         uniquify and sort
                        ╜@E  get the nth element (0-indexed)

CJam (25 바이트)

ri1a1${{_2*)1$3*(}%_&}*$=

온라인 데모 . 이것은 0부터 시작하는 인덱싱을 사용합니다.

이것은 대부분 비슷한 방법을 사용합니다. 변환 n시간을 적용한 다음 n항목 을 정렬 및 추출합니다 . 효율성을 높이기 위해 중복 제거 기능이 루프 내부에 적용되고 정렬이 루프 외부에 적용됩니다.

레티 나 , 48 바이트

.+
$*
+1`^(((!*)!(!|\3)(?=\3!1))*!)1|\b
!$1
-2`.

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

nimi의 답변에서 영감을 얻은 Retina에 대해 다른 접근 방식을 시도하고 주어진 (단항) 숫자가 순서에 있는지 여부를 알아 내기 위해 정규식 엔진의 역 추적을 사용하려고 생각했습니다. 이것은 27 바이트 정규 표현식으로 결정할 수 있지만 비용을 사용하는 데 약간의 비용이 더 들지만 여전히 생성 방식보다 짧습니다.

대체 48 바이트 솔루션은 다음과 같습니다.

.+
$*
{`1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!

단항 I / O를 사용하면 42 바이트를 수행 할 수 있지만 피하려고 노력하고 다른 Retina 답변은 십진수도 사용합니다.

1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!
1

루비, 70 바이트

->n{a=*1
n.times{a<<a.map{|i|([2*i+1,3*i-1]-a).min||1.0/0}.min}
a[-2]}

설명

->n{
    # Magical, golfy way of initializing an array. Equivalent to a = [1].
    a=*1
    n.times{
        # Generate the next element in the sequence, by...
        a<<
            # ... finding the minimal term that will appear at some point.
            a.map{|i|
                ([2*i+1,3*i-1]-a).min||1.0/0
            }.min
    }
    # We generated n+1 elements, so we'll take the *second* to last one.
    a[-2]
}

J, 31 바이트

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]

0부터 시작하는 인덱싱을 사용합니다. 매우 메모리 비효율적입니다.

설명

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]  Input: n
                              ]  Identity function, gets n
 1                               The constant 1
  (                      )^:[~   Repeat n times with an initial array a = [1]
                       >:          Increment each in a
                     2*            Multiply by 2 to get 2a+2
             3&*                   Multiply each in a by 3 to get 3a
                 &:<:              Decrement both x and y to get 2a+1 and 3a-1
                ,                  Join them
    ]                              Identity function, gets a
            ,                      Join a with 2a+1 and 3a-1
         ~.@                       Take the distinct values
     /:~@                          Sort up
   ]                               Return the sorted list
{                                Select the value from the list at index n and return it

옥타브, 68 바이트

function r=a(n)s=1;for(i=1:n)r=s(i);s=union(s,[r*2+1 r*3-1]);end;end

펄 173 132 = -n (133)에 대한 +1 바이트

sub c{my$a=pop;return($a==1||($a%2&&c(($a-1)/2))?1:$a%3!=2?0:$a%3==2?c(($a+1)/3):1)}while($#b<$_){$i++;@b=(@b,$i)if c$i}say$b[$_-1];

언 골프 드 :

my @array = ();
my $n = <>;
sub chk {
    my $a = shift;
    return 1 if ($a == 1);
    if ($a % 2 == 0) {
        if ($a % 3 != 2) {
            return 0;
        } else {
            return chk(($a + 1) / 3);
        }
    } else {
        if (chk(($a - 1) / 2) == 0) {
            if ($a % 3 != 2) {
                return 0;
            } else {
                return chk(($a + 1) / 3);
            }
        } else {
            return 1
        }
    }
}
my $i = 1;
while ($#array < $n-1) {
    push(@array,$i) if (chk($i) == 1);
    $i++;
}
print $array[$n];

내가 그것에 대해 더 많이 생각한다면 아마 더 잘할 수 있지만, 이것은 몇 분 후에 나왔던 것입니다. 내 첫 골프, 그래서 이것은 꽤 재미 있었다!

-40 바이트에 대한 @Dada 및 @ TùxCräftîñg (및 많은 마이너 바이트 최적화) 덕분에

자바 스크립트 (ES6), 58

n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

덜 골프

n=>{
  a=[];
  a[1] = 1;
  for(i = 0; n;)
  {
    ++i
    if (a[i])
    {
      a[2*i+1] = 1;
      a[3*i-1] = 1;
      --n;
    }
  }
  return i
}

테스트

시간 및 메모리 정보 : FireFox 64 비트 알파에서 사용되는 ~ 20 초의 요소 500000 및 300MB

F=
n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

function test() {
  var n=+I.value, t0=+new Date
  O.textContent = F(n)
  console.log((+new Date-t0)/1000,'sec')
}  

test()

#I { width:5em}

<input id=I type=number value=10 oninput="test()"> 
<span id=O></span>