Nhiệm vụ của bạn khá đơn giản, hãy tính phần tử thứ n của A190810 .

Các yếu tố của A190810 được tính theo các quy tắc sau:

1. Phần tử đầu tiên là 1
2. Trình tự đang tăng lên
3. Nếu xxảy ra trong chuỗi, 2x+1và 3x-1cũng làm

Bạn có thể sử dụng lập chỉ mục dựa trên 1 hoặc 0, nhưng nếu bạn sử dụng lập chỉ mục dựa trên 0, vui lòng nói trong câu trả lời.

Các trường hợp thử nghiệm

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

Vì đây là môn đánh gôn, câu trả lời ngắn nhất bằng byte sẽ thắng!

Thạch , 16 byte

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

Rất kém hiệu quả. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Python 2, 88 83 72 byte

Bạn có thể muốn đọc các chương trình trong câu trả lời này theo thứ tự ngược lại ...

Chậm hơn và ngắn hơn, nhờ Dennis:

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

Dùng thử trực tuyến

Điều này không chạy nhanh, nhưng ngắn hơn ( 83 byte .) Bằng cách sắp xếp và loại bỏ trùng lặp mỗi lần lặp, cũng như loại bỏ phần tử đầu tiên, tôi loại bỏ sự cần thiết của một chỉ mục vào danh sách. Kết quả chỉ đơn giản là phần tử đầu tiên sau khi nlặp.

Tôi có thể đã ra sân Dennis. : D

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]

Dùng thử trực tuyến

Phiên bản dưới đây ( 88 byte ) chạy rất nhanh, tìm phần tử thứ 500000 trong khoảng hai giây.

Nó khá đơn giản. Tính toán các phần tử của danh sách cho đến khi có nhiều phần tử hơn ba lần n, vì mọi phần tử được thêm vào có thể thêm tối đa 2 phần tử độc đáo hơn. Sau đó loại bỏ trùng lặp, sắp xếp và in nphần tử thứ (không có chỉ mục.)

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]

Dùng thử trực tuyến

Python 2, 59 byte

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

Dựa trên câu trả lời Python của @ mbomb007 . Kiểm tra nó trên Ideone .

Haskell, 76 73 69 byte

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

Sử dụng một chỉ số dựa trên 0. Ví dụ sử dụng: (filter t[1..]!!) 54-> 255.

Thay vì xây dựng danh sách bằng cách liên tục chèn 2x+1và 3x-1như đã thấy trong hầu hết các câu trả lời khác, tôi đi qua tất cả các số nguyên và kiểm tra xem chúng có thể giảm xuống 1bằng cách áp dụng nhiều lần (x-1) / 2hoặc (x+1) / 3nếu chia hết.

Haskell, 77 74 byte

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

Điều này cung cấp một chức năng acho mục nhập thứ n. Nó không có chỉ mục. Ngoài ra, a=nub$f[1]sẽ tạo ra toàn bộ danh sách (uể oải).

Đây là một biến thể danh sách của Setmã Reinhard Zumkeller .

Python 2, 88 84 byte

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)

Kiểm tra nó trên Ideone .

Bình thường, 20 19 byte

hutS{+G,hyhGt*3hGQ0

Hãy thử trực tuyến. Bộ thử nghiệm.

Sử dụng lập chỉ mục dựa trên không.

Brachylog , 45 byte

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

Tính toán N = 1000trong khoảng 6 giây trên máy của tôi.

Đây là 1 chỉ mục, ví dụ

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

Giải trình

• Vị ngữ chính:

  :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
  

• Vị ngữ 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
         )
  

Bạn có thể lưu ý rằng chúng tôi không chuyển bất kỳ đầu vào nào cho vị ngữ 1 khi chúng tôi gọi y - Yield. Do lan truyền ràng buộc, nó sẽ tìm đúng đầu vào một khi đạt đến 1.mệnh đề sẽ truyền các giá trị đầu vào đúng.

MATL, 19, 18 17 byte

1w:"tEQy3*qvSu]G)

Đây là một thuật toán cực kỳ kém hiệu quả. Trình thông dịch trực tuyến hết bộ nhớ cho các đầu vào lớn hơn 13.

Một byte được lưu, nhờ Luis Mendo!

Hãy thử trực tuyến!

Phiên bản này dài hơn, nhưng hiệu quả hơn (21 byte)

1`tEQy3*qvSutnG3*<]G)

Dùng thử trực tuyến

Giải trình:

Cách hợp lý để làm điều đó là thêm các phần tử vào mảng cho đến khi đủ dài để lấy phần tử thứ i. Đó là cách hiệu quả của một hoạt động. Cách chơi golf (và không hiệu quả) để làm điều đó là chỉ tăng kích thước mảng i lần.

Vì vậy, trước tiên, chúng tôi xác định mảng bắt đầu : 1. Sau đó, chúng tôi trao đổi hai yếu tố hàng đầu, để đầu vào là trên cùng. w. Bây giờ, chúng tôi lặp qua đầu vào với :". Vì vậy, tôi lần:

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.

Bây giờ, chúng ta có một mảng khổng lồ của chuỗi. (Cách nhiều hơn mức cần thiết để tính toán) Vì vậy, chúng tôi dừng vòng lặp ]và lấy số thứ i từ mảng này với G)(1 chỉ mục)

JavaScript (ES6), 63 byte

 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)

Có lẽ từ bỏ nhanh chóng do sự đệ quy.

Võng mạc, 57

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

Hãy thử trực tuyến!

Chỉ số 0. Theo thuật toán được sử dụng thường xuyên: xóa giá trị tối thiểu khỏi tập hợp hiện tại, gọi nó xvà thêm 2x+1và 3x-1vào tập hợp số lần bằng với đầu vào, sau đó số dẫn đầu là kết quả. "Tập hợp" trong Retina chỉ là một danh sách được sắp xếp lặp đi lặp lại và được tạo để chỉ chứa các phần tử duy nhất. Có một số bit lén lút được thêm vào thuật toán cho golf, mà tôi sẽ giải thích một khi tôi đã có thêm thời gian.

Cảm ơn Martin rất nhiều vì đã chơi golf khoảng 20 byte!

Clojure, 114 108 byte

#(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)))))

Tôi sẽ không ngạc nhiên nếu điều này có thể bị đánh golf / giảm đi một lượng đáng kể nhưng việc setkhông hỗ trợ thứ n thực sự làm tổn thương đến suy nghĩ của tôi.

Thử trực tuyến

Phiên bản có dấu cách:

#(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 byte

Sử dụng mã hóa CP-1252 .

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

Giải trình

$                  # 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

Dùng thử trực tuyến với số lượng nhỏ

Rất chậm.
Sử dụng lập chỉ mục dựa trên 0.

C ++, 102 byte

[](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;};

Hàm lambda này yêu cầu #include <map>và using std::map.

Ở mapđây chỉ là một bộ sưu tập các phím; giá trị của chúng bị bỏ qua. Tôi sử dụng mapđể hưởng lợi từ mã terse để chèn:

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

Nhờ thứ tự được sắp xếp của map, phần tử nhỏ nhất được trích xuất bởi k.begin()->first.

Trên thực tế, 27 byte

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

Hãy thử trực tuyến!

Chương trình này sử dụng lập chỉ mục dựa trên 0. Cách tiếp cận rất mạnh mẽ, vì vậy đừng hy vọng nó sẽ hoạt động trong trình thông dịch trực tuyến cho các đầu vào lớn hơn.

Giải trình:

╗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 byte)

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

Bản demo trực tuyến . Lưu ý rằng điều này sử dụng lập chỉ mục dựa trên không.

Điều này sử dụng một cách tiếp cận tương tự với hầu hết: áp dụng nthời gian biến đổi , sau đó sắp xếp và trích xuất nmục thứ. Như một cái gật đầu cho hiệu quả, sự trùng lặp được áp dụng bên trong vòng lặp và việc sắp xếp được áp dụng bên ngoài vòng lặp.

Võng mạc , 48 byte

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

Hãy thử trực tuyến!

Lấy cảm hứng từ câu trả lời của nimi, tôi nghĩ rằng tôi đã thử một cách tiếp cận khác cho Retina, sử dụng tính năng quay lui của công cụ regex để tìm hiểu xem có bất kỳ số nào (không chính thức) có trong chuỗi hay không. Hóa ra điều này có thể được xác định bằng regex 27 byte, nhưng việc sử dụng nó tốn kém hơn một chút, nhưng nó vẫn kết thúc ngắn hơn so với cách tiếp cận tổng quát.

Đây là một giải pháp 48 byte thay thế:

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

Và khi sử dụng I / O đơn phương, chúng ta có thể thực hiện 42 byte, nhưng tôi đang cố gắng tránh điều đó và câu trả lời Retina khác cũng sử dụng số thập phân:

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

Ruby, 70 byte

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

Giải trình

->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 byte

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

Sử dụng lập chỉ mục dựa trên không. Rất kém hiệu quả bộ nhớ.

Giải trình

{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

Octave, 68 byte

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

Perl, 173 132 byte +1 cho -n = 133

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

Ung dung:

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

Tôi có thể có thể làm tốt hơn nếu tôi nghĩ nhiều hơn về nó, nhưng đây là những gì tôi nghĩ ra chỉ sau vài phút. Lần đầu tiên tôi chơi golf, vì vậy điều này khá thú vị!

Cảm ơn @Dada và @ TùxCräftîñg (và một loạt các tối ưu hóa byte nhỏ) cho -40 byte

JavaScript (ES6), 58

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

Ít chơi gôn

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
}

Kiểm tra

Về thời gian và bộ nhớ: phần tử 500000 trong ~ 20 giây và 300MB được sử dụng bởi alpha 64 bit FireFox của tôi

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>