Dự đoán MathJax tạm thời bị vô hiệu hóa , MathJax được hiển thị trong câu hỏi này đã được thay thế bằng hình ảnh. Bạn vẫn được hoan nghênh đăng câu trả lời nhưng bạn sẽ phải xem MathJax được hiển thị trên một trang web khác .

PPCG vừa có MathJax ! Điều này có nghĩa là bây giờ chúng ta có thể dễ dàng bao gồm các công thức toán học được định dạng tốt vào bài viết. ( Hướng dẫn tiện dụng MathJax. )

Ví dụ, đây là tỷ lệ vàng được biểu thị dưới dạng phân số tiếp tục vô hạn :

Mã MathJax cho phương trình này là

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

^{Bạn có thể tìm thấy điều này bằng cách nhấp chuột phải vào công thức và làm theo Show Math As → Lệnh TeX .
Có $$nghĩa là nó được hiển thị riêng ở giữa trang thay vì nội tuyến. Sử dụng một đơn $cho nội tuyến.}

Thử thách

Viết chương trình lấy số nguyên không âm, n và xuất mã MathJax cho nhiều "bước" của phân số tiếp tục cho tỷ lệ vàng.

Để giữ mọi thứ chuẩn trên các câu trả lời, bạn phải sử dụng cú pháp MathJax chính xác này :

• Với n = 0, đầu ra phải là $$\varphi=1+\dots$$.
  Được hiển thị là:

  

• Với n = 1, đầu ra phải là $$\varphi=1+\cfrac1{1+\ddots}$$.
  Được hiển thị là:

  

• Với n = 2, đầu ra phải là $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Được hiển thị là:

  

• Với n = 3, đầu ra phải là $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Được hiển thị là:

  

Mô hình này tiếp tục cho n lớn hơn. Bạn có thể nói rằng n đại diện cho số lượng các đường phân chia trong phương trình.

Ghi chú

• \cfracđược sử dụng thay vì phổ biến hơn \frac.
• \dotsđược sử dụng thay vì \ddotscho n = 0.
• Lấy đầu vào từ stdin hoặc dòng lệnh.
• Xuất ra thiết bị xuất chuẩn (với một dòng mới tùy chọn).
• Ngoài ra, bạn có thể viết một hàm lấy n là số nguyên và trả về mã MathJax dưới dạng chuỗi (hoặc vẫn in nó).

Chấm điểm

Đệ trình nhỏ nhất tính bằng byte thắng. Tiebreaker đi đến trình trước đó.

CJam, 51 50 byte

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

Mã giải thích:

"$$\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 $$";

Một vài ví dụ:

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

CẬP NHẬT - Lưu 1 byte nhờ Sp3000!

Dùng thử trực tuyến tại đây

Python, 70 68 67 byte

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

Điều này xác định một hàm ẩn danh chỉ sử dụng phép nhân chuỗi đơn giản và định dạng chuỗi.

(Cảm ơn @xnor đã chỉ ra rằng \\ccó thể được viết là \c, vì ckhông thể thoát được. Thật không may, điều này không đúng với \\v, vì \vlà ASCII 11.)

Những nỗ lực trước đây:

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

Chạy với -vcờ, vd

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

Đáng ngạc nhiên> <> không làm quá tệ ở đây, vì chúng ta có thể bắt chước phép nhân chuỗi bằng cách có một bộ đếm mà chúng ta giảm dần mỗi lần lặp.

:&"$$"{\                     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 nhờ @randomra)

Võng mạc , 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}

Mỗi dòng đi vào một tệp nguồn riêng biệt, vì vậy tôi đã thêm 1 byte cho mỗi tệp sau lần đầu tiên . Tuy nhiên, để thuận tiện, Retina hiện cũng hỗ trợ -scờ dòng lệnh, cho phép bạn đặt tất cả những thứ này vào một tệp duy nhất (trong trường hợp đó các dòng mới được coi là dấu tách tệp).

Phần lớn nhất của mã (98 byte) được sử dụng để chuyển đổi đầu vào từ thập phân sang đơn nguyên (tệp 3 đến 6). Ý tưởng cơ bản của mã là bao quanh đầu vào $$\varphi=1+\dots...$$, sau đó chuyển đổi đầu vào thành unary, sau đó mở rộng \dotsNhoặc \ddotsNsang cấp tiếp theo của phân số tiếp tục (trong khi giảm Nxuống N-1).

Julia, 76 73 byte

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

Điều này tạo ra một hàm lambda lấy một số nguyên duy nhất làm đầu vào và trả về MathJax dưới dạng chuỗi. Để gọi nó, đặt tên cho nó, vd f=n->....

Thật không may, cả dấu gạch chéo ngược và ký hiệu đô la phải được thoát trong chuỗi Julia vì cả hai đều có ý nghĩa đặc biệt. Nối chuỗi được thực hiện bằng cách sử dụng *và lặp lại chuỗi với ^.

Ví dụ:

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

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

Đề nghị được chào đón như mọi khi!

Chỉnh sửa: Đã lưu 3 byte nhờ vào plannapus!

Yếu tố, 63 ký tự

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

Đây là giải pháp đơn giản nhất. Thật không may, số lượng lớn các ký hiệu trong đầu ra gây ra sự gia tăng đáng kể về độ dài chương trình (đưa các chuỗi vào chương trình trực tiếp khiến các ký hiệu thực hiện các thao tác). Tôi chắc chắn có chỗ để chơi gôn, nhưng hiện tại tôi không có nhiều thời gian hơn.

Vì ngôn ngữ này vẫn chưa được biết đến, nên đây là một liên kết đến trình thông dịch , được viết bằng 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

Đã được một thời gian kể từ khi tôi trả lời SQL và như mọi khi nó rất dài dòng. Chỉnh sửa Tất nhiên tôi quá phức tạp và không cần một truy vấn đệ quy nào cả.

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

Nguyên

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=@

Điều này tạo ra một hàm bảng nội tuyến sử dụng truy vấn đệ quy để thêm vào cfrac1{1+\mỗi lần lặp bổ sung . Thay đổi dấu chấm thành ddots rất tốn kém, nhưng đã cứu được một vài người thoát khỏi sự thay thế :). Ngoài ra, phải truyền chuỗi gốc là 'VARCHAR (MAX)' tốn một chút.

Nó được sử dụng như sau 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

Điều này cảm thấy nghi ngờ đơn giản, vì vậy xin vui lòng cho tôi biết nếu tôi nhắn tin ở đâu đó.

Ngẫu nhiên, đây là điều đầu tiên tôi từng viết bằng Ruby - Tôi đang tìm kiếm một ngôn ngữ hỗ trợ sự lặp lại chuỗi bằng cách nhân lên, và Ruby dường như thực hiện thủ thuật.

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

Để được áp dụng như vậy:

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,],*

Sử dụng:

   ((<;._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}}}$$

Phương pháp:

Chuỗi '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'được cắt ra tại các khoảng trắng và các phần được lặp lại nhiều 1 n signum(n) 1 n 1lần và sau đó các phần này được nối với nhau.

Hãy thử trực tuyến tại đây.

R, 93 90

Giống như các câu trả lời khác. Cảm ơn @plannapus cho mẹo quét.

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

catđược sử dụng thay vì paste0 vì kết quả cuối cùng sẽ \\thay vì \.

Đang sử dụng

> > 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 byte nhờ George Reith

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

Đây là mục đầu tiên của tôi trong một cuộc thi codegolf! Xin vui lòng cho tôi biết làm thế nào để cải thiện.

Mục trước (106 byte):

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

Mục trước (109 byte):

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

Mục trước (114 byte):

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

Dán vào giao diện điều khiển trình duyệt và gọi như f(n)nơi nlà số 'bước'.

Mã đơn giản :

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

Pyth - 52 byte

Cách tiếp cận đơn giản trong Pyth, bị đánh cắp khá nhiều từ giải pháp Python của @ Sp3000. Sử dụng toán tử định dạng chuỗi %.

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

Hãy thử trực tuyến tại đây .

%                  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

Bình thường, 50 byte

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

JavaScript (ES6), 76 80

Một phần đệ quy. Phần đơn / đôi d là phần khó chịu nhất.

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

Kiểm tra trong bảng điều khiển Firefox / 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}}}}$$

Con trăn, 90 116

vì giải pháp hiệu quả nhất đã được đăng nhiều lần, thay vào đó tôi đi thay thế chuỗi

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+'}')

Chỉnh sửa: chết tiệt, bỏ qua dotsthay vì ddotscho n=0, bây giờ giải pháp đệ quy với một điều khoản bổ sung được giải quyết là quá xấu để cạnh tranh.

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%"}"++"$$"

Về cơ bản cách tiếp cận giống như tất cả các giải pháp ở đây. drop(0^n)"ddots"là dễ thương, mặc dù!