Untuk mengantisipasi MathJax dinonaktifkan sementara , MathJax yang diberikan dalam pertanyaan ini telah diganti dengan gambar. Anda tetap dapat memposting jawaban tetapi Anda harus melihat hasil MathJax di situs lain .

PPCG baru saja mendapat MathJax ! Ini berarti kita sekarang dapat dengan mudah memasukkan formula matematika yang diformat dengan baik ke dalam tulisan. ( Tutorial berguna MathJax. )

Sebagai contoh, di sini adalah rasio emas yang dinyatakan sebagai fraksi lanjutan tanpa batas :

Kode MathJax untuk persamaan ini adalah

$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$

^{Anda dapat menemukan ini dengan mengklik kanan rumus dan mengikuti Show Math As → TeX Commands .
The $$berarti ia ditampilkan sendiri di tengah halaman bukan inline. Gunakan satu $untuk inline.}

Tantangan

Tulis sebuah program yang menggunakan bilangan bulat non-negatif, n, dan mengeluarkan kode MathJax untuk "langkah-langkah" dari fraksi lanjutan untuk rasio emas.

Untuk menjaga hal-hal standar di jawaban, Anda harus menggunakan sintaks MathJax yang tepat ini :

• Untuk n = 0, output harus $$\varphi=1+\dots$$.
  Yang diterjemahkan sebagai:

  

• Untuk n = 1, hasilnya harus $$\varphi=1+\cfrac1{1+\ddots}$$.
  Yang diterjemahkan sebagai:

  

• Untuk n = 2, output harus $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Yang diterjemahkan sebagai:

  

• Untuk n = 3, output harus $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Yang diterjemahkan sebagai:

  

Pola ini berlanjut untuk n yang lebih besar. Anda bisa mengatakan bahwa n mewakili jumlah garis pembagian dalam persamaan.

Catatan

• \cfracdigunakan bukan yang lebih umum \frac.
• \dotsdigunakan sebagai ganti \ddotsuntuk n = 0.
• Ambil input dari stdin atau baris perintah.
• Output ke stdout (dengan baris tambahan opsional).
• Atau, Anda dapat menulis fungsi yang mengambil n sebagai integer dan mengembalikan kode MathJax sebagai string (atau masih mencetaknya).

Mencetak gol

Pengajuan terkecil dalam bytes menang. Tiebreaker pergi ke pengiriman sebelumnya.

CJam, 51 50 byte

$$\varphi=1+""\cfrac1{1+"ri:R*'\"ddots"R!>'}R*'$_

Penjelasan kode:

"$$\varphi=1+"             "This is a static string";
  "\cfrac1{1+"ri:R*'\      "Repeat this string input number times. Put a \ at the end";
    "ddots"R!>             "If input is 0, remove 1st characters, else not";
      '}R*                 "Put the closing bracket R times";
        '$_                "The final $$";

Beberapa contoh:

N = 0

$$\varphi=1+\dots$$

N = 4

$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$

N = 15

$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}}}}}}}}}}}}$$

UPDATE - 1 byte disimpan berkat Sp3000!

Cobalah online di sini

Python, 70 68 67 byte

lambda n:"$$\\varphi=1+\%sdots%s$$"%("cfrac1{1+\\"*n+"d"[:n],"}"*n)

Ini mendefinisikan fungsi anonim yang hanya menggunakan perkalian string sederhana dan pemformatan string.

(Terima kasih kepada @xnor untuk menunjukkan bahwa itu \\chanya dapat ditulis sebagai \c, karena ctidak dapat melarikan diri. Sayangnya ini tidak berlaku untuk \\v, karena \vASCII 11.)

Upaya sebelumnya:

lambda n:"$$\\varphi="+"1+\\cfrac1{"*n+"1+\\"+"ddots"[n<1:]+"}"*n+"$$"
lambda n:r"$$\varphi=%s1+\%s$$"%("1+\cfrac1{"*n,"ddots"[n<1:]+"}"*n)

> <> , 89 86 + 3 = 89 byte

:&"$$"{\l?!;o70.
}-1v!?:<{"}"
&:&\~"stod"&:&?:
{1->:?!v}"\+1{1carfc"
rav\$$"\~"\+1=ihp

Jalankan dengan -vbendera, misalnya

py -3 fish.py program.fish -v 3

Anehnya> <> tidak terlalu buruk di sini, karena kita bisa meniru perkalian string dengan memiliki penghitung yang kita kurangi setiap iterasi.

:&"$$"{\                     Put n into the register and push "$$"
}-1v!?:<{"}"                 Push n "}"s
&:&\~"stod"&:&?:             Push "stod", and copy the final "d" if n != 0
{1->:?!v}"\+1{1carfc"        Push n "\+1{1carfc"s
rav\$$"\~"\+1=ihp            Push "\+1=ihprav\$$"
       \l?!;o70.             Keep printing chars until the stack is empty

(-3 byte terima kasih kepada @randomra)

Retina , 160 + 7 = 167 byte

;`.+
$$$$\varphi=1+\dots#$0$$$$

; + (\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0) $1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10# ;#

;+`\\d?dots\d(\d*)
\cfrac1{1+\ddots$1}

Setiap baris masuk ke file sumber yang terpisah, jadi saya telah menambahkan 1 byte untuk setiap file setelah yang pertama . Namun, untuk kenyamanan, Retina sekarang juga mendukung -sflag baris perintah, yang memungkinkan Anda untuk menempatkan semua ini ke dalam satu file (dalam hal ini baris baru diperlakukan sebagai pemisah file).

Bagian terbesar dari kode (98 byte) digunakan untuk mengubah input dari desimal ke unary (file 3 hingga 6). Ide dasar kode adalah mengelilingi input $$\varphi=1+\dots...$$, kemudian mengonversi input ke unary, dan kemudian memperluas \dotsNatau \ddotsNke tingkat berikutnya dari fraksi lanjutan (sambil mengurangi Nmenjadi N-1).

Julia, 76 73 byte

n->("\$\$\\varphi=1+"*"\\cfrac1{1+"^n*"\\"*"d"^(n>0)*"dots"*"}"^n*"\$\$")

Ini menciptakan fungsi lambda yang mengambil integer tunggal sebagai input dan mengembalikan MathJax sebagai string. Untuk menyebutnya, berikan nama, mis f=n->....

Sayangnya baik garis miring terbalik dan tanda-tanda dolar harus lolos dalam string Julia karena mereka berdua memiliki makna khusus. Penggabungan string dilakukan menggunakan *dan pengulangan string dengan ^.

Contoh:

julia> f(0)
"$$\varphi=1+\dots$$"

julia> f(4)
"$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$"

Saran diterima seperti biasa!

Sunting: Disimpan 3 byte berkat plannapus!

Elemen, 63 Karakter

_+2:'\$\$\\varphi\=1\+`[\\cfrac1\{1\+`]?\\[d.]`"dots`[\}`]\$\$`

Ini adalah solusi paling mudah. Sayangnya, jumlah besar simbol dalam output menyebabkan peningkatan panjang program yang signifikan (menempatkan string dalam program secara langsung menyebabkan simbol melakukan operasi). Saya yakin ada ruang untuk bermain golf, tapi saya tidak punya waktu lagi sekarang.

Karena bahasa ini masih relatif tidak dikenal, inilah tautan ke juru bahasa , yang ditulis dalam Perl.

_+2:                     take input, add 0 to it to make it a number, and duplicate
'                        put one copy onto the control stack
\$\$\\varphi\=1\+        a "bare" string
`                        output the string
[                        start a for loop, based on the input from earlier
    \\cfrac1\{1\+        a bare string
    `                    output it
]                        end the for loop
?                        test the second copy of the input for non-zero-ness
\\                       a bare \
[d.]                     a "for" loop used as an if block, appends a "d"
`                        output it
dots`                    output dots
"                        get rid of the if condition result so the old result is on top
[                        another for loop, still using the input from earlier
    \}`                  output a }
]                        end for loop
\$\$`                    output $$

T-SQL, 229 227 138

Sudah lama sejak saya melakukan jawaban SQL dan seperti biasa sangat verbose. Sunting Tentu saja saya terlalu rumit dan tidak membutuhkan permintaan rekursif sama sekali.

CREATE FUNCTION A(@ INT)RETURNS TABLE RETURN SELECT'$$\varphi=1+\'+REPLICATE('cfrac1{1+\',@)+IIF(@>0,'d','')+'dots'+REPLICATE('}',@)+'$$'S

Asli

CREATE FUNCTION A(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT CAST('$$\varphi=1+\dots'AS VARCHAR(MAX))S,0N UNION ALL SELECT REPLACE(STUFF(S,14,0,'cfrac1{1+\'),'\do','\ddo')+'}',N+1FROM R WHERE N<=@)SELECT S+'$$'S FROM R WHERE N=@

Ini menciptakan fungsi tabel inline yang menggunakan kueri rekursif untuk memasukkan dalam cfrac1{1+\per iterasi tambahan . Mengubah titik-titik ke titik-titik itu mahal, tetapi menyelamatkan pasangan menyingkirkan ganti :). Juga harus menggunakan string asli sebagai 'VARCHAR (MAX)' sedikit biaya.

Ini digunakan sebagai berikut SQLFiddle :

SELECT * 
FROM (SELECT N FROM(VALUES(0),(1),(2),(3),(4),(5))A(N)) N
    CROSS APPLY A(N.N)
N   S
--- ---------------------------------------------------------------------------
0   $$\varphi=1+\dots$$
1   $$\varphi=1+\cfrac1{1+\ddots}$$
2   $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$
3   $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$
4   $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$
5   $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}}$$

Ruby, 76 75 71 70 byte

Ini terasa mencurigakan secara langsung, jadi tolong beri tahu saya jika saya mengacaukan suatu tempat.

Kebetulan, ini adalah hal pertama yang pernah saya tulis di Ruby - Saya mencari bahasa yang mendukung pengulangan string dengan mengalikan, dan Ruby sepertinya melakukan triknya.

f=proc{|n|'$$\varphi=1+'+'\cfrac1{1+'*n+'\dd'[0,n+2]+'ots'+'}'*n+'$$'}

Untuk diterapkan seperti:

f.call(0)
$$\varphi=1+\dots$$

f.call(3)
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$

J, 60 byte

(<;._2'$$\varphi=1+\ cfrac1{1+\ d dots } $$ ');@#~1,~5$1,],*

Pemakaian:

   ((<;._2'$$\varphi=1+\ cfrac1{1+\ d dots } $$ ');@#~1,~5$1,],*) 0
$$\varphi=1+\dots$$

   ((<;._2'$$\varphi=1+\ cfrac1{1+\ d dots } $$ ');@#~1,~5$1,],*) 3
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$

Metode:

Tali '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'dipotong di ruang-ruang dan bagian-bagiannya diulang 1 n signum(n) 1 n 1kali dan kemudian bagian-bagian ini digabungkan.

Cobalah online di sini.

R, 93 90

Sama seperti jawaban lainnya. Terima kasih kepada @plannapus untuk tip pemindaian.

cat('$$\\varphi=1+\\',rep('cfrac1{1+\\',n<-scan()),if(n)'d','dots',rep('}',n),'$$',sep='')

catdigunakan daripada paste0 karena hasilnya akan berakhir dengan \\bukannya \.

Digunakan

> > cat('$$\\varphi=1+\\',rep('cfrac1{1+\\',n<-scan()),if(n)'d','dots',rep('}',n),'$$',sep='')
1: 3
2: 
Read 1 item
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$

JavaScript, 114 109 106 85 bytes berkat George Reith

f=n=>'$$\\varphi=1+\\'+((x='cfrac1{1+\\'.repeat(n))&&x+'d')+'dots'+'}'.repeat(n)+'$$'

Ini adalah entri pertama saya dalam kontes codegolf! Tolong beritahu saya cara meningkatkan.

Entri sebelumnya (106 byte):

w="$$\\varphi=";y=n=>{return a=!n?w+"1+\\dots$$":w+"1+\\cfrac1{".repeat(n)+"1+\\ddots"+"}".repeat(n)+"$$"}

Entri sebelumnya (109 byte):

x="repeat",w="$$\\varphi=";y=n=>{return a=!n?w+"1+\\dots$$":w+"1+\\cfrac1{"[x](n)+"1+\\ddots"+"}"[x](n)+"$$"}

Entri sebelumnya (114 byte):

x="repeat";y=n=>{return a=!n?"$$\\varphi=1+\\dots$$":"$$\\varphi="+"1+\\cfrac1{"[x](n)+"1+\\ddots"+"}"[x](n)+"$$"}

Rekatkan ke konsol browser dan panggil di f(n)mana nnomor 'langkah'.

Kode sederhana :

function y(n) {
   if(n === 0) {
      return "$$\\varphi=1+\\dots$$";
   } else {
      return "$$\\varphi=" + "1+\\cfrac1{".repeat(n) + "1+\\ddots"+"}".repeat(n)+"$$";
   }

Pyth - 52 byte

Pendekatan sederhana dalam Pyth, cukup banyak dicuri dari solusi Python @ Sp3000. Menggunakan operator pemformatan string %.

%"$$\\varphi=1+\%sdots%s$$"(+*"cfrac1{1+\\"Q<\dQ*\}Q

Cobalah online di sini .

%                  String formatting
 "$$ . . . $$"     String to be formatted
 (                 Tuple (no need to close it)
  +                String concatenation
   *"..."Q         String repetition input times
   <\dQ            If Q>0 then d
  *                String repetition
   \}              The character "}"
   Q               Q times

Pyth, 50 byte

s["$$\\varphi=1+"*Q"\cfrac1{1+"\\<\dQ"dots"*Q\}"$$

JavaScript (ES6), 76 80

Sebagian bersifat rekursif. Single / double d adalah bagian yang paling menjengkelkan.

F=n=>"$$\\varphi=1+\\"+(R=d=>n--?"cfrac1{1+\\"+R("d")+"}":d+"dots")("")+"$$"

Uji di Firefox / konsol FireBug

> for(i=0;i<5;i++)console.log(F(i))

$$\varphi=1+\dots$$
$$\varphi=1+\cfrac1{1+\ddots}$$
$$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$
$$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}}$$

Python, 90 116

karena solusi paling efisien telah diposting beberapa kali, saya menggunakan pengganti string

f=lambda n:'$$\\varphi=1+\ddots$$'if n==0 else f(n-1).replace('\ddots','\cfrac{1+\ddots}')
# or, with exactly the same length
x='\ddots';f=lambda n:'$$\\varphi=1+'x+'$$'if n==0 else f(n-1).replace(x,'\cfrac{1+'x+'}')

Sunting: sialan, mengabaikan dotsalih - alih ddotsuntuk n=0, sekarang solusi rekursif dengan klausa tambahan ditempelkan terlalu jelek untuk bersaing.

x='$$\\varphi=1+\d%sots$$';f=lambda n:x%''if n==0 else x%'d'if n==1 else f(n-1).replace('\ddots','\cfrac{1+\ddots}')

Haskell, 86

n%x=[1..n]>>x
f n="$$\\varphi=1+"++n%"\\cfrac1{1+"++'\\':drop(0^n)"ddots"++n%"}"++"$$"

Pada dasarnya pendekatan yang sama dengan semua solusi di sini. drop(0^n)"ddots"itu lucu!