Tugas Anda cukup sederhana, hitung elemen ke- A1 A190810 .

Elemen A190810 dihitung berdasarkan aturan ini:

1. Elemen pertama adalah 1
2. Urutannya meningkat
3. Jika xterjadi dalam urutan, maka 2x+1dan 3x-1juga lakukan

Anda dapat menggunakan pengindeksan berbasis 1 atau 0, tetapi jika Anda menggunakan pengindeksan berbasis 0, harap katakan dalam jawaban.

Uji kasus

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

Karena ini adalah kode-golf, jawaban tersingkat dalam byte menang!

Jelly , 16 byte

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

Sangat tidak efisien. Cobalah online!

Bagaimana itu bekerja

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

Anda mungkin ingin membaca program dalam jawaban ini dalam urutan terbalik ...

Lebih lambat dan lebih pendek, terima kasih untuk Dennis:

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

Cobalah online

Ini tidak berjalan secepat, tetapi lebih pendek ( 83 byte .) Dengan menyortir dan menghapus duplikat setiap iterasi, serta menghapus elemen pertama, saya menghapus kebutuhan akan indeks ke dalam daftar. Hasilnya hanyalah elemen pertama setelah niterasi.

Saya mungkin telah bermain golf dengan 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]

Cobalah online

Versi di bawah ini ( 88 byte ) berjalan sangat cepat, menemukan elemen ke-500000 dalam waktu sekitar dua detik.

Sederhana saja. Hitung elemen daftar hingga ada tiga kali lebih banyak elemen daripada n, karena setiap elemen yang ditambahkan dapat menambahkan paling banyak 2 elemen lebih unik. Kemudian menghapus duplikat, mengurutkan, dan mencetak nelemen ke - th (diindeks nol.)

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]

Cobalah online

Python 2, 59 byte

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

Berdasarkan jawaban Python @ mbomb007 . Uji di 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..]!!)

Menggunakan indeks berbasis 0. Contoh penggunaan: (filter t[1..]!!) 54-> 255.

Alih-alih membangun daftar dengan memasukkan berulang kali 2x+1dan 3x-1seperti yang terlihat di sebagian besar jawaban lain, saya memeriksa semua bilangan bulat dan memeriksa apakah mereka dapat dikurangi menjadi 1dengan berulang kali menerapkan (x-1) / 2atau (x+1) / 3jika dapat dibagi.

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

Ini menyediakan fungsi auntuk entri ke-n. Ini nol diindeks. Atau, a=nub$f[1]akan membuat seluruh daftar (malas).

Ini adalah varian daftar Setkode 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)

Uji di Ideone .

Pyth, 20 19 byte

hutS{+G,hyhGt*3hGQ0

Cobalah online. Suite uji.

Menggunakan pengindeksan berbasis nol.

Brachylog , 45 byte

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

Menghitung N = 1000sekitar 6 detik di mesin saya.

Ini 1-diindeks, misalnya

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

Penjelasan

• Predikat utama:

  :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
  

• Predikat 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
         )
  

Anda mungkin memperhatikan bahwa kami tidak memberikan input apa pun ke predikat 1 saat kami menelepon y - Yield. Karena propagasi kendala, ia akan menemukan input yang tepat setelah mencapai 1.klausa yang akan menyebarkan nilai input yang benar.

MATL, 19, 18 17 byte

1w:"tEQy3*qvSu]G)

Ini adalah algoritma yang sangat tidak efisien. Interpreter online kehabisan memori untuk input yang lebih besar dari 13.

Satu byte disimpan, terima kasih kepada Luis Mendo!

Cobalah online!

Versi ini lebih panjang, tetapi lebih efisien (21 byte)

1`tEQy3*qvSutnG3*<]G)

Cobalah online

Penjelasan:

Cara logis untuk melakukannya, adalah menambahkan elemen ke array sampai cukup lama untuk mengambil elemen ke-i. Begitulah cara kerja yang efisien. The Golfy (dan tidak efisien) cara untuk melakukannya, adalah untuk hanya meningkatkan ukuran array i kali.

Jadi pertama, kami menentukan awal array yang: 1. Kemudian kita menukar dua elemen teratas, sehingga input ada di atas. w. Sekarang, kita mengulang melalui input dengan :". Jadi saya kali:

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.

Sekarang, kita memiliki deretan raksasa urutan. (Cara lebih dari yang dibutuhkan untuk menghitung) Jadi kita berhenti mengulang ],, dan ambil nomor ke-i dari array ini dengan G)(1-diindeks)

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)

Mungkin menyerah dengan cepat karena rekursi.

Retina, 57

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

Cobalah online!

Diindeks 0. Mengikuti algoritme yang sering digunakan: hapus nilai minimum dari set saat ini, panggil x, dan tambahkan 2x+1dan 3x-1setel beberapa kali sama dengan input, maka angka yang memimpin adalah hasilnya. "Set" di Retina hanyalah daftar yang berulang kali disortir dan dibuat hanya mengandung elemen unik. Ada beberapa bit licik ditambahkan ke algoritma untuk golf, yang akan saya jelaskan setelah saya punya waktu lagi.

Terima kasih banyak untuk Martin karena bermain golf sekitar 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)))))

Saya tidak akan terkejut jika ini bisa golf / dikurangi dengan jumlah yang signifikan tetapi settidak mendukung dan benar-benar melukai pikiran saya.

Coba online

Versi dengan spasi:

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

Menggunakan pengodean CP-1252 .

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

Penjelasan

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

Cobalah online untuk jumlah kecil

Sangat lambat.
Menggunakan pengindeksan berbasis 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;};

Fungsi lambda ini membutuhkan #include <map>dan using std::map.

Di mapsini hanya kumpulan kunci; nilai-nilai mereka diabaikan. Saya menggunakan mapuntuk mendapatkan manfaat dari kode singkat untuk dimasukkan:

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

Berkat urutan terurut map, elemen terkecil diekstraksi oleh k.begin()->first.

Sebenarnya, 27 byte

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

Cobalah online!

Program ini menggunakan pengindeksan berbasis 0. Pendekatan ini sangat kasar, jadi jangan berharap itu bekerja di penerjemah online untuk input yang lebih besar.

Penjelasan:

╗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*(}%_&}*$=

Demo online . Perhatikan bahwa ini menggunakan pengindeksan berbasis nol.

Ini menggunakan pendekatan yang mirip dengan kebanyakan: menerapkan waktu transformasi ndan kemudian mengurutkan dan mengekstrak nitem th. Sebagai anggukan efisiensi, deduplikasi diterapkan di dalam loop dan penyortiran diterapkan di luar loop.

Retina , 48 byte

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

Cobalah online!

Terinspirasi oleh jawaban nimi, saya pikir saya akan mencoba pendekatan yang berbeda untuk Retina, memanfaatkan backtracking mesin regex untuk mencari tahu apakah ada nomor (tidak diperhatikan) dalam urutan atau tidak. Ternyata ini dapat ditentukan dengan regex 27 byte, tetapi memanfaatkannya biayanya lebih sedikit, tetapi masih berakhir lebih pendek daripada pendekatan generatif.

Berikut solusi 48 byte alternatif:

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

Dan menggunakan I / O unary kita bisa melakukan 42 byte, tapi saya mencoba menghindarinya dan jawaban Retina lainnya menggunakan desimal juga:

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

Penjelasan

->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*>:)^:[~]

Menggunakan pengindeksan berbasis nol. Memori sangat tidak efisien.

Penjelasan

{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

Oktaf, 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 bytes +1 untuk -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];

Tidak Disatukan:

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

Saya mungkin bisa melakukan lebih baik jika saya memikirkannya lebih lanjut, tetapi inilah yang saya hasilkan setelah beberapa menit. Pertama kali saya bermain golf, jadi ini cukup menyenangkan!

Terima kasih kepada @Dada dan @ TùxCräftîñg (dan sekelompok kecil optimasi byte) untuk -40 byte

JavaScript (ES6), 58

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

Kurang golf

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
}

Uji

Tentang waktu dan memori: elemen 500000 dalam ~ 20 detik dan 300MB yang digunakan oleh FireFox 64 bit alpha saya

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>