Generieren Sie MathJax für den Golden Ratio Continued Fraction

17

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 :

eq0

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:

    eq1

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

    eq2

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

    eq3

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

    eq4

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.

code-golf  math  kolmogorov-complexity 
— Calvins Hobbys
quelle
Nur eine Anmerkung für diejenigen, die das Stack-Snippet ausführen möchten: Wie bei vielen (den meisten?) Stack-Snippets funktioniert dies in Safari nicht.
— Alex A.
Das Stack-Snippet funktioniert nicht, wenn Sie etwas Uncaught ReferenceError: textbox is not defined
— eingeben
@soktinpk Das ist seltsam, ich habe das gleiche Problem. Aber das Snippet hier funktioniert, obwohl es genau dasselbe ist ... Hier ist ein externer Bytezähler für den Fall.
— Calvins Hobbys
MathJax wurde für PPCG wieder aktiviert!
— Wastl

Antworten:

6

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

— Optimierer
quelle
1
Ein wenig mischen ergibt 50:"$$\varphi=1+""\cfrac1{1+"ri:R*'\"ddots"R!>'}R*'$_
— Sp3000
Ich habe deine Antwort überhaupt nicht angeschaut - nur Zufall. So oder so, Ihre 49 Byte Pyth Lösung ist 50 Bytes in der Realität, weil Sie zu entkommen \vzu \\v.
— Orlp
@orlp und aus diesem Grund habe ich einen Rollback durchgeführt, da diese Lösung auch hier keinen potenziellen Nutzen brachte.
— Optimierer
10

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)
— Sp3000
quelle
Du hast mich um 14 Sekunden geschlagen! Auch 70 Zeichen.
— xnor
2
Ich denke, dass dies funktioniert, ohne ein double \ vor cfrac zu verwenden.
— xnor
@xnor Scheint so, danke! Und entschuldigen Sie, dass Sie die ganze Zeit Python-Golf gespielt haben ...
— Sp3000
Nein, ich habe meinen ganzen Anteil an Rennen gestohlen, um sie dir zu entlocken.
— xnor
4

> <> , 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)

— Sp3000
quelle
Zwei kleine Verbesserungen für 3 Bytes (am Ende der Linie 1 und Linie 3): pastebin.com/wEbKhuUH
— randomra
Hah die erste und letzte Zeile Spiegel übereinstimmen, nicht bemerkt: P
— Sp3000
4

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).

— Martin Ender
quelle
4

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!

— Alex A.
quelle
"d"^(n>0)anstatt (n>0?"d":"")würde es kürzer machen.
— Plannapus
@plannapus: Ich verstehe nicht, was dein Name bedeutet, aber du bist ein Genie! Ich hatte vergessen, dass "string"^0das echt war.
— Alex A.
Bitte. Mein Pseudonym ist der Name einer radioaktiven Gattung, da ich selbst ein radioaktiver Paläontologe bin. Es bedeutet "abgeflachte Rübe", denke ich :)
— Plannapus
Ich warte auf eine Antwort von BF =)
— flawr
@flawr: Ich hoffe, Sie warten nicht auf mich ...
— Alex A.
3

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 $$
— PhiNotPi
quelle
+1 für die Verwendung von Element! Es ist Zeit, dass Element ein Begriff wird!
— Alex A.
3

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}}}}}$$
— MickyT
quelle
3

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}}}$$
— vvye
quelle
@ Sp3000 Ersteres nicht, da Ruby anscheinend keine Booleschen Werte in Ganzzahlen konvertieren kann. Letzteres funktionierte aber, also danke dafür!
— Vvye
2

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.

— zufällig
quelle
2

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}}}$$
— MickyT
quelle
+1 aber anstatt es zu einer Funktion zu machen, können Sie, wenn Sie den Benutzer nbeim ersten Auftreten als stdin eingeben lassen, einige Zeichen speichern:cat("$$\\varphi=1+\\",rep("cfrac1{1+\\",n<-scan()),if(n)"d","dots",rep("}",n),"$$",sep="")
— plannapus
2

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)+"$$";
   }
2
x = 'repeat' macht es länger, nicht kürzer: benutze .repeat as is und spare 3 Zeichen
— edc65
@ edc65 danke !!
pastebin.com/uU7tgFm9 einige weitere Verbesserungen
— edc65
Kann wie folgt
— George Reith
Oder 85 Bytes pastebin.com/k90Fyr2m
— George Reith
1

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
— Maltysen
quelle
1

Pyth, 50 Bytes

s["$$\\varphi=1+"*Q"\cfrac1{1+"\\<\dQ"dots"*Q\}"$$
— orlp
quelle
1
Siehe meine Bearbeitungshistorie :)
— Optimierer
1

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}}}}$$
— edc65
quelle
0

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}')
— DenDenDo
quelle
Hier fehlt momentan der n=0Sonderfall (Punkte statt Punkte).
— Randomra
0

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üß!

— Lynn
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.