Urutan Sylvester, OEIS A000058 , adalah urutan bilangan bulat yang didefinisikan sebagai berikut:

Setiap anggota adalah produk dari semua anggota sebelumnya ditambah satu. Anggota urutan pertama adalah 2.

Tugas

Buat program sekecil mungkin yang membutuhkan n dan hitung jangka waktu n dari Sylvester's Sequence. Input standar, output dan celah berlaku. Karena hasilnya tumbuh sangat cepat, Anda tidak diharapkan untuk mengambil istilah yang hasilnya akan menyebabkan meluapnya bahasa yang Anda pilih.

Uji Kasus

Anda dapat menggunakan nol atau satu pengindeksan. (Di sini saya menggunakan nol pengindeksan)

>>0
2
>>1
3
>>2
7
>>3
43
>>4
1807

Brain-Flak , 76 68 58 52 46 byte

<>(()())<>{({}[()])<>({({}[()])({})}{}())<>}<>

Cobalah online!

Gunakan hubungan ini sebagai gantinya:

yang berasal dari hubungan ini dimodifikasi dari yang disediakan dalam urutan:

a(n+1) = a(n) * (a(n) - 1) + 1.

Penjelasan

Untuk dokumentasi tentang apa yang dilakukan setiap perintah, silakan kunjungi halaman GitHub .

Ada dua tumpukan di Brain-Flak, yang akan saya beri nama Stack 1 dan Stack 2.

Input disimpan di Stack 1.

<>(()())<>             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 <- Stack_1 - 1;
  <>                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  <>                       Switch back to Stack 1.
}

<>                     Switch to Stack 2, implicitly print.

Untuk algoritme pembangkitan:

({({}[()])({})}{}())      Top <- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).

Alternatif versi 46-byte

Ini hanya menggunakan satu tumpukan.

({}<(()())>){({}<({({}[()])({})}{}())>[()])}{}

Cobalah online!

Jelly , 5 byte

Ḷ߀P‘

Ini menggunakan pengindeksan berbasis 0 dan definisi dari spec tantangan.

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

Ḷ߀P‘  Main link. Argument: n

Ḷ      Unlength; yield [0, ..., n - 1].
 ߀    Recursively apply the main link to each integer in that range.
   P   Take the product. This yields 1 for an empty range.
    ‘  Increment.

Hexagony , 27 byte

1{?)=}&~".>")!@(</=+={"/>}*

Dibuka:

    1 { ? )
   = } & ~ "
  . > " ) ! @
 ( < / = + = {
  " / > } * .
   . . . . .
    . . . .

Cobalah online!

Penjelasan

Mari kita perhatikan urutannya b(a) = a(n) - 1dan lakukan sedikit pengaturan ulang:

b(a) = a(n) - 1
     = a(n-1)*(a(n-1)-1) + 1 - 1
     = (b(n-1) + 1)*(b(n-1) + 1 - 1)
     = (b(n-1) + 1)*b(n-1)
     = b(n-1)^2 + b(n-1)

Urutan ini sangat mirip tetapi kita bisa menunda kenaikan sampai akhir, yang terjadi untuk menyimpan byte dalam program ini.

Jadi di sini adalah kode sumber beranotasi:

^{Dibuat dengan HexagonyColorer Timwi .}

Dan di sini adalah diagram memori (segitiga merah menunjukkan posisi awal dan orientasi pointer memori):

^{Dibuat dengan EsotericIDE Timwi .}

Kode dimulai pada jalur abu-abu yang membungkus sudut kiri, jadi bit linear awal adalah sebagai berikut:

1{?)(
1      Set edge b(1) to 1.
 {     Move MP to edge N.
  ?    Read input into edge N.
   )(  Increment, decrement (no-op).

Kemudian kode mengenai <yang merupakan cabang dan menunjukkan awal (dan akhir) dari loop utama. Selama tepi N memiliki nilai positif, jalur hijau akan dieksekusi. Jalan itu membungkus grid beberapa kali, tetapi sebenarnya seluruhnya linier:

""~&}=.*}=+={....(

The .tidak-ops, sehingga kode yang sebenarnya adalah:

""~&}=*}=+={(
""             Move the MP to edge "copy".
  ~            Negate. This is to ensure that the value is negative so that &...
   &           ...copies the left-hand neighbour, i.e. b(i).
    }=         Move the MP to edge b(i)^2 and turn it around.
      *        Multiply the two copies of b(i) to compute b(i)^2.
       }=      Move the MP back to edge b(i) and turn it around.
         +     Add the values in edges "copy" and b(i)^2 to compute
               b(i) + b(i)^2 = b(i+1).
          ={   Turn the memory pointer around and move to edge N.
            (  Decrement.

Setelah pengurangan ini berkurang Nmenjadi 0, jalur merah dijalankan:

")!@
"     Move MP back to edge b(i) (which now holds b(N)).
 )    Increment to get a(N).
  !   Print as integer.
   @  Terminate the program.

J, 18 14 12 byte

Versi ini berkat randomra. Saya akan mencoba menulis penjelasan terperinci nanti.

0&(]*:-<:)2:

J, 14 byte

Versi ini berkat mil. Gunakan adverbia ^:alih-alih agenda seperti di bawah ini. Penjelasan lebih lanjut akan datang.

2(]*:-<:)^:[~]

J, 18 byte

2:`(1+*/@$:@i.)@.*

Diindeks 0.

Contohnya

   e =: 2:`(1+*/@$:@i.)@.*
   e 1
3
   e 2
7
   e 3
43
   e 4
1807
   x: e i. 10
2 3 7 43 1807 3263443 10650056950807 113423713055421862298779648 12864938683278674737956996400574416174101565840293888 1655066473245199944217466828172807675196959605278049661438916426914992848    91480678309535880456026315554816
   |: ,: x: e i. 10
                                                                                                        2
                                                                                                        3
                                                                                                        7
                                                                                                       43
                                                                                                     1807
                                                                                                  3263443
                                                                                           10650056950807
                                                                              113423713055421862298779648
                                                    12864938683278674737956996400574416174101565840293888
165506647324519994421746682817280767519695960527804966143891642691499284891480678309535880456026315554816

Penjelasan

Ini adalah agenda yang terlihat seperti ini:

           ┌─ 2:
           │    ┌─ 1
       ┌───┤    ├─ +
       │   └────┤           ┌─ / ─── *
── @. ─┤        │     ┌─ @ ─┴─ $:
       │        └─ @ ─┴─ i.
       └─ *

(Dihasilkan menggunakan (9!:7)'┌┬┐├┼┤└┴┘│─'kemudian 5!:4<'e')

Membusuk:

       ┌─ ...
       │
── @. ─┤
       │
       └─ *

Menggunakan cabang atas sebagai gerund G, dan bagian bawah sebagai pemilih F, ini adalah:

e n     <=>     ((F n) { G) n

Ini menggunakan fungsi konstan 2:ketika 0 = * n, yaitu, ketika tanda nol (dengan demikian nadalah nol). Jika tidak, kami menggunakan garpu ini:

  ┌─ 1
  ├─ +
──┤           ┌─ / ─── *
  │     ┌─ @ ─┴─ $:
  └─ @ ─┴─ i.

Yang satu ditambah seri di atas berikut:

            ┌─ / ─── *
      ┌─ @ ─┴─ $:
── @ ─┴─ i.

Menguraikan lebih jauh, ini adalah produk ( */) lebih dari referensi-sendiri ( $:) lebih dari rentang ( i.).

Perl 6 , 24 byte

{(2,{1+[*] @_}...*)[$_]}

{(2,{1+.²-$_}...*)[$_]}

Penjelasan

# bare block with implicit parameter ｢$_｣
{
  (
    # You can replace 2 with 1 here
    # so that it uses 1 based indexing
    # rather than 0 based
    2,

    # bare block with implicit parameter ｢@_｣
    {
      1 +

      # reduce the input of this inner block with ｢&infix:<*>｣
      # ( the input is all of them generated when using a slurpy @ var )
      [*] @_

      # that is the same as:
      # ｢@_.reduce: &infix:<*>｣
    }

    # keep calling that to generate more values until:
    ...

    # forever
    *

  # get the value as indexed by the input
  )[ $_ ]
}

Pemakaian:

my &code = {(2,{1+[*] @_}...*)[$_]}

say code 0; # 2
say code 1; # 3
say code 2; # 7
say code 3; # 43
say code 4; # 1807

# you can even give it a range
say code 4..7;
# (1807 3263443 10650056950807 113423713055421844361000443)

say code 8;
# 12864938683278671740537145998360961546653259485195807
say code 9;
# 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
say code 10;
# 27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807

my $start = now;
# how many digits are there in the 20th value
say chars code 20;
# 213441

my $finish = now;
# how long did it take to generate the values up to 20
say $finish - $start, ' seconds';
# 49.7069076 seconds

Haskell, 26 byte

f n|n<1=2|m<-f$n-1=1+m*m-m

Contoh penggunaan: f 4-> 1807.

Java 7, 46 42 byte

int f(int n){return--n<0?2:f(n)*~-f(n)+1;}

Menggunakan pengindeksan 0 dengan rumus biasa. Aku bertukar n*n-nuntuk n*(n-1)meskipun, karena Java tidak memiliki operator listrik berguna, dan f()panggilan mendapatkan panjang.

Haskell, 25 byte

(iterate(\m->m*m-m+1)2!!)

SILOS , 60 byte

readIO 
p = 2
lblL
r = p
r + 1
p * r
i - 1
if i L
printInt r

Cobalah online!

Pelabuhan jawaban saya di C .

Brain-Flak , 158 154 byte

Leaky Nun membuatku mengalahkan di sini

({}<(()())>){({}[()]<<>(())<>([]){{}<>({}<<>(({}<>))><>)<>({<({}[()])><>({})<>}{})<>{}([])}{}<>({}())([]){{}({}<>)<>([])}{}<>>)}{}([][()]){{}{}([][()])}{} 

Cobalah secara Online!

Penjelasan

Letakkan dua di bawah input a (0)

({}<(()())>) 

Sementara input lebih besar dari nol kurangi satu dari input dan ...

{
({}[()]

Diam-diam ...

<

Letakkan satu di tumpukan lain untuk bertindak sebagai katalis untuk perkalian <> (()) <>

Sementara tumpukan tidak kosong

 ([])
 {
  {}

Pindahkan bagian atas daftar dan salin

  <>({}<<>(({}<>))><>)

Lipat gandakan katalis dengan salinannya

  <>({<({}[()])><>({})<>}{})<>{}
  ([])
 }
 {}

Tambahkan satu

 <>({}())

Pindahkan urutan kembali ke tumpukan yang tepat

 ([])
 {
 {}
 ({}<>)<>
 ([])
 }
 {}
 <>
>)
}{}

Hapus semua kecuali item bawah (yaitu nomor terakhir yang dibuat)

([][()])
{
{}
{}
([][()])
}
{}

C, 32 byte

f(n){return--n?f(n)*~-f(n)+1:2;}

Menggunakan pengindeksan berbasis 1. Uji di Ideone .

Sebenarnya , 9 byte

2@`rΣτu`n

Cobalah online!

Gunakan hubungan ini sebagai gantinya:

yang berasal dari hubungan ini dimodifikasi dari yang disediakan dalam urutan:

a(n+1) = a(n) * (a(n) - 1) + 1.

R, 44 42 41 byte

2 byte menghemat berkat JDL

Hemat 1 byte berkat pengguna5957401

f=function(n)ifelse(n,(a=f(n-1))^2-a+1,2)

Oasis , 4 byte (tidak bersaing)

Mungkin bahasa terakhir saya dari keluarga golf! Non-bersaing, karena bahasa tersebut mengungguli tantangan.

Kode:

²->2

Solusi alternatif berkat Zwei :

<*>2

Versi yang diperluas:

a(n) = ²->
a(0) = 2

Penjelasan:

²    # Stack is empty, so calculate a(n - 1) ** 2.
 -   # Subtract, arity 2, so use a(n - 1).
  >  # Increment by 1.

Menggunakan pengkodean CP-1252 . Cobalah online!

Python, 38 36 byte

2 byte berkat Dennis.

f=lambda n:0**n*2or~-f(n-1)*f(n-1)+1

Ide itu!

Menggunakan hubungan ini yang diubah dari yang disediakan dalam urutan sebagai gantinya:

a(n+1) = a(n) * (a(n) - 1) + 1

Penjelasan

0**n*2mengembalikan 2kapan n=0dan 0sebaliknya, karena 0**0didefinisikan berada 1dalam Python.

Cheddar , 26 byte

n g->n?g(n-=1)**2-g(n)+1:2

Cobalah online!

Idiomatik.

Penjelasan

n g ->    // Input n, g is this function
  n ?     // if n is > 1
    g(n-=1)**2-g(n)+1   // Do equation specified in OEIS
  : 2     // if n == 0 return 2

CJam, 10 byte

2{_(*)}ri*

Menggunakan pengindeksan berbasis 0. Cobalah online!

05AB1E , 7 byte

2sFD<*>

Dijelaskan

Menggunakan pengindeksan berbasis nol.

2         # push 2 (initialization for n=0)
 sF       # input nr of times do
   D<*    # x(x-1)
      >   # add 1

Cobalah online!

Prolog, 49 byte

a(0,2).
a(N,R):-N>0,M is N-1,a(M,T),R is T*T-T+1.

SILOS 201 byte

readIO 
def : lbl
set 128 2
set 129 3
j = i
if j z
print 2
GOTO e
:z
j - 1
if j Z
print 3
GOTO e
:Z
i - 1
:a
a = 127
b = 1
c = 1
:b
b * c
a + 1
c = get a
if c b
b + 1
set a b
i - 1
if i a
printInt b
:e

Jangan ragu untuk mencobanya secara online!

Jelly , 7 byte

²_’
2Ç¡

Cobalah online!

Menggunakan hubungan ini yang disediakan dalam urutan sebagai gantinya: a(n+1) = a(n)^2 - a(n) + 1

Penjelasan

2Ç¡   Main chain, argument in input

2     Start with 2
  ¡   Repeat as many times as the input:
 Ç        the helper link.


²_’   Helper link, argument: z
²     z²
  ’   z - 1
 _    subtraction, yielding z² - (z-1) = z² - z + 1

C, 46 byte

s(n,p,r){for(p=r=2;n-->0;p*=r)r=p+1;return r;}

Ide itu!

Penggunaan p sebagai penyimpanan sementara produk.

Pada dasarnya, saya mendefinisikan dua urutan p(n)dan r(n), di mana r(n)=p(n-1)+1danp(n)=p(n-1)*r(n) .

r(n) adalah urutan yang diperlukan.

R, 50 46 44 byte

    n=scan();v=2;if(n)for(i in 1:n){v=v^2-v+1};v

Daripada melacak seluruh urutan, kami hanya melacak produk, yang mengikuti aturan pembaruan kuadratik yang diberikan selama n> 1 n> 0. (Urutan ini menggunakan "mulai dari satu konvensi nol")

Menggunakan start at zero convention menghemat beberapa byte karena kita dapat menggunakan if (n) daripada if (n> 1)

Ubur-ubur , 13 byte

p
\Ai
&(*
><2

Cobalah online!

Penjelasan

Mari kita mulai dari bawah ke atas:

(*
<

Ini adalah pengait, yang mendefinisikan fungsi f(x) = (x-1)*x.

&(*
><

Ini menyusun kait sebelumnya dengan fungsi kenaikan sehingga memberi kita fungsi g(x) = (x-1)*x+1.

\Ai
&(*
><

Akhirnya, ini menghasilkan fungsi hyang merupakan iterasi dari fungsi sebelumnya g, sebanyak yang diberikan oleh input integer.

\Ai
&(*
><2

Dan akhirnya, kami menerapkan iterasi ini ke nilai awal 2. Itup di atas hanya mencetak hasilnya.

Alternatif (juga 13 byte)

p
>
\Ai
(*
>1

Ini mempertahankan kenaikan sampai akhir.

C, 43 , 34 , 33 byte

1-diindeks:

F(n){return--n?n=F(n),n*n-n+1:2;}

Tes utama:

int main() {
  printf("%d\n", F(1));
  printf("%d\n", F(2));
  printf("%d\n", F(3));
  printf("%d\n", F(4));
  printf("%d\n", F(5));
}

Brachylog , 13 byte

0,2|-:0&-y+*+

Cobalah online!

Gunakan hubungan ini sebagai gantinya:

yang berasal dari hubungan ini dimodifikasi dari yang disediakan dalam urutan:

a(n+1) = a(n) * (a(n) - 1) + 1.

Mathematica, 19 byte

Nest[#^2-#+1&,2,#]&

Atau 21 byte:

Array[#0,#,0,1+1##&]&

Labirin , 18 byte

Kredit untuk Sp3000 yang menemukan solusi yang sama secara mandiri.

?
#
)}"{!@
* (
(:{

Cobalah online!

Sebenarnya , 14 12 byte

Ini digunakan pengindeksan 0. Saran golf diterima. Cobalah online!

2#,`;πu@o`nF

Tidak melakukan pelanggaran:

2#              Start with [2]
  ,`     `n     Take 0-indexed input and run function (input) times
    ;           Duplicate list
     πu         Take product of list and increment
       @o       Swap and append result to the beginning of the list
           F    Return the first item of the resulting list

GolfScript , 12 10 byte

2 byte berkat Dennis.

~2\{.(*)}*

Cobalah online!

Penggunaan a(n) = a(n-1) * (a(n-1)-1) + 1.