В ожидании временного отключения MathJax отображенный MathJax в этом вопросе был заменен изображениями. Вы все еще можете публиковать ответы, но вам придется просматривать отображенный MathJax на другом сайте .

PPCG только что получил MathJax ! Это означает, что теперь мы можем легко включать хорошо отформатированные математические формулы в сообщения. ( Handy MathJax учебник. )

Например, вот золотое сечение, выраженное в виде бесконечной непрерывной дроби :

Код MathJax для этого уравнения

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

^{Вы можете найти это, щелкнув правой кнопкой по формуле и следуя Show Math As → TeX Commands .
На $$средства он отображается на его собственный в центре страницы вместо встроенного. Используйте сингл $для inline.}

Вызов

Напишите программу, которая принимает неотрицательное целое число n и выводит код MathJax для такого количества «шагов» непрерывной дроби для золотого сечения.

Чтобы сохранить стандартность ответов, вы должны использовать этот точный синтаксис MathJax:

• Для n = 0 вывод должен быть $$\varphi=1+\dots$$.
  Который отображается как:

  

• Для n = 1 вывод должен быть $$\varphi=1+\cfrac1{1+\ddots}$$.
  Который представлен как:

  

• Для n = 2 вывод должен быть $$\varphi=1+\cfrac1{1+\cfrac1{1+\ddots}}$$.
  Который отображается как:

  

• Для n = 3 вывод должен быть $$\varphi=1+\cfrac1{1+\cfrac1{1+\cfrac1{1+\ddots}}}$$.
  Который отображается как:

  

Эта модель продолжается для больших п. Можно сказать, что n представляет количество линий деления в уравнении.

Примечания

• \cfracиспользуется вместо более распространенного \frac.
• \dotsиспользуется вместо \ddotsдля n = 0.
• Возьмите ввод из стандартного ввода или командной строки.
• Вывод в стандартный вывод (с необязательным завершающим переводом строки).
• В качестве альтернативы вы можете написать функцию, которая принимает n как целое число и возвращает код MathJax в виде строки (или все еще печатает ее).

счет

Наименьшая подача в байтах побеждает. Tiebreaker переходит к более раннему представлению.

CJam, 51 50 байт

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

Объяснение кода:

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

Несколько примеров:

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

ОБНОВЛЕНИЕ - 1 байт сохранен благодаря Sp3000!

Попробуйте это онлайн здесь

Python, 70 68 67 байт

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

Это определяет анонимную функцию, которая просто использует умножение строк и форматирование строк.

(Спасибо @xnor за указание, что это \\cможет быть записано как \c, поскольку cне может быть экранирован. К сожалению, это не так \\v, поскольку \vASCII 11.)

Предыдущие попытки:

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 байт

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

Беги с -vфлагом, например

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

Удивительно, но> <> здесь не так уж и плохо, поскольку мы можем имитировать умножение строк, имея счетчик, который мы уменьшаем на каждой итерации.

:&"$$"{\                     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 байта благодаря @randomra)

Сетчатка , 160 + 7 = 167 байт

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

Каждая строка входит в отдельный исходный файл, поэтому я добавил 1 байт для каждого файла после первого . Однако для удобства Retina теперь также поддерживает -sфлаг командной строки, который позволяет поместить все это в один файл (в этом случае символы новой строки обрабатываются как разделители файлов).

Большая часть кода (98 байт) используется для преобразования входных данных из десятичной в унарную (файлы с 3 по 6). Основная идея кода заключается в том, чтобы окружить входные данные $$\varphi=1+\dots...$$, затем преобразовать входные данные в унарные, а затем расширить \dotsNили \ddotsNперейти к следующему уровню непрерывной дроби (при уменьшении Nдо N-1).

Юлия, 76 73 байта

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

Это создает лямбда-функцию, которая принимает одно целое число в качестве входных данных и возвращает MathJax в виде строки. Чтобы назвать его, дайте ему имя, например f=n->....

К сожалению, в строках Julia необходимо избегать обратной косой черты и знака доллара, поскольку они оба имеют особое значение. Конкатенация строк выполняется с использованием *и повторения строк с ^.

Примеры:

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

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

Предложения приветствуются как всегда!

Изменить: Сохранено 3 байта благодаря plannapus!

Элемент, 63 символа

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

Это самое простое решение. К сожалению, большое количество символов в выводе приводит к значительному увеличению длины программы (размещение строк в программе напрямую приводит к выполнению операций символами). Я уверен, что есть место для игры в гольф, но сейчас у меня нет больше времени.

Поскольку этот язык все еще относительно неизвестен, здесь есть ссылка на переводчик , написанный на 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

Прошло некоторое время с тех пор, как я сделал ответ на SQL, и, как всегда, он очень многословен. Edit Конечно , я более сложное это и не нужен рекурсивный запрос вообще.

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

оригинал

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

Это создает встроенную табличную функцию, которая использует рекурсивный запрос для добавления cfrac1{1+\в дополнительную итерацию. Изменение точек на ddots было дорого, но спасло пару избавиться от замены :). Кроме того, необходимость приведения оригинальной строки как VARCHAR (MAX) стоит немного.

Он используется следующим образом 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}}}}}$$

Рубин, 76 75 71 70 байт

Это кажется подозрительно простым, поэтому, пожалуйста, дайте мне знать, если я что-то напутал.

Между прочим, это первое, что я написал в Ruby - я искал язык, который поддерживал бы повторение строк путем умножения, и Ruby, похоже, добился цели.

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

Применяться так:

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

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

J, 60 байт

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

Использование:

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

Метод:

Строка '$$\varphi=1+\ cfrac1{1+\ d dots } $$ 'разрезается на пробелы, и части повторяются, 1 n signum(n) 1 n 1а затем эти части объединяются.

Попробуйте это онлайн здесь.

R, 93 90

Почти так же, как и другие ответы. Спасибо @plannapus за совет по сканированию.

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

catиспользуется, а не paste0, так как результат будет \\скорее, чем \.

В использовании

> > 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 байт благодаря Джорджу Рейту

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

Это моя первая запись в соревновании по кеглю! Пожалуйста, скажите мне, как улучшить.

Предыдущая запись (106 байт):

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

Предыдущая запись (109 байт):

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

Предыдущая запись (114 байт):

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

Вставьте в консоль браузера и назовите, f(n)где nчисло шагов.

Упрощенный код :

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

Pyth - 52 байта

Простой подход в Pyth, в значительной степени украденный из решения Python @ Sp3000. Использует оператор форматирования строки %.

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

Попробуйте это онлайн здесь .

%                  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 байтов

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

JavaScript (ES6), 76 80

Частично рекурсивный. Одиночный / двойной d является наиболее раздражающей частью.

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

Тест в консоли 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}}}}$$

Питон, 90 116

так как наиболее эффективное решение уже было опубликовано несколько раз, вместо этого я заменяю строку

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

Редактировать: черт, упустил из виду dotsвместо ddotsfor n=0, теперь рекурсивное решение с добавленным дополнительным предложением слишком уродливо, чтобы конкурировать.

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

Хаскелл, 86

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

По сути тот же подход, что и все решения здесь. drop(0^n)"ddots"это мило, хотя!