^{Đây là phiên bản ASCII của thử thách này . Bài đăng ban đầu được phân tách theo yêu cầu của Martin Ender}

Giới thiệu

Tương tự như Chuỗi Fibonacci, Chuỗi Padovan ( OEIS A000931 ) là một chuỗi các số được tạo ra bằng cách thêm các số hạng trước đó trong chuỗi. Các giá trị ban đầu được định nghĩa là:

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

Các điều khoản 0, 1 và 2 đều là 1. Mối quan hệ lặp lại được nêu dưới đây:

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

Do đó, nó mang lại trình tự sau:

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

Sử dụng các số này làm độ dài cạnh của các hình tam giác đều tạo ra một đường xoắn ốc đẹp khi bạn đặt tất cả chúng lại với nhau, giống như hình xoắn ốc Fibonacci:

^{Hình ảnh lịch sự của Wikipedia}

Bài tập

Nhiệm vụ của bạn là viết một chương trình tái tạo vòng xoắn ốc này bằng nghệ thuật ASCII, với đầu vào tương ứng với thuật ngữ nào. Do một tam giác có độ dài cạnh 1 (1 ký tự) không thể biểu diễn độc đáo trong ASCII, nên độ dài cạnh đã bị giãn bởi hệ số 2. Do đó, tam giác có độ dài cạnh 1 thực sự được biểu diễn như vậy:

 /\
/__\

Vì vậy, ví dụ, nếu đầu vào là 5 (thuật ngữ thứ 5), thì đầu ra phải là:

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

5 số hạng đầu tiên là 1, 1, 1, 2, 2, do đó tam giác có các cạnh dài 2, 2, 2, 4, 4 do sự giãn nở. Một ví dụ khác cho đầu vào 8:

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

Quy tắc

• Bạn phải in kết quả và đầu vào phải là số nguyên tương ứng với số hạng
• Trailing và dòng mới hàng đầu được cho phép, dấu cách sau khi dòng cũng được cho phép
• Việc gửi của bạn phải có khả năng xử lý ít nhất đến nhiệm kỳ thứ 10 (9)
• Nội dung gửi của bạn phải là một chương trình hoặc chức năng đầy đủ nhận đầu vào và in kết quả
• Xoay của đầu ra được cho phép, theo bội số 60 độ, nhưng kích thước của các hình tam giác phải giữ nguyên, cùng với biểu diễn
• Đi ngược chiều kim đồng hồ cũng được cho phép
• Sơ hở tiêu chuẩn bị cấm

Bạn có thể cho rằng đầu vào sẽ> 0 và định dạng đầu vào chính xác sẽ được cung cấp.

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng. Chuc mưng năm mơi mọi ngươi!

Befunge, 871 836 798 byte

&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

Hãy thử trực tuyến!

Như thường thấy với Befunge, thủ thuật được đưa ra với một thuật toán cho phép chúng ta kết xuất mô hình từ trên xuống dưới, vì trước tiên không thể đưa nó vào bộ nhớ với không gian hạn chế.

Cách thức hoạt động này là trước tiên xây dựng một cấu trúc dữ liệu đơn giản đại diện cho các cạnh cần thiết để vẽ hình xoắn ốc. Giai đoạn thứ hai sau đó phân tích cấu trúc đó từ trên xuống dưới, hiển thị các đoạn cạnh cần thiết cho mỗi dòng đầu ra.

Sử dụng kỹ thuật này, chúng tôi có thể hỗ trợ tối đa n = 15 trong triển khai tham chiếu trước khi chúng tôi bắt đầu gặp sự cố tràn trong các ô nhớ 8 bit. Các trình thông dịch có kích thước ô lớn hơn sẽ có thể hỗ trợ tới n = 25 trước khi hết bộ nhớ.

đi, 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]))}
}

Điều này tất nhiên là không tối ưu, nhưng nó không phải là một khởi đầu tồi. Tôi biết nó có thể hơi đơn giản đối với các tiêu chuẩn chơi gôn, nhưng nó rất vui và tôi hy vọng nó không phiền nếu tôi để lại một số ghi chú cho bản thân trong tương lai.

Làm thế nào nó hoạt động

Về cơ bản, tôi mô phỏng một 'con rùa vẽ' như trong LOGO trên lưới pixel ASCII, nhưng con rùa chỉ có thể thực hiện ba lệnh sau:

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 \

Bây giờ với mỗi tam giác, tôi đi như thế này, trong đó P gấp 2 lần số Padovan thứ n:

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

'Fd' thứ tư có nghĩa là tôi đang truy tìm lại cạnh đầu tiên của mỗi tam giác. Điều này giúp quay trở lại điểm khởi đầu tốt đẹp cho tam giác tiếp theo. Xoay nửa bên phải đảm bảo rằng tam giác tiếp theo sẽ nằm đúng hướng.

Để đánh gôn rùa tôi lưu trữ 5 biến trạng thái trong mảng: x vị trí, vị trí y, vận tốc x, vận tốc y và 'vẽ rune'. Tại mỗi khung hình động, x + = x vận tốc, y + = y vận tốc và rune được vẽ.

Sau đó, tôi thiết lập bảng cho biết cách thực hiện lần lượt. Mã lần lượt là khó khăn vì cách hoạt động của nghệ thuật ASCII. Nó không phải là một chuyển động đơn giản như trên màn hình pixel. Hướng của rùa, được xác định bởi vận tốc x và y, xác định các thay đổi cần thiết để có được lượt đi để trông phù hợp.

Để biến, nó nhìn vào vận tốc x và y hiện tại, và kết hợp chúng thành một chỉ mục.

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

Chỉ mục này được sử dụng để tra cứu một bộ 5 giá trị trong bảng. 5 giá trị đó trong bảng then sau đó được thêm vào mỗi trong số 5 biến ở trạng thái. Con rùa sau đó được quay một cách hiệu quả và sẵn sàng cho 'fd' tiếp theo.

Đối với rth, một nửa rẽ phải, có một phần riêng của bảng. Nó được bù bởi 7 * 5 hoặc 35, các mục từ bảng đầu tiên trong.

Cuối cùng tôi đã thực hiện một số mã hóa đơn giản các số nguyên của bảng thành một chuỗi ascii.

Tôi biết tôi có thể 'tiết kiệm byte' bằng cách loại bỏ Hanzi nhưng như tôi đã nói, điều này không tối ưu và có thể chơi gôn nhiều hơn ... Tôi sẽ xóa chúng khi không có tối ưu hóa nào khác. Những Hanzi thực sự có ý nghĩa lỏng lẻo dựa trên ý nghĩa thực tế của chúng, và mặc dù tôi không biết tiếng Trung Quốc, nó giúp tôi suy nghĩ về chương trình.

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

Để kiểm tra mã, bạn sẽ cần tệp golang đầy đủ, với tiêu đề này

package main
import "fmt"

và chân trang này

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

cảm ơn