In Erwartung der vorübergehenden Deaktivierung von MathJax wurde das in dieser Frage gerenderte MathJax durch Bilder ersetzt. Sie können weiterhin gerne Antworten posten, müssen das gerenderte MathJax jedoch auf einer anderen Site anzeigen .

PPCG hat gerade MathJax bekommen ! Dies bedeutet, dass wir nun problemlos gut formatierte mathematische Formeln in Posts einfügen können. ( Praktisches MathJax-Tutorial. )

Zum Beispiel ist hier der goldene Schnitt, ausgedrückt als unendlicher fortgesetzter Bruch :

Der MathJax-Code für diese Gleichung lautet

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

^{Sie finden dies, indem Sie mit der rechten Maustaste auf die Formel klicken und Show Math As → TeX Commands ausführen .
Das $$bedeutet, dass es allein in der Mitte der Seite anstatt inline angezeigt wird. Verwenden Sie eine Single $für Inline.}

Herausforderung

Schreiben Sie ein Programm, das eine nicht negative Ganzzahl n enthält und den MathJax-Code für die vielen "Schritte" des fortgesetzten Bruchs für den goldenen Schnitt ausgibt.

Um die Dinge Standard über Antworten, müssen Sie diese verwenden , genaue Mathjax Syntax:

• Für n = 0 muss der Ausgang sein $$\varphi=1+\dots$$.
  Welches wird gerendert als:

  

• Für n = 1 muss der Ausgang sein $$\varphi=1+\cfrac1{1+\ddots}$$.
  Welches wird gerendert als:

  

• Für n = 2 muss der Ausgang sein $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Welches wird gerendert als:

  

• Für n = 3 muss der Ausgang sein $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Welches wird gerendert als:

  

Dieses Muster setzt sich für ein größeres n fort. Man könnte sagen, dass n die Anzahl der Teilungslinien in der Gleichung darstellt.

Anmerkungen

• \cfracwird anstelle des gebräuchlicheren verwendet \frac.
• \dotswird anstelle von \ddotsfür n = 0 verwendet.
• Nehmen Sie Eingaben von stdin oder der Befehlszeile entgegen.
• Ausgabe auf stdout (mit optionalem Zeilenumbruch).
• Alternativ können Sie eine Funktion schreiben, die n als Ganzzahl aufnimmt und den MathJax-Code als Zeichenfolge zurückgibt (oder ihn weiterhin druckt).

Wertung

Die kleinste Einsendung in Bytes gewinnt. Tiebreaker geht auf die frühere Vorlage.

CJam, 51 50 Bytes

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

Code Erklärung:

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

Einige Beispiele:

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 gespart dank Sp3000!

Probieren Sie es hier online aus

Python, 70 68 67 Bytes

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

Dies definiert eine anonyme Funktion, die nur einfache Zeichenfolgenmultiplikation und Zeichenfolgenformatierung verwendet.

(Vielen Dank an @xnor für den Hinweis, dass \\cnur geschrieben werden kann als \c, da cnicht maskiert werden kann . Leider gilt dies nicht für \\v, da \vASCII 11 ist.)

Bisherige Versuche:

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 Bytes

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

Laufen Sie mit der -vFlagge, z

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

Überraschenderweise macht sich> <> hier nicht schlecht, da wir die String-Multiplikation nachahmen können, indem wir einen Zähler haben, den wir bei jeder Iteration dekrementieren.

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

Retina , 160 + 7 = 167 Bytes

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

Jede Zeile geht in eine separate Quelldatei, daher habe ich nach der ersten 1 Byte für jede Datei hinzugefügt . Der -sEinfachheit halber unterstützt Retina jetzt auch das Befehlszeilen-Flag, mit dem Sie all dies in einer einzigen Datei zusammenfassen können (in diesem Fall werden die Zeilenumbrüche als Dateitrenner behandelt).

Der größte Teil des Codes (98 Byte) wird zum Konvertieren der Eingabe von dezimal nach unär (Dateien 3 bis 6) verwendet. Die Grundidee des Codes wird die Eingabe in umgeben $$\varphi=1+\dots...$$, dann wandelt die Eingabe in unäre, und erweitert \dotsNoder \ddotsNauf die nächsten Ebene des Kettenbruches ( bei gleichzeitiger Reduzierung Nzu N-1).

Julia, 76 73 Bytes

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

Dadurch wird eine Lambda-Funktion erstellt, die eine einzelne Ganzzahl als Eingabe verwendet und das MathJax als Zeichenfolge zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=n->....

Leider müssen sowohl Backslashes als auch Dollarzeichen in Julia-Strings maskiert werden, da beide eine besondere Bedeutung haben. Die Verkettung von *Zeichenfolgen erfolgt mit und die Wiederholung von Zeichenfolgen mit ^.

Beispiele:

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

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

Vorschläge sind wie immer willkommen!

Bearbeiten: 3 Bytes dank Plannapus gespeichert!

Element, 63 Zeichen

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

Dies ist die einfachste Lösung. Leider führt die große Anzahl von Symbolen in der Ausgabe zu einer signifikanten Erhöhung der Programmlänge (das Einfügen der Zeichenfolgen in das Programm bewirkt direkt, dass die Symbole Operationen ausführen). Ich bin sicher, dass es Platz zum Golfen gibt, aber ich habe momentan keine Zeit mehr.

Da diese Sprache noch relativ unbekannt ist, finden Sie hier einen in Perl geschriebenen Link zum Interpreter .

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

Es ist schon eine Weile her, dass ich eine SQL-Antwort gemacht habe, und wie immer ist es sehr ausführlich. Bearbeiten Natürlich habe ich es überkompliziert und brauchte überhaupt keine rekursive Abfrage.

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

Original

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

Dadurch wird eine Inline-Tabellenfunktion erstellt, die eine rekursive Abfrage verwendet, um den zusätzlichen cfrac1{1+\Inhalt pro Iteration einzufügen. Das Ändern der Punkte in Punkte war teuer, ersparte aber ein paar, die das Ersetzen loswurden :). Auch die ursprüngliche Zeichenfolge als 'VARCHAR (MAX)' umwandeln zu müssen, kostet ein wenig.

Es wird wie folgt verwendet :

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 Bytes

Das fühlt sich verdächtig einfach an, also lass es mich bitte wissen, wenn ich irgendwo etwas falsch gemacht habe.

Übrigens ist dies das erste, was ich jemals in Ruby geschrieben habe - ich suchte nach einer Sprache, die die Wiederholung von Zeichenfolgen durch Multiplikation unterstützt, und Ruby schien den Trick zu tun.

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

So bewerben:

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

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

J, 60 Bytes

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

Verwendung:

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

Methode:

Die Zeichenfolge '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'wird in Leerzeichen geschnitten und die Teile werden mehrmals wiederholt 1 n signum(n) 1 n 1und dann werden diese Teile verkettet.

Probieren Sie es hier online aus.

R 93, 90

Ähnlich wie die anderen Antworten. Vielen Dank an @plannapus für den Scan-Tipp.

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

catanstatt paste0 als das Ergebnis mit verwendet würde am Ende \\statt\ .

In Benutzung

> > 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, danke an George Reith

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

Dies ist meine erste Teilnahme an einem Codegolf-Wettbewerb! Bitte sag mir, wie ich mich verbessern kann.

Vorheriger Eintrag (106 Bytes):

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

Vorheriger Eintrag (109 Bytes):

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

Vorheriger Eintrag (114 Bytes):

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

Einfügen in die Browser-Konsole und Aufrufen als f(n)wo nist die Anzahl der "Schritte".

Vereinfachter Code :

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

Pyth - 52 Bytes

Der einfache Ansatz in Pyth, der der Python-Lösung von @ Sp3000 so ziemlich gestohlen wurde. Verwendet den Zeichenfolgenformatierungsoperator %.

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

Probieren Sie es hier online aus .

%                  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 Bytes

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

JavaScript (ES6), 76 80

Teilweise rekursiv. Das einfache / doppelte d ist der nervigste Teil.

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

Test In der Firefox / FireBug-Konsole

> 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

Da die effizienteste Lösung bereits mehrmals veröffentlicht wurde, werde ich stattdessen die Zeichenfolge ersetzen

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: Verdammt, übersehen dotsstatt ddotsfür n=0, jetzt ist die rekursive Lösung mit einer zusätzlichen Klausel zu hässlich, um mithalten zu können.

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

Im Wesentlichen derselbe Ansatz wie bei allen Lösungen. drop(0^n)"ddots"ist aber süß!