การแข่งขันครั้งนี้จบลงแล้ว ขอบคุณสำหรับรายการที่ไม่ใช่ esolang ที่น่าสนใจและขอแสดงความยินดีกับJakuje ที่ได้รับรางวัลจาวาสคริปต์

ในประเพณีที่ยิ่งใหญ่ของความท้าทายศิลปะ ASCII ในเว็บไซต์นี้นี่คืออีกหนึ่ง รับอินพุตวาดเกลียว

&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

ง่ายใช่มั้ย เฮ้เฮ้ ... เฮ้ ...

(ได้รับแรงบันดาลใจจากการโพสต์Curve ASCII DragonsและASCII Art of the Dayของเครื่องมือเพิ่มประสิทธิภาพ)

อินพุต

ข้อมูลที่ป้อนจะอยู่ในรูปแบบของชุดพารามิเตอร์ที่นำมาจากอาร์กิวเมนต์ STDIN / function / etc ตามปกติไม่ว่าภาษาของคุณจะประกอบด้วยอะไรประกอบด้วยสี่ส่วน ส่วนเหล่านี้อาจเป็นอาร์กิวเมนต์ที่แยกกันสี่ส่วนสี่ส่วนอาร์เรย์ขนาด 4 เป็นต้นเพื่อความเรียบง่ายและสอดคล้องกันตลอดการท้าทายฉันจะแสดงอินพุตเป็นคำเดียว

• จำนวนเต็มที่2 ≤ x ≤ 20ระบุขนาดของเกลียวในรูปของ "กำลังสอง" ที่มีอักขระที่พิมพ์แต่ละตัวที่แทนขนาดหนึ่ง "สี่เหลี่ยม" ตามหลักวิชานี้อาจมีขอบเขตขนาดใหญ่ แต่เนื่องจากเรากำลังวาดศิลปะ ASCII ขีด จำกัด บนที่ปลอดภัยของสิ่งนี้จะเท่ากับ 20 เพื่อให้พอดีกับหน้าจอค่อนข้างเหมาะสม
• อักษรตัวเดียวของd u rหรือlแสดงการเคลื่อนไหวเริ่มต้นจาก "สี่เหลี่ยม" เริ่มต้น (ลง, ขึ้น, ขวา, ซ้าย)
• ตัวเลือกcระบุว่า "ทวนเข็มนาฬิกา" ถ้าcเว้นไว้ให้ถือว่าหมุนตามเข็มนาฬิกาสำหรับเกลียว
• จำนวนเต็มสุดท้าย1 ≤ y ≤ 10ที่ระบุจำนวนครั้งที่จะวาดรูปเกลียวหมุนวนโดยใช้ "สแควร์" ที่เสร็จสิ้นของเกลียวก่อนหน้าเป็น "สแควร์" เริ่มต้นของรูปแบบใหม่ ฉันเลือกขีด จำกัด สูงสุดที่ 10 เพราะฉันต้องการให้การวาดภาพเสร็จสิ้นในบางจุด
• ตัวอย่างอินพุต: 20lc5 13d2 2rc1

สิ่งที่น่าสนใจโปรดทราบว่าค่าคี่สำหรับอินพุตขนาดจะส่งผลให้เกิดการ@เป็นศูนย์กลางที่แน่นอนของเกลียวอยู่เสมอ แต่แม้ค่าอาจมีการเริ่มต้น "สแควร์" ชดเชยในทิศทางแนวทแยงทั้งสี่ใด ๆ ขึ้นอยู่กับทิศทางของการเริ่มต้น การท่องเที่ยว. ซึ่งอาจส่งผลให้ ... รูปแบบ ... น่าสนใจ ... ดูตัวอย่างทั้งสองด้านล่าง

การป้อนข้อมูลที่ไม่เป็นไปตามข้อกำหนดการป้อนข้อมูล (เช่น11q#s) จะไม่ได้กำหนดและฉันคาดหวังอย่างเต็มที่ว่าโปรแกรมจะต้องถูกต้อง :)

เอาท์พุต

เอาต์พุตเป็นเอาต์พุต ASCII ที่พิมพ์ได้ผ่าน STDOUT เทียบเท่าภาษาโดยมีข้อกำหนดดังต่อไปนี้:

• เริ่มต้น "สแควร์" (ของแต่ละ recursion) @จะต้องมีเครื่องหมายที่เข้าสู่ระบบ
• "สี่เหลี่ยม" สุดท้ายจะต้องทำเครื่องหมายด้วยเครื่องหมาย&และ ในกรณีที่มีการเรียกซ้ำหลายครั้งควรทำเครื่องหมาย "สี่เหลี่ยม" สุดท้าย&เท่านั้น
• มุมของความจำเป็นในเส้นทางเกลียวที่ "จุด" < > v ^ในทิศทางของการเดินทางโดยใช้
• |จำเป็นที่จะต้องเดินทางในแนวตั้งที่จะวาดโดยท่อ
• -ต้องการเดินทางแนวนอนจะถูกวาดด้วยขีดกลาง
• "สี่เหลี่ยม" ที่ถูกเขียนทับโดยการเรียกซ้ำในภายหลังควรแสดงทิศทางการเดินทางล่าสุด ซึ่งจะส่งผลให้เกิดการสอบถามซ้ำ "ที่ใหม่กว่า" ซึ่งดูเหมือนว่าจะซ้อนทับกันบนการเรียกซ้ำ "รุ่นเก่า" ดู4rc3ตัวอย่างด้านล่าง
• ขึ้นบรรทัดใหม่สุดท้ายต่อท้ายคือตกลงช่องว่างนำอาจเป็นสิ่งจำเป็นและได้รับอนุญาต แต่ไม่อนุญาตช่องว่างต่อท้าย
• ฉันจะไม่เทียบท่าคุณถ้าคุณใช้ escape sequences เพื่อวาด ASCII art ไปที่ STDOUT แต่ฉันจะผิดหวังในตัวคุณ (คุณจะยังคงมีสิทธิ์ได้รับเงินรางวัลถ้าคุณใช้พวกเขา)

ตัวอย่าง

2d4 = เส้นผ่านศูนย์กลางของ 2 เริ่มต้นโดยลงไปตามเข็มนาฬิกา 4 รอบซ้ำ

&@@@@
^<<<<

ในตัวอย่างนี้รูปวาดเริ่มต้นที่มุมขวาบน@เลื่อนลงหนึ่งซ้ายซ้ายขึ้นหนึ่งอัน ณ จุดนี้เราได้ทำการ2dแบ่งเสร็จแล้วจึงเริ่มต้นการสอบถามซ้ำครั้งที่ 2 ดังนั้นเราจึงมีอีก@อันลงหนึ่งเหลือหนึ่งเพิ่มขึ้นหนึ่งใหม่ จากนั้นเรียกซ้ำครั้งที่ 3; แล้วที่ 4 &และในที่สุดก็ของเรา

4rc3 = เส้นผ่านศูนย์กลางของ 4 เริ่มโดยไปทางขวาทวนเข็มนาฬิกา 3 รอบ

&--<
v-<|
|@^|<
>--^|
 |@^|<
 >--^|
  |@^|
  >--^

ในตัวอย่างนี้การวาดเริ่มต้นที่ด้านล่าง@ไปทางขวาหนึ่งขึ้นไปวนรอบจนกว่าจะถึงตรงกลาง@และเสร็จสิ้น4rcส่วน จากนั้นซ้ำอีกสองครั้งเพื่อรับคำขอแบบเต็ม 3 ครั้ง โปรดทราบว่า4rc1จะเป็นเพียง 4x4 บล็อกซ้ายบนของตัวอย่างนี้

7u1 = เส้นผ่านศูนย์กลางของ 7 เริ่มต้นด้วยการขึ้นไปตามเข็มนาฬิกา 1 ครั้งที่เรียกซ้ำ (สังเกตว่าเป็นอินโทรเดียวกัน)

&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

การชนะและการ จำกัด

นี่คือ Code Golf คำตอบที่เล็กที่สุดเป็นหน่วยชนะ การส่งควรอยู่ในรูปแบบปกติของโปรแกรม / ฟังก์ชั่น / CJam Code Block / ฯลฯ ใช้ข้อ จำกัด ช่องโหว่มาตรฐาน คนขับมืออาชีพในหลักสูตรปิด หากการระคายเคืองยังคงอยู่ให้หยุดใช้และปรึกษาแพทย์ของคุณ

javascript, 578, 575, 553, 478, 377 ไบต์

หลังจาก Lua ที่พ่ายแพ้ฉันเปลี่ยนไปใช้ภาษาที่กะทัดรัดกว่าเดิมและย้ายการแข่งขันไปที่ Javascript:

s=function(w,d,c,r){d="dlur".indexOf(d)
j=i=G=H=I=J=w*r;o=[];for(x=0;x<J*2;x++){o[x]=[]
for(y=0;y<J*2;)o[x][y++]=' '}for(;r--;){a=d;m=l=z=1;o[i][j]="@"
for(k=w*w-1;k--;){G=G<i?G:i;H=H>i?H:i;I=I<j?I:j;J=J>j?J:j
o[i+=(1-a)%2][j+=a?a-2:0]=l++==m?(a+=c=="c"?3:1,m+=z=!z,l=1,"v<^>"[a%=4]):k?"|-"[a%2]:"&"}}for(i=G;i<=H;)console.log(o[i++].slice(I,J+1).join("").replace(/\s+$/g,''))}

อัลกอริทึมเหมือนกัน แต่เขียนด้วยภาษาที่กะทัดรัดมากขึ้นดังนั้นฉันจึงสามารถเอาชนะ Lisp ที่ชั่วร้ายได้ :)

แก้ไข: การเปลี่ยนแปลงโครงสร้างบางอย่างจำเป็นต้องเข้าถึงภายใต้เสียงกระเพื่อมอีกครั้งและเพื่อกำจัดช่องว่างต่อท้าย แต่เรามาที่นี่อีกครั้ง

แก้ไข 2: บทคัดย่อที่นำมาพิจารณาเพื่อรับต่ำกว่า 500 หวังว่ามันจะเพียงพอ :)

แก้ไข 3: ขอบคุณ @Timwi รหัสเป็นอีก 100 chars slimmer ฉันยังไม่ได้อัปเดตคำอธิบาย

การทดสอบ ( เวอร์ชันออนไลน์ทดสอบใน Chrome):

----| 2d4 |---
s.js:9 &@@@@
s.js:9 ^<<<<
ss.html:7 ----| 4rc3 |---
s.js:9 &--<
s.js:9 v-<|
s.js:9 |@^|<
s.js:9 >--^|
s.js:9  |@^|<
s.js:9  >--^|
s.js:9   |@^|
s.js:9   >--^
ss.html:9 ----| 7u1 |---
s.js:9 &>----v
s.js:9 ||>--v|
s.js:9 |||>v||
s.js:9 |||@|||
s.js:9 ||^-<||
s.js:9 |^---<|
s.js:9 ^-----<
ss.html:11 ----| 8r3 |---
s.js:9       >------v
s.js:9       |>----v|
s.js:9       ||>--v||
s.js:9       |||@v|||
s.js:9    >------v|||
s.js:9    |>----v|<||
s.js:9    ||>--v||-<|
s.js:9    |||@v|||--<
s.js:9 >------v|||
s.js:9 |>----v|<||
s.js:9 ||>--v||-<|
s.js:9 |||@v|||--<
s.js:9 ||^-<|||
s.js:9 |^---<||
s.js:9 ^-----<|
s.js:9 &------<
ss.html:13 ----| 8rc3 |---
s.js:9 &------<
s.js:9 v-----<|
s.js:9 |v---<||
s.js:9 ||v-<|||
s.js:9 |||@^|||--<
s.js:9 ||>--^||-<|
s.js:9 |>----^|<||
s.js:9 >------^|||
s.js:9    |||@^|||--<
s.js:9    ||>--^||-<|
s.js:9    |>----^|<||
s.js:9    >------^|||
s.js:9       |||@^|||
s.js:9       ||>--^||
s.js:9       |>----^|
s.js:9       >------^

และเพื่อความเป็นธรรมมีคำอธิบายที่เป็นธรรม:

s = function(w, d, c, r) {
    // width, direction, "c" as counter-clockwise and number of repetition
    // transfer direction to internal numerical representation
    d=d=="d"?0:d=="u"?2:d=="l"?1:3;
    // output strings
    x="v<^>"
    y="|-"
    // this is size of our canvas. Could be smaller, but this is shorter
    M = w * r * 2;
    // fill canvas with spaces to have something to build upon
    o = [];
    for (i = 0; i < M; i++) {
        o[i] = [];
        for (j = 0; j < M; j++)
            o[i][j] = ' '
    }
    // i,j is starting position
    // G,H,I,J are current boundaries (maximum and minimum values of i and j during the time)
    j = i = G = H = I = J = M / 2
    for (q = 0; q < r; q++) { // number of repeats
        a = d; // reset original direction
        // m is the expected length of side
        // l counts the of current side length
        m = l = 1;
        z = 0; // counts occurrences of the length
        o[i][j] = "@" // write initial character
        for (k = w * w; k > 1; k--) { // cycle over the whole spiral
            // update boundaries
            G = G < i ? G : i;
            H = H > i ? H : i;
            I = I < j ? I : j;
            J = J > j ? J : j;
            // move to the next position according to direction
            i+=a<3?1-a:0;
            j+=a>0?a-2:0
            if (k == 2) // we reached the end
                o[i][j] = "&"
            else if (l == m) {
                // we reached the corner so we need to count next direction
                a=(c=="c"?a+3:a+1)%4;
                // and write according sign
                o[i][j]=x[a]
                // first occurrence of this length
                if (z == 0)
                    z = 1; // wait for finish of the other
                else {
                    m++; // increase length of side
                    z = 0 // wait again for the first one
                }
                l = 1 // start the side counter over
            } else {
                l++ // another part of this side
                // according side character
                o[i][j] = y[a%2]
            }
        }
    }
    // blow it all out
    for (i = G; i <= H; i++)
        console.log(o[i].slice(I, J + 1).join("").replace(/\s+$/g, ''))
}

เสียงกระเพื่อมสามัญ 649 617 605 586 576 565 554 527 518

(lambda(r v z c &aux(m 0)s(c(if c 1 -1))o p(x 0)i(y 0)j u)(#8=dotimes(_ z)(#7=setf p(aref"ruld"v)i(1-(abs(- p 2)))j(- 1(abs(1- p)))s'@)(#8#($(1- r))#5=(#7#m(min m x)o(cons`(,x,y,s)o)s(aref"-|-|"p)x(+ x i)y(+ y j))#2=(#7#s(*(- c)j)j(* i c)i s p(mod(+ p c)4)s(aref">^<v"p)u(#8#(_(1+ $))#5#))#2#))(#7#s'& u #5#o(#4=stable-sort(#4#o'< :key'car)'> :key'cadr)y(cadar o)x m)(dolist(k o)(do()((>=(cadr k)y))(#7#y(1- y)x m)(terpri))(do()((<=(car k)x))#9=(incf x)(princ" "))(and(=(cadr k)y)(=(car k)x)#9#(princ(caddr k)))))

การทดสอบทั้งหมดยังคงผ่าน ฟังก์ชั่นที่ไม่ได้รับการปรับปรุงได้รับการปรับปรุงเพื่อให้สอดคล้องกับการเปลี่ยนแปลงเช่นเดียวกับความคิดเห็น ในที่สุดฉันก็กำจัดremove-duplicatesเพื่อย่อรหัส แต่ตอนนี้ฉันไม่ทราบว่าจะหาไบต์เพิ่มเติมได้ที่ไหน ทำได้ดีมาก

ตัวอย่าง

(funcall *fun* 8 #\r 3 nil)

      >------v
      |>----v|
      ||>--v||
      |||@v|||
   >------v|||
   |>----v|<||
   ||>--v||-<|
   |||@v|||--<
>------v|||
|>----v|<||
||>--v||-<|
|||@v|||--<
||^-<|||
|^---<||
^-----<|
&------<

(funcall *fun* 8 #\r 3 t) ;; counter-clockwise

&------<
v-----<|
|v---<||
||v-<|||
|||@^|||--<
||>--^||-<|
|>----^|<||
>------^|||
   |||@^|||--<
   ||>--^||-<|
   |>----^|<||
   >------^|||
      |||@^|||
      ||>--^||
      |>----^|
      >------^

(funcall *fun* 7 #\u 1 nil)

&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

(funcall *fun* 2 #\d 4 nil)

&@@@@
^<<<<

ดูเพิ่มเติม20lc10(pastebin)

Ungolfed

ไม่มีการสอบถามซ้ำที่นี่เพียงวิธีกราฟิก Turtle แบบพื้นฐานพร้อมลูป:

1. วาดเกลียวในหน่วยความจำโดยเก็บ(x y char)อเนกประสงค์ไว้ในกอง
2. องค์ประกอบเรียงลำดับตามyและx
3. ทำซ้ำในรายการนั้นขณะที่หลีกเลี่ยงการซ้ำซ้อน (ร่องรอยก่อนหน้า) และพิมพ์จากบนซ้ายไปขวาล่าง

(lambda
    (r v z c
     &aux
       (m 0)       ; minimal x
       s           ; symbol to print (a character)
       (c          ; 1 if clockwise, -1 otherwise
        (if c
            1
            -1))
       o           ; stack of (x y char) traces
       p           ; position of s in ">^<v"
       i           ; move direction of x
       j           ; move direction of y
       (x 0)       ; position in x
       (y 0)       ; position in y
       u           ; auxiliary variable
       )
  ;; repeat for each recursive step
  (dotimes (_ z)
    ;; initialize spiral parameters
    (setf s '@            ; start spiral with @
          p (position v"ruld") ; initialize p according to input V

          ;; Set initial direction in I and J.
          i (1-(abs(- p 2))) ; i(0..3) = ( 1, 0, -1, 0 )
          j (- 1(abs(1- p))) ; j(0..3) = ( 0, 1, 0, -1 )

    ;; Iterate with increasing diameter $. For each iteration, draw a
    ;; "L"-shape that extends previous shape. Here is roughly what
    ;; happens at each step:
    ;;
    ;;   3334
    ;;   3124
    ;;   3224
    ;;   4444
    ;;
    (dotimes($(1- r))

      ;;
      ;; Assign the form to the reader variable #1# in order to
      ;; copy-paste later. This is like declaring a local function,
      ;; but shorter: push trace into list O and move forward.
      ;;
      #1=(setf m (min m x)
               o (cons `(,x ,y ,s) o)
               s (aref "-|-|" p)
               x (+ x i)
               y (+ y j))

      ;;
      ;; Helper function #2#: rotate and draw a line of length $.
      ;;

      #2=(setf u (* (- c) j) ; rotation as a vectorial                   
               j (* i c)     ; product of (i j 0) with (0 0 c).
               u i           ; At first I used PSETF, but now I reuse
                             ; the existing SETF with an auxiliary 
                             ; variable U to shorten the code and get
                             ; rid of PROGN. That's also why I affect
                             ; the result of DOTIMES to U (no need
                             ; for two forms and a PROGN, just SETF).

               p (mod(+ p c)4)   ; ">^<v" is sorted counter-clockwise, which 
               s (aref ">^<v" p) ; means that adding P and C (modulo 4) gives 
                                 ; the next symbol after rotation.

               ;; trace a line by repeatedly invoking code snippet #1#
               u (dotimes(_(1+ $)) #1#))
      ;; 
      ;; Rotate and draw a second line, hence drawing a "L"-shape.
      ;;
      #2#))

  ;; Finally, draw the final symbol &
  (setf s '&)
  #1#

  (setf o

        ;; From inside-out:
        ;;
        ;; - stable sort O according to X
        ;;   (from lowest (left) to highest (right))
        ;;
        ;; - stable sort the result according to Y
        ;;   (from highest (top) to lowest (bottom))
        ;;
        (stable-sort (stable-sort o '< :key 'car) '> :key 'cadr)

        ;; initialize Y with the first Y in O, which is also the
        ;; minimum of all Y.
        y (cadar o)

        ;; initialize X with the minimum of all X
        x m) 

  ;; For each trace in O
  (dolist (k o)

    ;; Add as many lines as needed to advance Y to current trace's Y.
    (do ()
      ((<= y (cadr k)))
      (setf y (1- y)
            x m)
      (terpri))

    ;; Add as many spaces as needed to advance X to current trace's X.
    (do () ((>= x (car k))) (incf x) (princ " "))

    ;; Then, print current trace's character and increment X.
    ;; This happens only when we have a "new" trace, not another
    ;; trace at the same point (which was being overwritten).
    (and(=(car k)x)(=(cadr k)y)(incf x)(princ(caddr k)))

Lua 5.2, 740 Bytes

s=io.read W=io.write Z=math.max A=math.min
D="d"U="u"L="l"R="r"function n()G=A(G,i)H=Z(H,i)I=A(I,j)J=Z(J,j)i=(a==D and i+1 or a==U and i-1 or i)j=(a==R and j+1 or a==L and j-1 or j)end
w=s"*n"d=s(1)c=s(1)r=(c=="c")and s"*n"or c
c=c=="c"M=w*(r+1)o={}for i=1,M do o[i]={}for j=1,M do o[i][j]=" "end end
i=M/2 j=i G=i H=i I=i J=i
for q=1,r do a=d m=1 l=1 z=0
o[i][j]="@"for k=3,w^2 do
n()if l==m then
a=c and(a==D and R or a==U and L or a==L and D or a==R and U)or(a==D and L or a==U and R or a==L and U or a==R and D)o[i][j]=(a==D and"v"or a==U and"^"or a==L and"<"or a==R and">")
if z==0 then z=1 else m=m+1;z=0 end
l=1
else
l=l+1
o[i][j]=(a==D or a==U)and"|"or"-"end end
n()o[i][j]="&"end
for i=G,H do for j=I,J do
W(o[i][j])end W("\n")end

ฉันคิดว่ามันคงจะสนุกถ้าได้ลองใช้อัลกอริทึมเพื่อเอาชนะ Lisp แต่ Lua อาจไม่ใช่ตัวเลือกที่ดีที่สุด ฉันใช้เวลากับมันมากเกินไปทำให้บางส่วนมีปัญหามากเกินไปจนจบด้วยการใช้งานที่น่ารำคาญ แต่วิธีแก้ปัญหาการทำงาน อาจเป็นไปได้ว่าฉันจะลองใช้ภาษาอื่นในภายหลังเพื่อเอาชนะ Lisp เนื่องจากมี 90 ตัวอักษรที่ฉันไม่สามารถนำออกจากอัลกอริทึมนี้ได้

ผลการทดสอบ:

jakuje@E6430:/tmp$ echo "2d4" | lua s.lua 
&@@@@
^<<<<
jakuje@E6430:/tmp$ echo "4rc3" | lua s.lua 
&--<  
v-<|  
|@^|< 
>--^| 
 |@^|<
 >--^|
  |@^|
  >--^
jakuje@E6430:/tmp$ echo "7u1" | lua s.lua 
&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

PHP, 524 ไบต์

ฉันมาสายในงานปาร์ตี้นี้ โซลูชัน PHP ของฉันไม่ใช่ขนาดที่เล็กที่สุดและฉลาดที่สุด มันใช้งานได้

$a=$argv;
$b=[['|','^',0,-1],['-','>',1,0],['|',v,0,1],['-','<',-1,$x=$y=$o=$p=$q=$r=0]];
for($t=$a[4];$t;$t--){$d=strpos(urdl,$a[2]);$c=$b[$d];$m[$y][$x]='@';
for($s=0;++$s<$a[1];){for($k=3;--$k;){for($i=$s;--$i;)
$m[$y+=$c[3]][$x+=$c[2]]=$c[0];$x+=$c[2];$y+=$c[3];$c=$b[$d=($d+($a[3]==c?3:1))%4];
$m[$y][$x]=$c[1];}$o=min($x,$o);$p=max($p,$x);$q=min($y,$q);$r=max($r,$y);}
for($i=$s;--$i;)$m[$y+=$c[3]][$x+=$c[2]]=$c[0];$m[$y][$x]='&';}
for($y=$q;$y<=$r;$y++){$l='';for($x=$o;$x<=$p;$x++)$l.=$m[$y][$x]?:' ';
echo rtrim($l)."\n";}

วิธีเรียกใช้:

$ php -d error_reporting=0 recursive-ascii-spirals.php 4 r c 3
&--<
v-<|
|@^|<
>--^|
 |@^|<
 >--^|
  |@^|
  >--^
$ php -d error_reporting=0 recursive-ascii-spirals.php 7 u '' 1
&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

รุ่นรายละเอียดที่มีการทดสอบคำอธิบายและสินค้าอื่น ๆ สามารถพบได้บนGitHub