W oczekiwaniu na tymczasowe wyłączenie MathJax, renderowany MathJax w tym pytaniu został zastąpiony obrazami. Nadal możesz publikować odpowiedzi, ale musisz wyświetlić renderowany MathJax na innej stronie .

PPCG właśnie dostało MathJax ! Oznacza to, że możemy teraz łatwo włączać dobrze sformatowane formuły matematyczne do postów. ( Poręczny samouczek MathJax. )

Na przykład tutaj jest złoty stosunek wyrażony jako nieskończona ciągła część :

Kod MathJax dla tego równania to

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

^{Można to znaleźć, klikając prawym przyciskiem myszy formułę i postępując zgodnie z poleceniami Pokaż matematykę jako → TeX .
Te $$środki to jest wyświetlane na własną rękę w środku strony zamiast inline. Użyj singla $do wstawiania.}

Wyzwanie

Napisz program, który przyjmuje nieujemną liczbę całkowitą n i wyprowadza kod MathJax dla tylu „kroków” ciągłego ułamka dla złotego podziału.

Aby zachować standard dla wszystkich odpowiedzi, musisz użyć tej dokładnej składni MathJax:

• Dla n = 0 wynikiem musi być $$\varphi=1+\dots$$.
  Który jest renderowany jako:

  

• Dla n = 1 wynikiem musi być $$\varphi=1+\cfrac1{1+\ddots}$$.
  Który jest renderowany jako:

  

• Dla n = 2 wyjściem musi być $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Który jest renderowany jako:

  

• Dla n = 3 wyjściem musi być $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Który jest renderowany jako:

  

Ten wzór trwa dla większej liczby n. Można powiedzieć, że n reprezentuje liczbę linii podziału w równaniu.

Notatki

• \cfracjest używany zamiast bardziej powszechnego \frac.
• \dotsjest używany zamiast \ddotsdla n = 0.
• Weź dane wejściowe ze standardowego wejścia lub wiersza poleceń.
• Wyjście na standardowe wyjście (z opcjonalnym końcowym znakiem nowej linii).
• Alternatywnie możesz napisać funkcję, która przyjmuje n jako liczbę całkowitą i zwraca kod MathJax jako ciąg znaków (lub nadal go drukuje).

Punktacja

Najmniejsze przesłanie w bajtach wygrywa. Tiebreaker przechodzi do wcześniejszego zgłoszenia.

CJam, 51 50 bajtów

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

Objaśnienie kodu:

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

Kilka przykładów:

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

AKTUALIZACJA - 1 bajt zapisany dzięki Sp3000!

Wypróbuj online tutaj

Python, 70 68 67 bajtów

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

Definiuje to anonimową funkcję, która po prostu wykorzystuje proste mnożenie i formatowanie łańcucha.

(Dzięki @xnor za wskazanie, że \\cmożna to po prostu zapisać jako \c, ponieważ cnie można go uniknąć. Niestety nie jest to prawdą \\v, ponieważ \vjest to ASCII 11.)

Poprzednie próby:

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 bajtów

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

Uruchom z -vflagą, np

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

Zaskakujące jest to, że> <> nie robi się tutaj zbyt źle, ponieważ możemy naśladować mnożenie ciągów, mając licznik, który zmniejszamy przy każdej iteracji.

:&"$$"{\                     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 bajty dzięki @randomra)

Siatkówka , 160 + 7 = 167 bajtów

;`.+
$$$$\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}

Każda linia przechodzi do osobnego pliku źródłowego, więc dodałem 1 bajt do każdego pliku po pierwszym . Jednak dla wygody Retina obsługuje teraz także -sflagę wiersza poleceń, która pozwala umieścić to wszystko w jednym pliku (w takim przypadku znaki nowej linii są traktowane jako separatory plików).

Największa część kodu (98 bajtów) służy do konwersji danych wejściowych z dziesiętnego na jednoargumentowy (pliki od 3 do 6). Podstawową ideą kodu jest otaczanie danych wejściowych $$\varphi=1+\dots...$$, następnie przekształcanie danych wejściowych na jednoargumentowe, a następnie rozwijanie \dotsNlub \ddotsNprzechodzenie do następnego poziomu ciągłego ułamka (redukując Ndo N-1).

Julia, 76 73 bajtów

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

To tworzy funkcję lambda, która przyjmuje jedną liczbę całkowitą jako dane wejściowe i zwraca MathJax jako ciąg znaków. Aby to nazwać, nadaj mu nazwę, np f=n->....

Niestety, zarówno odwrotne ukośniki, jak i znaki dolara muszą zostać usunięte w ciągach Julii, ponieważ oba mają specjalne znaczenie. Łączenie łańcuchów odbywa się za pomocą *i powtarzania łańcuchów za pomocą ^.

Przykłady:

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

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

Sugestie są jak zawsze mile widziane!

Edycja: Zapisano 3 bajty dzięki plannapus!

Element, 63 znaki

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

To najprostsze rozwiązanie. Niestety duża liczba symboli na wyjściu powoduje znaczny wzrost długości programu (umieszczenie ciągów w programie bezpośrednio powoduje, że symbole wykonują operacje). Jestem pewien, że jest miejsce na grę w golfa, ale nie mam teraz więcej czasu.

Ponieważ ten język jest nadal stosunkowo nieznany, oto link do tłumacza napisanego w Perlu.

_+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

Minęło trochę czasu, odkąd zrobiłem odpowiedź SQL i jak zawsze jest to bardzo szczegółowe. Edytuj Oczywiście skomplikowałem to i nie potrzebowałem w ogóle zapytania rekurencyjnego.

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

Oryginalny

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

Spowoduje to utworzenie wbudowanej funkcji tabeli, która korzysta z zapytania rekurencyjnego w celu umieszczenia dodatkowej dla cfrac1{1+\każdej iteracji. Zmiana kropek na kropki była kosztowna, ale uratowała parę pozbywających się zamiany :). Trzeba też rzucić oryginalny ciąg jako „VARCHAR (MAX)”.

Jest używany w następujący sposób 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}}}}}$$

Rubinowy, 76 75 71 70 bajtów

Wydaje się to podejrzanie proste, więc proszę dać mi znać, jeśli gdzieś coś pomieszałem.

Nawiasem mówiąc, jest to pierwsza rzecz, jaką kiedykolwiek napisałem w Ruby - szukałem języka, który wspiera powtarzanie ciągów przez mnożenie, a Ruby chyba to zrobiła.

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

Do zastosowania w ten sposób:

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

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

J, 60 bajtów

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

Stosowanie:

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

Metoda:

Sznurek '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'jest cięty w odstępach, a części są powtarzane 1 n signum(n) 1 n 1razy, a następnie te części są łączone.

Wypróbuj online tutaj.

R, 93 90

Podobnie jak inne odpowiedzi. Dzięki @plannapus za wskazówkę dotyczącą skanowania.

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

catużyte zamiast wklej0, ponieważ wynik byłby \\raczej wynikiem niż \.

W użyciu

> > 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 bajtów dzięki George'owi Reithowi

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

To mój pierwszy wpis w konkursie codegolf! Powiedz mi, jak poprawić.

Poprzedni wpis (106 bajtów):

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

Poprzedni wpis (109 bajtów):

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

Poprzedni wpis (114 bajtów):

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

Wklej do konsoli przeglądarki i zadzwoń, f(n)gdzie njest liczba „kroków”.

Kod uproszczony :

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

Pyth - 52 bajty

Proste podejście w Pyth, prawie skradzione z rozwiązania Python @ Sp3000. Używa operatora formatowania łańcucha %.

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

Wypróbuj online tutaj .

%                  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 bajtów

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

JavaScript (ES6), 76 80

Częściowo rekurencyjne. Single / double d jest najbardziej denerwującą częścią.

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

Przetestuj w konsoli 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}}}}$$

Python, 90 116

ponieważ najskuteczniejsze rozwiązanie zostało już opublikowane wiele razy, zamiast tego wybieram zamianę łańcucha

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

Edit: cholera, darowany dotszamiast ddotsza n=0, teraz rekurencyjne rozwiązanie z dodatkową klauzulą zaatakowana na to zbyt brzydki konkurować.

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

Zasadniczo takie samo podejście jak wszystkie rozwiązania tutaj. drop(0^n)"ddots"jest jednak słodki!