^{Ini adalah versi ASCII dari tantangan ini . Posting awal dipisahkan per permintaan oleh Martin Ender}

pengantar

Mirip dengan Urutan Fibonacci, Urutan Padovan ( OEIS A000931 ) adalah urutan angka yang dihasilkan dengan menambahkan istilah sebelumnya dalam urutan. Nilai awal didefinisikan sebagai:

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

Istilah 0, 1, dan 2 semuanya 1. Relasi perulangan dinyatakan di bawah ini:

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

Dengan demikian, ia menghasilkan urutan berikut:

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

Menggunakan angka-angka ini sebagai panjang sisi dari segitiga sama sisi menghasilkan spiral yang bagus ketika Anda menempatkan semuanya, seperti Fibonacci Spiral:

^{Gambar milik Wikipedia}

Tugas

Tugas Anda adalah menulis program yang membuat ulang spiral ini dengan seni ASCII, dengan input yang sesuai dengan istilah mana. Karena segitiga dengan panjang sisi 1 (1 karakter) tidak mungkin direpresentasikan dengan baik di ASCII, panjang sisi telah dilebarkan oleh faktor 2. Dengan demikian, segitiga dengan panjang sisi 1 sebenarnya direpresentasikan seperti:

 /\
/__\

Jadi, misalnya, jika inputnya 5 (istilah ke-5), outputnya harus:

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

5 istilah pertama adalah 1, 1, 1, 2, 2, sehingga segitiga memiliki panjang sisi 2, 2, 2, 4, 4 karena pelebaran. Contoh lain untuk input 8:

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

Aturan

• Anda harus mencetak hasilnya, dan input harus berupa bilangan bulat yang sesuai dengan nomor term
• Mengejar dan memimpin baris baru diizinkan, membuntuti spasi setelah garis juga diizinkan
• Kiriman Anda harus dapat menangani setidaknya hingga jangka waktu 10 (9)
• Kiriman Anda harus berupa program atau fungsi lengkap yang mengambil input dan mencetak hasilnya
• Rotasi output diperbolehkan, dalam kelipatan 60 derajat, tetapi ukuran segitiga harus tetap sama, bersama dengan representasi
• Berlawanan arah jarum jam juga diperbolehkan
• Celah standar dilarang

Anda dapat berasumsi bahwa input akan> 0 dan format input yang benar akan diberikan.

Mencetak gol

Ini adalah kode-golf , jadi kode terpendek dalam byte menang. Selamat Tahun Baru semuanya!

Befunge, 871 836 798 bytes

&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

Cobalah online!

Seperti yang sering terjadi pada Befunge, triknya adalah dengan algoritme yang memungkinkan kita untuk merender pola dari atas ke bawah, karena tidak layak untuk merendernya terlebih dahulu dengan ruang terbatas yang tersedia.

Cara ini bekerja adalah dengan terlebih dahulu membangun struktur data sederhana yang mewakili tepi yang diperlukan untuk menggambar spiral. Tahap kedua kemudian mem-parsing struktur itu dari atas ke bawah, menampilkan fragmen tepi yang diperlukan untuk setiap baris output.

Dengan menggunakan teknik ini, kami dapat mendukung hingga n = 15 dalam implementasi referensi sebelum kami mulai mengalami masalah overflow dalam sel memori 8-bit. Penerjemah dengan ukuran sel yang lebih besar harus dapat mendukung hingga n = 25 sebelum kehabisan memori.

pergi, 768 byte

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

Ini tentu saja tidak optimal, tetapi itu bukan awal yang buruk. Saya tahu itu mungkin agak sederhana untuk standar golf, tapi itu menyenangkan dan saya harap tidak keberatan jika saya meninggalkan beberapa catatan untuk diri sendiri di masa depan.

Bagaimana itu bekerja

Pada dasarnya saya mensimulasikan 'menggambar kura-kura' seperti di LOGO pada kisi pixel ASCII, tetapi kura-kura hanya dapat melakukan tiga perintah ini:

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 \

Sekarang untuk setiap segitiga, saya pergi seperti ini, di mana P adalah 2x nomor Padovan ke-n:

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

'Fd' keempat berarti saya menelusuri kembali sisi pertama setiap segitiga. Ini membantu untuk kembali ke titik awal yang bagus untuk segitiga berikutnya. Setengah kanan belok memastikan bahwa segitiga berikutnya akan berada dalam orientasi yang tepat.

Untuk bermain golf kura-kura, saya menyimpan 5 variabel keadaan dalam array 态: posisi x, posisi y, kecepatan x, kecepatan y, dan 'rune menggambar'. Pada setiap frame animasi, x + = x kecepatan, y + = y kecepatan, dan rune ditarik.

Lalu saya mengatur tabel 表 yang memberitahu bagaimana sebenarnya melakukan belokan. Kode gilirannya rumit karena cara seni ASCII bekerja. Ini bukan gerakan langsung seperti pada layar piksel. Arah kura-kura, ditentukan oleh kecepatan x dan y, menentukan perubahan yang diperlukan untuk mendapatkan belokan agar terlihat benar.

Untuk mengubahnya, ia melihat kecepatan x dan y saat ini, dan menggabungkannya ke dalam indeks.

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

Indeks ini digunakan untuk mencari satu set 5 nilai dalam tabel 表. Kelima nilai dalam tabel 表 kemudian ditambahkan ke masing-masing dari 5 variabel dalam keadaan 态. Penyu kemudian secara efektif berbalik, dan siap untuk 'fd' berikutnya.

Untuk rth, setengah dari belokan kanan, ada bagian terpisah dari tabel 表. Diimbangi oleh entri 7 * 5, atau 35, dari tabel pertama di 表.

Terakhir saya melakukan beberapa pengkodean sederhana dari integer tabel menjadi string ascii.

Saya tahu saya bisa 'menyimpan byte' dengan menghapus Hanzi tapi seperti saya katakan, ini tidak optimal dan ada lebih banyak golf yang mungkin ... Saya akan menghapusnya ketika tidak ada optimasi lain yang mungkin. Hanzi itu sebenarnya memiliki makna yang longgar berdasarkan pada makna sebenarnya, dan meskipun saya tidak tahu bahasa Cina, itu membantu saya berpikir tentang program tersebut.

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

Untuk menguji kode Anda perlu file golang lengkap, dengan header ini

package main
import "fmt"

dan catatan kaki ini

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

Terima kasih