วันนี้คุณทำงาน: วาดเส้นโค้งมังกร!

ในกรณีที่คุณไม่ทราบว่า Dragon Curve คืออะไรนี่เป็นวิดีโอแนะนำ ViHart (เจ๋งจริง ๆ โปรดดู!)

งานของคุณ: วาดรูปโค้งมังกรซ้ำอย่างน้อย 9 ครั้ง คุณไม่จำเป็นต้องแสดงการวนซ้ำตั้งแต่ 1 ถึง 9 คุณเพียงแค่ต้องแสดงกราฟโค้งสุดท้ายที่เกิดขึ้นหลังจากการทำซ้ำ 9 ครั้ง (อย่างน้อย) เส้นโค้งต้องวาดเป็นเส้นตรงที่เชื่อมต่อจุดต่างๆบนเส้นโค้ง ผลลัพธ์ควรตรงกับหนึ่งในภาพด้านล่างที่แสดงการวนซ้ำ 9 ครั้งขึ้นไป (มากถึงการสะท้อนการหมุนการปรับสเกลและการแปรผันของความกว้างของเส้นสีของเส้นและสีพื้นหลัง) ผลลัพธ์ของคุณจะต้องมีขนาดใหญ่พอที่แต่ละบรรทัดและ "กล่อง" ที่รูปแบบสามารถแยกออกจากกันได้ หากสองบรรทัดไม่ตัดกันในส่วนโค้งพวกเขาไม่ควรใช้พิกเซลเดียวกันหรือพิกเซลที่อยู่ติดกันในเอาต์พุต (ควรมีอย่างน้อยหนึ่งพิกเซลของพื้นหลังที่มองเห็นได้ระหว่างพวกเขา) คุณสามารถแสดงภาพไปที่หน้าจอหรือบันทึกภาพเป็นไฟล์ได้ ผลลัพธ์จะต้องเป็นกราฟิก - มันไม่สามารถเป็นศิลปะ ASCII ได้

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะแต่รวมถึงคำสั่งสำหรับไลบรารีไม่ควรรวมอยู่ในจำนวนไบต์และคุณสามารถใช้ไลบรารีกราฟิกหรือไลบรารีอื่น ๆ ที่เขียนขึ้นสำหรับภาษาที่คุณเลือกหากถูกเขียนก่อนการโพสต์

โปรดรวมภาพของผลลัพธ์ของโปรแกรมของคุณ

ข้ามย่อหน้านี้หากคุณดูวิดีโอ:สำหรับคนที่ตัดสินใจไม่ดูวิดีโอจะมีการแสดง 12 รอบแรกของเส้นโค้งมังกรตามด้านล่าง สำหรับวัตถุประสงค์ของงานนี้เส้นโค้งมังกรเป็นเส้นโค้งที่สร้างโดยกฎต่อไปนี้: ใช้จุดสิ้นสุดของเส้นโค้งปัจจุบันสร้างเส้นโค้งที่สองหมุน 90 องศารอบจุดสิ้นสุดนั้นเพื่อให้จุดสิ้นสุดของต้นฉบับ เส้นโค้งเป็นจุดเริ่มต้นของเส้นโค้งใหม่และเข้าร่วมทั้งสองโค้งเป็นโค้งเดียวที่พวกเขาพบ ในภาพที่แสดงด้านล่างการทำซ้ำใหม่แต่ละครั้งจะถูกสร้างขึ้นโดยการหมุนการทำซ้ำก่อนหน้า 90 องศานาฬิกาฉลาดรอบจุดสิ้นสุดแต่ละการทำซ้ำ เมื่อเส้นโค้งแสดงบนหน้าจอไม่ชัดเจนว่าจุดสิ้นสุดใดที่นับว่าเป็น "จุดสิ้นสุด" อย่างไรก็ตามเมื่อเส้นโค้งถูกเก็บเป็นอาร์เรย์ของจุดทำให้ง่ายต่อการกำหนด "จุดปลาย" เป็นจุดสุดท้ายใน อาร์เรย์

ชื่นชมศิลปะ ASCii แต่ไม่ยอมรับ: นี่เป็นเอาต์พุตกราฟิกไม่ใช่ ASCII Art

x86, MSDOS, 16 ไบต์

เมื่อไม่นานมานี้ฉันได้เขียนเรื่องนี้ขึ้นมาเพื่อให้ความรู้เกี่ยวกับขั้นตอนที่เล็กที่สุดสำหรับการผลิตเศษส่วนมังกร มันไม่ใช้การวนซ้ำจริง ๆ แต่จะพล็อตพิกเซลทุกจุดที่มีอยู่ภายในแฟร็กทัลโดยตรงแสดงภาพสุดท้าย มันมาพร้อมกับโปรดักชั่นเล็ก ๆ มากมายในชุดนี้ เวอร์ชัน 16 ไบต์เป็นจุดสิ้นสุดของความพยายามของฉันในการทำให้เศษส่วนมังกรเล็กที่สุดเท่าที่จะเป็นไปได้เริ่มต้นปี 2014 ด้วยการผลิต 32 ไบต์นี้

แม่มด

14 10 19 CA D1 FA 10 DE 01 D1 CD 10 B4 0C EB F0

รหัส

S: 
adc al,0x10
sbb dx,cx       
sar dx,0x01 
adc dh,bl
add cx,dx
int 0x10
mov ah,0x0C
jmp short S

Python 2/3, 169 167 150 111 98 78 Bytes

โปรดทราบว่าการนำเข้าไม่รวมอยู่ในจำนวนไบต์ตามข้อมูลจำเพาะของความท้าทาย

ขอบคุณ @AlexHall สำหรับการบันทึก 39 (!) ไบต์และ @ nedla2004 สำหรับอีก 13

from turtle import*
o=[90]
for z in o*9:o+=[90]+[-x for x in o[::-1]]
fd(5)
for i in o:rt(i);fd(5)

เริ่มต้นด้วยการสร้างรายการหรือขวา (90) และเลี้ยวซ้าย (-90) จากนั้นผ่านรายการและย้ายเต่า

สร้างผลลัพธ์:

แก้ไข: ในกรณีนี้คือน่าเบื่อเกินไปดูเกินไปเพิ่มก่อนมีสิทธิก่อนspeed(0) fd(5)มันจะวิ่งเหมือนเดิมยกเว้นเต่าจะเคลื่อนที่เร็วกว่ามาก

โลโก้ขนาด 43 ไบต์

for[i 1 512][fd 9 lt :i/(bitand :i -:i)*90]

ลองใช้ล่ามที่http://www.calormen.com/jslogo/#

นี่ใช้หลักการเดียวกับคำตอบศิลปะ ASCII ก่อนหน้าของฉันและสูตรที่วิกิพีเดียยกเว้นว่าฉันกลับทิศทางเพื่อให้ตรงกับภาพในคำถาม:

ก่อนอื่น express n ในรูปแบบk*(2^m)ที่ k เป็นจำนวนคี่ ทิศทางของเทิร์นที่ n ถูกกำหนดโดย k mod 4 นั่นคือส่วนที่เหลือทางซ้ายเมื่อ k ถูกหารด้วย 4 หาก k mod 4 เป็น 1 ดังนั้นเทิร์นที่ n คือR L; ถ้า k mod 4 เป็น 3 ดังนั้นเทิร์นที่ n คือL R

bitand :i -:iiพบบิตอย่างมีนัยสำคัญน้อย เราหารiสิ่งนี้เพื่อแบ่งiจำนวนที่ต้องการให้จำนวนที่kต้องการ ไม่จำเป็นต้องแยกแยะระหว่างเลี้ยวซ้ายและขวา เราแค่เลี้ยวซ้ายทีละk*90องศาและพึ่งพาความจริงที่ว่าการหมุนเป็นโมดูโล 360 operaton เพื่อทำการโมดูโลสำหรับเรา

เอาท์พุต

ใช้htเพื่อซ่อนเต่าหากจำเป็น

เอาท์พุท (แก้ไข)

ต่อไปนี้แสดงให้เห็นว่าเส้นโค้งเป็นเส้นเดี่ยว

bk 6 for[i 1 512][fd 6 rt :i/(bitand :i -:i)%4*45-90 fd 3 rt :i/(bitand :i -:i)%4*45-90]

LindenMASM , 51 ไบต์

LindenMASM เป็นภาษาที่ฉันสร้างขึ้นมาเพื่อความท้าทายเมื่อไม่นานมานี้ที่จะมีชีวิตอยู่ใน Sandbox ตลอดไป มันใช้ประโยชน์จากแนวคิดของระบบ Lindenmayerในการวาดสิ่งต่าง ๆ เช่นเส้นโค้งมังกรพืชเศษส่วนสามเหลี่ยม Sierpinski เป็นต้น

ซอร์สโค้ดมีดังนี้:

STT
AXI FX
INC 9
SET F 0
RPL X X+YF+
RPL Y -FX-Y
END

หากต้องการตั้งค่านี้n = 6สำหรับตัวอย่าง:

STT
AXI FX
INC 6
SET F 0
RPL X X+YF+
RPL Y -FX-Y
END

สิ่งนี้สร้างภาพต่อไปนี้ผ่านทาง Python 3 turtle:

อาจมีความแตกต่างเล็กน้อยในการคำนวณซ้ำในระบบ Lindenmayer การทำซ้ำครั้งแรกเป็นบรรทัดเดียว นี่คือสิ่งที่ดูเหมือนว่าn = 10:

เพื่อความสนุกนี่คือสิ่งที่ดูเหมือนกับ 15 รุ่น (พร้อมคำแนะนำเพิ่มเติมMOV 2เพื่อให้เล็กลงเล็กน้อย):

เมื่อคุณได้รับมากถึง 20 รุ่น (ด้วยMOV 0.5) คุณจะไม่เห็นเส้นอีกต่อไปจริงๆและใช้ขั้นตอนมากมายในการสร้าง (คู่+-และ-+ไม่ได้รับการปรับให้เหมาะสม) นี่คือสิ่งที่คุณจะได้รับ:

^{โปรดทราบว่าล่ามปัจจุบันอาจแสดงปัญหากราฟิกสำหรับรุ่นจำนวนน้อยเช่นอาจไม่ได้วาดไปที่หน้าจอ โชคไม่ดีเมื่อล่ามนี้ถูกสร้างขึ้นไม่มีปัญหาการเปลี่ยนแปลงที่เป็นไปได้ใน Python 3 อาจทำให้เกิดสิ่งนี้หรืออาจเป็นเพียงระบบของฉัน}

อันเดอร์, 196 ไบต์

()()(<svg width="99" height="147">)S(<g transform="translate):S((33,33)">)S((3,0)rotate)*a(*a(~*)*~("><path d="M0h3" stroke="#"/>)~*a(*)**:(-90)a~^~(90)a~^)*::*:**:*^S(</g>)(:*)::*:**:*^S(</svg>)S

ฉันคิดว่ามันน่าสนใจที่จะลองความท้าทายนี้ใน esolang ที่ใช้พลังงานต่ำ Underload ทำได้ค่อนข้างดีสำหรับภาษาที่มีคำสั่งจำนวนน้อย

เอาต์พุตเป็นไฟล์ SVG ที่มีแท็กที่ซ้อนกันสูงมากและช็อตคัทกอล์ฟ จนถึงตอนนี้ฉันยังไม่พบเบราว์เซอร์ที่สามารถแสดงได้ (Firefox ค้างเป็นเวลาหลายนาทีพยายามโหลดมันและทั้ง Firefox และ Chromium ให้หน้าจอว่าง) โปรแกรมประมวลผลภาพส่วนใหญ่ไม่สามารถโหลดได้ (ทำให้ยากที่จะแปลงเป็นรูปแบบอื่น) แต่ฉันจัดการโหลดมันใน Eye Viewer Gnome (ซึ่งเป็นส่วนหนึ่งของการติดตั้งเริ่มต้นบน Ubuntu) ดังนั้นฉันจึงถ่ายภาพหน้าจอของภาพเพื่อที่คุณจะได้เห็น (ภาพจริงมีพื้นหลังโปร่งใส แต่คุณไม่สามารถจับภาพหน้าจอที่โปร่งใสจริง ๆ ):

เราจำเป็นต้องระบุขนาดภาพอย่างชัดเจน การเลือกทิศทางที่เหมาะสมสำหรับภาพวาดทุกอย่างขนาดตามกฎหมายขั้นต่ำและทำจำนวนขั้นต่ำของการทำซ้ำโดยระบุความท้าทายที่ทำให้เรามีภาพที่เพียงแค่พอดีเข้าไป 99 พิกเซลกว้างประหยัดไบต์ มันดีเมื่อสิ่งต่าง ๆ เป็นไปอย่างนั้น

อัลกอริทึมทั่วไปที่ใช้สำหรับการวาดภาพคือการรักษาสองตัวแปร (อันเดอร์โหลดไม่ได้ตั้งชื่อตัวแปร แต่ฉันคิดว่าพวกเขาเป็นxและy ) ทั้งคู่เริ่มว่างเปล่า จากนั้นเราแทนที่ ( x , y ) ด้วยซ้ำ ๆ( x , เลี้ยวซ้ายและก้าวไปข้างหน้า, y ) และ ( x , เลี้ยวขวาและก้าวไปข้างหน้า, y ) หลังจากการทำซ้ำสิบครั้งทั้งxและyจะมีส่วนโค้งมังกรเก้าซ้ำ

มีการเพิ่มประสิทธิภาพขนาดเล็กและเทคนิคเฉพาะ Underload เช่นกัน เพื่อหลีกเลี่ยงการสับสนมากเกินไปกับด้านบนของสแต็คแต่ละรอบวนซ้ำเราเริ่มต้นด้วยการรวมxและyในฟังก์ชั่น "คืนสตริงที่สร้างขึ้นโดยการเชื่อมต่อ: x , คำสั่งเทิร์นอาร์กิวเมนต์ของฟังก์ชั่น การเรียนการสอนไปข้างหน้าและy . " ฟังก์ชั่นนี้ใช้พื้นที่เพียงหนึ่งเดียวบนสแต็กดังนั้นเราจึงสามารถทำซ้ำเรียกมัน-90ว่าเป็นอาร์กิวเมนต์เปลี่ยนค่าส่งคืนภายใต้ซ้ำและเรียกมัน90ว่าเป็นอาร์กิวเมนต์เพื่อรับค่าใหม่สำหรับxและyโดยไม่จำเป็นต้องสัมผัสมากกว่าสององค์ประกอบบนสุดของสแต็ก (ซึ่งเป็นสิ่งที่เข้าถึงได้ทั่วไปมากที่สุด) ฟังก์ชั่นนี้สร้างจากโค้ดในขณะใช้งาน เครื่องกำเนิดไฟฟ้าเองก็สร้างรหัสในรันไทม์เพื่อให้มันสามารถใช้สตริง<g transform="translateที่ใช้ในการตั้งค่าที่มาของภาพ เราสร้างแท็กเปิดทั้งหมดก่อนแล้วเพราะแท็กปิดทั้งหมดเป็นเพียงแค่</g>เราสามารถส่งออกแท็กปิด 1024 โดยเพียงแค่ทำซ้ำสตริงโดยไม่ต้องกังวลเกี่ยวกับการจับคู่กับแท็กเปิด (การเขียนตัวเลขอย่างมีประสิทธิภาพใน Underload เป็นปัญหาที่น่าสนใจในสิทธิของตนเอง; (:*)::*:**:*อาจเป็นวิธีที่มีประสิทธิภาพที่สุดในการเขียน 1024 แม้ว่าการแปลเป็น "2 สู่พลังของ (1 + 2 × 2) × 2"

อันเดอร์โหลดไม่มีไลบรารีกราฟิกใด ๆ ดังนั้นฉันจึงสร้าง SVG โดยใช้การรวมกันของการวาดเส้นในตำแหน่งคงที่และหมุนภาพไปรอบ ๆ จุดที่กำหนด แทนที่จะหันปากกาเราก็พลิกกระดาษ แนวคิดก็คือการวาดเส้นหมุนภาพทั้งหมดวาดเส้นอื่นหมุนภาพอีกครั้ง ฯลฯ เราสามารถจำลองภาพเต่าได้อย่างมีประสิทธิภาพโดยไม่ต้องใช้เลขคณิตหรือใช้ไลบรารีกราฟิกใด ๆ เนื่องจากวาดทุกบรรทัด ในตำแหน่งเดียวกัน แน่นอนนั่นหมายความว่าเรามีแท็กหมุนภาพซ้อนกันอย่างมากซึ่งทำให้ผู้ดู SVG หลายคนสับสน

การจัดแต่งทรงผมของภาพจะนับรวมกับจำนวนไบต์ดังนั้นฉันจำเป็นต้องกำหนดสไตล์ขั้นต่ำที่จำเป็นในการแสดงภาพ สิ่งนี้กลายเป็นstroke="#"สิ่งที่มากหรือน้อยแปลว่า "เส้นต้องมีสี"; ดูเหมือนว่าจะขยายออกไปวาดเป็นสีดำ (โดยปกติคุณจะต้องระบุสีเหมือนพูดว่า "# 000") พื้นหลังโปร่งใสโดยค่าเริ่มต้น เราไม่ได้ระบุความกว้างของเส้นขีด แต่ตัวเลือกที่เลือกโดย Eye of Gnome ทำให้ทุกอย่างมองเห็นได้

ล่าม Underload จำนวนมากต่อสู้กับโปรแกรมนี้เช่นที่เกิดปัญหากับ Try It Online เพราะมันสร้างสตริงที่มีขนาดใหญ่มากภายใน อย่างไรก็ตามล่ามออนไลน์ Underloadทำงาน (ที่น่าสนใจคือล่ามตัวแรกที่ออนไลน์ดังนั้นภาษานั้นสามารถใช้ได้ออนไลน์ก่อนที่มันจะใช้งานออฟไลน์ได้)

บางสิ่งที่ฉันไม่สบายใจเล็กน้อยเกี่ยวกับว่าดูเหมือนจะมีเพียง 1023 ส่วนของเส้นตรงและเราคาดหวังว่าจะ 1024 วาดในการทำซ้ำครั้งถัดไปแทน) หากการตัดสิทธิ์นั้นอาจเป็นไปได้ที่จะปรับโปรแกรม แต่อาจจบลงได้นานกว่ามาก (ไม่เหมือนความท้าทายนี้ที่จะชนะการแข่งขันอย่างไรก็ตามมีหลายรายการที่สั้นกว่า)

MATL , 26 ไบต์

0J1_h9:"tPJ*h]hYsXG15Y01ZG

หากยอมรับสเกลที่แตกต่างกันในสองแกนจะสามารถลดรหัสได้ถึง 19 ไบต์:

0J1_h9:"tPJ*h]hYsXG

ตัวเลขด้านล่างสอดคล้องกับรุ่นสเกล (26- ไบต์) ที่เท่ากัน

รหัสด้านบนสร้างการวนซ้ำที่ 9 (อิงตาม 0) นั่นคือรูปที่สิบในการท้าทาย:

สำหรับค่าอื่น ๆ ให้เปลี่ยน9รหัสหรือแทนที่ด้วยiเพื่อรับหมายเลขเป็นอินพุตของผู้ใช้ ตัวอย่างเช่นผลลัพธ์13คือ:

คำอธิบาย

สิ่งนี้ใช้การวนซ้ำเพื่อสร้างอาร์เรย์ของขั้นตอนตามด้วยเส้นโค้งในระนาบเชิงซ้อน ตัวอย่างเช่นสองขั้นตอนแรกคือ1j(ขึ้น) และ-1(ซ้าย)

ในการวนซ้ำแต่ละครั้งอาร์เรย์ของขั้นตอนจะถูกคัดลอก สำเนาของอาร์เรย์จะย้อนกลับ , คูณโดย1j(เพื่อหมุน 90 องศา) และตัดแบ่งไปที่เดิม

หลังจากวนลูป, ผลรวมสะสมของขั้นตอนจะให้คะแนนจริงซึ่งจะถูกพล็อตในระนาบเชิงซ้อน

0                          % Push 0
 J1_h                      % Push array [1j, -1]. This defines the first two steps
     9:                    % Push [1, 2, ..., 9]
       "                   % For each
        t                  %   Duplicate the array of steps so far
         P                 %   Reverse
          J*               %   Multiply by 1j
            h              %   Concatenate horizontally to previous steps
             ]             % End
              h            % Concatenate with the initial 0
               Ys          % Cumulative sum
                 XG        % Plot. Complex numbers are plotted with real and imag as x and y
                   15Y0    % Push string 'equal'
                       1ZG % Set equal scale in the two axes

Mathematica 86 ไบต์

{1,-1}
r=Reverse;Graphics@Line@Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]

วิธีการทำงาน: เอาท์พุท{1,-1} {1,-1}มันเป็นพื้น "ผลักมันไปที่กองซ้อน" %ค่านี้สามารถถูกเรียกคืนด้วย r=Reverseเพียงแค่เปลี่ยนชื่อฟังก์ชั่น Reverse เพราะฉันใช้สองครั้งในรหัส Graphics@Line@ใช้เวลาเพียงรายการของจุดและวาดเส้นเชื่อมต่อพวกเขา Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]เนื้อแท้จริงของปัญหาที่เกิดขึ้นในส่วนของรหัสนี้: Lemme บอกคุณ - ส่วนนั้นซับซ้อนเหมือน f ****** ck นี่คือสิ่งที่Nestไม่: Nest[f,x,9]outputs f[f[f[f[f[f[f[f[f[x]]]]]]]]]ผลมาจากการโทร

ในรหัสของฉันอาร์กิวเมนต์แรกนี้fคือ: Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&อาร์กิวเมนต์ที่สองxคือ{{0,0},%}(ซึ่งประเมินค่า{{0,0},{1,-1}}) และอาร์กิวเมนต์ที่สามคือnซึ่งเป็นเพียง 9 (ซึ่งจะใช้อาร์กิวเมนต์แรกกับอาร์กิวเมนต์ที่สอง 9 ครั้ง)

ส่วนที่ซับซ้อนที่สุดของทั้งหมดคืออาร์กิวเมนต์แรก: Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&ซึ่งเป็นระเบียบยักษ์ของน้ำตาล syntactic บริสุทธิ์เกือบ ฉันถูกจริงๆเหยียดหยามน้ำตาลประโยค Mathematica สำหรับคนนี้ บรรทัดของรหัสนั้นแสดงถึงฟังก์ชั่นนิรนามของ mathematica ยกเว้นเพื่อย่อสิ่งที่ฉันกำหนดไว้สองฟังก์ชั่นนิรนามแยกต่างหากภายในฟังก์ชั่นนิรนามนั้น ใช่คนนั้นถูกกฎหมาย มาทำลายมันกันเถอะ

Joinใช้เวลาสองข้อโต้แย้ง ที่แรกก็คือและที่สองคือl=Last@#;h=#-l&/@#r[r@#%&/@h]

อาร์กิวเมนต์แรกของการเข้าร่วม:ภายในฟังก์ชั่นที่ไม่ระบุชื่อ "main" #เป็นรายการของคะแนนทั้งหมดที่ทำซ้ำในโค้งปัจจุบัน ดังนั้นl=Last@#;หมายถึง "รับจุดในรายการจุดที่คุณได้รับเป็นอินพุตและกำหนดจุดนั้นให้กับตัวแปรlส่วนถัดไปh=#-l&/@#มีความซับซ้อนมากกว่าเล็กน้อยนั่นหมายความว่า" คุณมีฟังก์ชั่น ฟังก์ชั่นนี้ใช้จุดเป็นอินพุต, ลบออกlจากมันและส่งกลับผลลัพธ์ ตอนนี้ใช้ฟังก์ชั่นที่ทุกองค์ประกอบในรายการของจุดที่คุณได้รับเป็น input hเพื่อสร้างรายการของจุดเปลี่ยนและกำหนดว่ารายการใหม่เพื่อตัวแปร

อาร์กิวเมนต์ที่สองของ Join: r[r@#%&/@h]มีไวยากรณ์ที่ซับซ้อนที่สุดที่ฉันเคยเขียน ฉันไม่อยากจะเชื่อเลยว่าส่วนของรหัสใด ๆ ที่มีสิ่งที่คล้าย@#%&/@- ดูเหมือนว่าฉันสาปแช่งเหมือนตัวการ์ตูนในช่วงกลางของโปรแกรม! แต่เป็นไปได้ที่จะทำลายมันลง ข้อควรจำ - r[x]ใช้รายการของคะแนนและส่งคืนรายการนั้นในลำดับย้อนกลับ r@#%&เป็นฟังก์ชั่นนิรนามที่ย้อนกลับอินพุตจากนั้นคูณด้วยค่าที่เก็บไว้%(ซึ่งคือ{1,-1}) และส่งคืนผลลัพธ์ โดยทั่วไปแล้วมันจะหมุนเป็นอินพุต 90 องศา แต่ในรหัสสั้นที่สุดเท่าที่ฉันจะเขียน จากนั้นr@#%&/@hหมายถึง "เอาท์พุทรายการใหม่นั่นคือทุกจุดในการhหมุน 90 องศา"

โดยรวมแล้วJoin[l=Last@#;h=#-l&/@#,r[r@#*%&/@h]]&เป็นฟังก์ชั่นที่รับรายการคะแนนเป็นอินพุทและเพิ่มในรายการของจุดเดิมที่หมุน 90 องศาเพื่อให้เกิดการวนซ้ำครั้งถัดไป ทำซ้ำ 9 ครั้งเพื่อให้ได้เส้นโค้งมังกร จากนั้นรายการคะแนนที่ได้จะถูกลากไปยังหน้าจอเป็นบรรทัด และผลลัพธ์:

Python 2, 43 ไบต์

คำตอบนี้คือ 43 ไบต์ไม่รวมคำสั่งนำเข้าและส่วนใหญ่จะขึ้นอยู่กับคำตอบโลโก้ของ Level River Stและการใช้งานi/(i&-i)ในรหัสของพวกเขา ลองออนไลน์ได้ที่ trinket.io

from turtle import*
for i in range(1,513):fd(9);rt(90*i/(i&-i))

นี่คือรูปภาพของผลลัพธ์

Mathematica, 56 55 ไบต์

Graphics@Line@AnglePath[Pi/2JacobiSymbol[-1,Range@512]]

คำอธิบาย: OEIS A034947

เพื่อความสนุกนี่คือการทำซ้ำครั้งที่ 19 ในรูปแบบสี

Mathematica, 63 ไบต์

การใช้ AnglePath

Graphics@Line@AnglePath[Pi/2Nest[Join[#,{1},-Reverse@#]&,{},9]]

HTML + JavaScript, 182

<canvas id=C></canvas><script>c=C.getContext("2d")
C.width=C.height=400
s=n=9
x=y=200
for(i=d=0;i<=1<<n;d+=++i/(i&-i))
c.lineTo(x,y),
d&1?y+=d&2?s:-s:x+=d&2?-s:s
c.stroke()</script>

Haskell + ไดอะแกรม, 179 ไบต์

import Diagrams.Prelude
import Diagrams.Backend.SVG
d 1=hrule 1<>vrule 1
d n=d(n-1)<>d(n-1)#reverseTrail#rotateBy(1/4)
main=renderSVG"d"(mkWidth 99)$strokeT(d 9::Trail V2 Double)

เอาต์พุตเป็นไฟล์ svg ที่มีความกว้าง 99 พิกเซลพร้อมพื้นหลังโปร่งใส (ภาพที่มีขนาด 9 พิกเซลจะมีความหนาเกินกว่าที่จะทำการคำนวณใหม่ได้) ที่นี่มีการลดขนาดและประกอบไปด้วยพื้นหลังสีขาว:

tosh , 518 ไบต์

tosh เป็นรอยขีดข่วนแต่มีข้อความแทนที่จะเป็นบล็อก ที่ 518 ไบต์คำตอบนี้อาจเลวร้ายยิ่งกว่า Java

คำตอบนี้ใช้ตรรกะเดียวกับคำตอบ Python ของ @ Theoแต่ด้วยสตริงของ "L" และ "R" แทนที่จะเป็นตัวเลขความสามารถในการทำรายการของ Scratch (และ tosh's) นั้นแย่มาก

คุณสามารถเรียกใช้มันเป็นโครงการเริ่มต้นที่นี่ (tosh รวบรวมเพื่อเกาโครงการ)

when flag clicked
set path to "R"
go to x: -50 y: 100
point in direction 90
pen down
set pen size to 2
clear
repeat 9
    set path copy to path
    set path to join (path) "R"
    set i to length of path copy
    repeat length of path copy
        if letter i of path copy = "R" then
            set path to join (path) "L"
        else
            set path to join (path) "R"
        end
        change i by -1
    end
end
set i to 0
repeat length of path
    change i by 1
    if letter i of path = "R" then
         turn cw 90 degrees
    else
         turn ccw 90 degrees
    end
    move 7 steps
end  

คำอธิบาย:

when flag clicked
set path to "R"
go to x: -50 y: 100
point in direction 90
pen down
set pen size to 2
clear

ส่วนแรกนี้ทำให้โปรแกรมรันเมื่อมีการคลิกที่ธงสีเขียว ( when flag clicked) ตั้งค่าตัวแปรพา ธ เป็น "R" และรับ sprite และสถานะสเตจในสถานะที่เหมาะสมพร้อมที่จะวาด

repeat 9
    set path copy to path
    set path to join (path) "R"
    set i to length of path copy
    repeat length of path copy
        if letter i of path copy = "R" then
            set path to join (path) "L"
        else
            set path to join (path) "R"
        end
        change i by -1
    end
end

ตอนนี้เราได้รับรหัสการสร้างเส้นทาง มันใช้ตรรกะเดียวกับคำตอบ Python ของ @ Theoยกเว้นด้วยสตริงของ "R" และ "L" แทนตัวเลขและเราใช้ลูปซ้อนกันแทนที่จะเป็นรายการความเข้าใจ

set i to 0
repeat length of path
    change i by 1
    if letter i of path = "R" then
         turn cw 90 degrees
    else
         turn ccw 90 degrees
    end
    move 7 steps
end  

สุดท้ายเราวาดเส้นทางโดยผ่านตัวอักษรแต่ละตัวของตัวแปรพา ธ แล้วเลี้ยวซ้ายหรือขวาขึ้นอยู่กับตัวอักษร