^{Это версия ASCII этого вызова . Первоначальный пост был отделен по запросу Мартина Эндера}

Введение

Подобно последовательности Фибоначчи, последовательность Падована ( OEIS A000931 ) представляет собой последовательность чисел, которая получается путем добавления предыдущих терминов в последовательность. Начальные значения определяются как:

P(0) = P(1) = P(2) = 1

Все 0-й, 1-й и 2-й члены равны 1. Отношение повторения указано ниже:

P(n) = P(n - 2) + P(n - 3)

Таким образом, он дает следующую последовательность:

1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37, 49, 65, 86, 114, 151, 200, 265, 351, ...

Использование этих чисел в качестве длины сторон равносторонних треугольников дает хорошую спираль, когда вы размещаете их все вместе, во многом как спираль Фибоначчи:

^{Изображение предоставлено Википедией}

задача

Ваша задача состоит в том, чтобы написать программу, воссоздающую эту спираль в соответствии с искусством ASCII, с вводом, соответствующим определенному термину. Так как треугольник с длиной стороны 1 (1 символ) невозможно хорошо представить в ASCII, длины сторон были расширены с коэффициентом 2. Таким образом, треугольник с длиной стороны 1 фактически представлен так:

 /\
/__\

Так, например, если входное значение было 5 (5-й член), выходное значение должно быть:

   /\
  /  \
 /    \
/______\
\      /\
 \    /__\ 
  \  /\  /
   \/__\/

Первые 5 слагаемых были 1, 1, 1, 2, 2, поэтому треугольник имел длину сторон 2, 2, 2, 4, 4 из-за расширения. Еще один пример для ввода 8:

     __________
   /\          /\
  /  \        /  \
 /    \      /    \
/______\    /      \
\      /\  /        \
 \    /__\/          \
  \  /\  /            \
   \/__\/______________\
    \                  /
     \                /
      \              /
       \            /
        \          /
         \        /
          \      /
           \    /
            \  /
             \/

правила

• Вы должны напечатать результат, и ввод должен быть целым числом, соответствующим номеру термина
• Допускается завершающий и ведущий переводы строк, также допускаются завершающие пробелы после строк
• Ваша заявка должна быть в состоянии обработать по крайней мере до 10-го семестра (9)
• Ваша заявка должна быть полной программой или функцией, которая принимает данные и печатает результат
• Вращения выходных данных допускаются с кратностью 60 градусов, но размер треугольников должен оставаться неизменным вместе с представлением
• Также возможно движение против часовой стрелки
• Стандартные лазейки запрещены

Вы можете предположить, что ввод будет> 0, и будет указан правильный формат ввода.

счет

Это код-гольф , поэтому выигрывает самый короткий код в байтах. Всех с новым годом!

Befunge, 871 836 798 байт

&00p45*:10p20p030p240p050p060p9010gp9110gp1910gp1-91+10gpv
<v-g03+g06*2g041g055_v#!:%6:p06p05+p04g05g06:g04<p*54+292<
->10g:1\g3+:70p110gv >:5- #v_550g:01-\2*40g+1-30g
/\110:\-g03:\1:g055 _v#!-4:<vp01:-1g01-g03-1\-
^1<v07+1:g07< p08p < >:1-#v_550g:01-\40g+60g+1-30g-50g>v
 _0>p80gp:5-|v1\+66\:p\0\9:$<:p02:+1g02-g03+g06-\g04\1:<
0v|-g00:+1$$<>\p907^>p:!7v>3-#v_550g:30g+:30p1\0\-
1>10g+::0\g3-:70p\0^^07<v<>50#<g::30g+:30p-1-01-\
v >\$0gg> :1+10gg1- #v_^>0g10gg*+\:!2*-70g2+10gv>:#->#,"_"$#1_:1#<p
+1+g03$_^#`gg011+3:+3<g07\+*2+*`0:-\gg01+5g07:g<>1#,-#*:#8>#4_$#:^#
>55+,p30g40p10gg10g1>#v_
#v:#p0$#8_:$#<g!#@_0^ >
 >>:180gg`>>#|_:2+80gg:!v
3+^g\0p08:<vgg08+2::+3<$_100p1-v>g,\80gg+\80gp:2+90g:!01p\80gp
!#^_80g:1+^>\180gg`+!#^_20g80g`
5*g10!g09p04-1-\0\+g04:gg08:p09<^3`0:gg08+1:::$$_1#!-#\\:,#\<g

Попробуйте онлайн!

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

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

Используя эту технику, мы можем поддерживать до n = 15 в эталонной реализации, прежде чем у нас возникнет проблема переполнения в 8-битных ячейках памяти. Интерпретаторы с большим размером ячейки должны иметь возможность поддерживать до n = 25, прежде чем закончится память.

идти, 768 байт

func 卷(n int){
    数:=0
    p:=[]int{1,1,1}
    for i:=3;i<n;i++ {p=append(p,p[i-2]+p[i-3])}
    宽:=p[len(p)-1]*10+10
    素:=make([]int,宽*宽)
    for 数=range 素 {素[数]=32}
    for i:=0;i<数;i+=宽 {素[i]=10}
    态:=[]int{1,1,宽/2,宽/2,92}
    表:=[70]int{}
    s:="SRSQTSPQQ!QOQP~QQQQQQSQR~ORQR!OPOPTSQRQ$QPPQNQPPPXQQQQQQRRQXQRRRNOQPQ$"
    for i:=range s {表[i]=int(s[i])-33-48}
    表[49],表[59]=48,48
    for i:=0;i<4*n;i++ {
        梴:=p[i/4]*2
        if 态[1]==0 {梴=梴*2-2}
        for k:=0;k<梴;k++ {
            址:=(态[2]+态[3]*宽)%len(素)
            if 素[址]==32 {素[址]=态[4]}
            态[2]+=态[0]
            态[3]+=态[1]
        }
        数=((态[0]+1)*2+态[1]+1)*5
        if i%4>2 {数+=35}
        for k:=0;k<5;k++ {态[k]+=表[数+k]}
    }
    for i:=0;i<宽*宽;i++ {fmt.Printf("%c",rune(素[i]))}
}

Это, конечно, не оптимально, но это неплохое начало. Я знаю, что это, вероятно, немного просто для стандартов игры в гольф, но это было весело, и я надеюсь, что это не имеет значения, если я оставлю некоторые заметки будущему себе.

Как это работает

По сути, я имитирую «рисованную черепаху», как в LOGO, на сетке пикселей ASCII, но черепаха может выполнять только эти три команды:

rt   - right turn, turn 120 degrees right (1/3 of a Turn)
rth  - right turn half, turn  60 degrees right (1/6 of a Turn)
fd n - forward, go forward n steps, drawing a trail of _, /, or \

Теперь для каждого треугольника я иду следующим образом, где P - это 2-е число n-го Падована:

fd P
rt
fd P
rt 
fd P
rt
fd P
rth

Четвертый «fd» означает, что я пересматриваю первую сторону каждого треугольника. Это помогает вернуться к хорошей отправной точке для следующего треугольника. Половина правого поворота гарантирует, что следующий треугольник будет в правильной ориентации.

Для игры в черепаху я храню 5 переменных состояния в массиве 态: положение x, положение y, скорость x, скорость y и «руна рисования». На каждом кадре анимации x + = x скорость, y + = y скорость, и рисуется руна.

Затем я установил таблицу 表, в которой рассказывается, как на самом деле выполнить поворот. Код поворота хитрый из-за того, как работает искусство ASCII. Это не прямолинейное движение, как на пиксельном дисплее. Направление черепахи, определяемое скоростью x и y, определяет изменения, необходимые для правильного поворота.

В свою очередь, он смотрит на текущие скорости x и y и объединяет их в индекс.

xv = x velocity, yv = y velocity. 
i.e. a turtle facing down and to the right has 
xv of 1, and yv of 1. It can only face 6 
different directions. Formula is (xv+1)*2+yv+1

xv  yv    index
-1  -1    0
-1   0    1
-1   1    2
 1  -1    4
 1   0    5
 1   1    6

Этот индекс используется для поиска набора из 5 значений в таблице 表. Эти 5 значений в таблице then затем добавляются к каждой из 5 переменных в состоянии 态. Черепаха затем эффективно поворачивается и готова к следующему «fd».

Для rth, половина правого поворота, есть отдельный раздел таблицы.. Он смещен на 7 * 5 или 35 записей из первой таблицы в 表.

Наконец, я сделал простое кодирование целых чисел таблицы в строку ascii.

Я знаю, что мог бы «сохранить байты», удалив Hanzi, но, как я уже сказал, это не оптимально, и в игре больше возможностей для игры в гольф ... Я уберу их, когда нет другой возможной оптимизации. Эти Hanzi на самом деле имеют значение, основанное на их фактическом значении, и хотя я не знаю китайский язык, это помогает мне думать о программе.

数  index number
宽  screen width
素  pixel data
梴  length of side of triangle
态  current state
址  address of pixel
表  state transition table

Для проверки кода вам понадобится полный файл golang с этим заголовком

package main
import "fmt"

и этот нижний колонтитул

func main ()  {
    for i := 0; i<15; i++ {
       卷(i)
    }
}

Благодарность