พิจารณาเกลียวนี้

###########
#
# #######
# #     #
# # ### #
# # # # #
# # # # #
# #   # #
# ##### #
#       #
#########

เริ่มต้นในศูนย์:

• บรรทัดแรก (ขึ้นไป) มี 3 ตัวอักษร
• บรรทัดที่สองมีจำนวนอักขระเท่ากัน (3)
• ต่อไปเราจะเพิ่มสองตัวอักษร (5) สำหรับสองด้านถัดไป
• รูปแบบนี้ดำเนินต่อไปทั้งสองด้านมีความยาวเท่ากันจากนั้นเพิ่มความยาวเป็น 2

ฉันต้องการสร้างเกลียวนี้สำหรับบรรทัด N

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

กรณีทดสอบ (ใช้แฮชเป็นเอาต์พุต):

N = 1

#
#
#

N = 2

###
#
#

N = 3

###
# #
# #
  #
  #

N = 10

###########
#
# #######
# #     #
# # ### #
# # # # #
# # # # #
# #   # #
# ##### #
#       #
#########

05AB1E , 13 11 ไบต์

รหัส:

ขอบคุณEmignaสำหรับการบันทึกสองไบต์!

LDÈ-Ì'#3Ý·Λ

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

คำอธิบาย

ความยาวของแต่ละขอบของเกลียวเริ่มต้นด้วยความยาว3และค่อยๆเพิ่มขึ้นทุกสองขั้นตอนด้วยสอง:

$n$$n$

L                # Create a list from [1 .. input]
 DÈ              # Duplicate and check for each number if even
   -             # Subtract that from the first list
    Ì            # Add 2

สิ่งนี้ทำให้เรามีรายการความยาวที่ต้องการ

     '#          # Push the '#' character
       0246S     # Push the array [0, 2, 4, 6]
            Λ    # Write to canvas

ผ้าใบทำงานเป็นฟังก์ชั่นที่ปรากฏสามพารามิเตอร์ (ที่พารามิเตอร์ขวาสุดเป็น popped แรก): <ยาว (s)> , <ถ่าน (s)> , <ทิศทาง (s)> พารามิเตอร์เส้นทางในกรณีนี้คือรายการหมายเลข หมายเลขที่สอดคล้องกับเส้นทางคือ:

ในกรณีนี้[0, 2, 4, 6][↑, →, ↓, ←]สอดคล้องกับทิศทางรายการ ผืนผ้าใบวนซ้ำในแต่ละความยาวที่ดึงมาจากรายการความยาวใช้อักขระ '#' และวนซ้ำรอบรายการเส้นทาง

Python 2 , 176 170 165 161 157 bytes

g=lambda a,r:r and g(map(''.join,zip(*a))[::-1],r-1)or a
R=['#']
n=1
exec"R=g(['  '+l for l in g(R,n)][:-1]+[(n+2)*'#'],3*n);n+=1;"*input()
print'\n'.join(R)

ลองออนไลน์!

ซ้ำ ๆ : ใช้gเพื่อหมุนการnวนซ้ำของเกลียวไปยังตำแหน่ง 'canonical' (คล้ายกับ N = 3 หรือ N = 7) เพิ่มเซ็กเมนต์ใหม่โดยเพิ่ม 2 ช่องว่างที่ด้านซ้ายของแต่ละแถวที่มีอยู่จากนั้นเปลี่ยนแถวสุดท้าย ด้วย'#'s ทั้งหมด(ส่งผลให้ตำแหน่งเทียบเท่ากับ N = 4 หรือ N = 8) และในที่สุดก็ใช้gอีกครั้งเพื่อหมุนกลับไปยังตำแหน่งที่ถูกต้อง นวดแล้วล้างซ้ำ

ถ่าน , 16 15 14 ไบต์

↶ＦＮ«¶×#⁺³⊗÷ι²↷

-2 ไบต์ต้องขอบคุณ@Neil @Neil

ลองออนไลน์ (verbose)หรือลองออนไลน์ (บริสุทธิ์)

คำอธิบาย:

ทิศทางการพิมพ์เป็นไปทางขวาโดยค่าเริ่มต้นและเราต้องการเริ่มด้านบนดังนั้นเราจึงเริ่มต้นโดยหมุน 45 องศาทวนเข็มนาฬิกา:

PivotLeft();
↶

จากนั้นวนรอบiในช่วง[0, input):

For(InputNumber()){ ... }
ＦＮ« ...

พิมพ์บรรทัดใหม่เพื่อเลียนแบบเอฟเฟกต์ในการเลื่อนถอยหลังหนึ่งตำแหน่ง:

Print("\n");
¶

พิมพ์xจำนวนครั้ง"#" ในทิศทางปัจจุบัน:

Print(Times("#", ... ));
×# ...

ที่ไหนxคือ3 + i // 2 * 2:

Add(3,Doubled(IntegerDivide(i,2))
⁺³⊗÷ι²

จากนั้นหมุน 45 องศาตามเข็มนาฬิกาสำหรับการวนซ้ำครั้งถัดไปของลูป:

PivotRight();
↷

งูหลาม 2 , 179 178 ไบต์

ขอบคุณKevin Cruijssenสำหรับ -1 ไบต์

n=input()
S,H=' #'
m=[S*n]*(n%2-~n)
x=n/4*2
y=0--n/4*2
k=2
m[y]=S*x+H+S*n
M=[1,0,-1,0]*n
exec'exec k/2*2*"x+=M[~k];y+=M[k];m[y]=m[y][:x]+H+m[y][x+1:];";k+=1;'*n
print'\n'.join(m)

ลองออนไลน์!

Python 2 , 179 ไบต์

ในวิธีการนี้จะใช้สูตรxและเดลตาyแทนรายการการค้นหา

n=input()
S,H=' #'
m=[S*n]*(n%2-~n)
x=n/4*2
y=0--n/4*2
k=2
m[y]=S*x+H+S*n
exec'exec k/2*2*"x+=k%-2+k%4/3*2;y-=(k%2or k%4)-1;m[y]=m[y][:x]+H+m[y][x+1:];";k+=1;'*n
print'\n'.join(m)

ลองออนไลน์!

JavaScript (ES6), 185 ไบต์

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

r=(a,n=1)=>n?r(a.reduce((_,c)=>c).map((_,i)=>a.map(e=>e[i])).reverse(),n-1):a,
s=n=>n?r(s(n-1)).map((r,i)=>[...r,w,w].map(x=>i?x:'#')):[[w=' ']],
d=n=>r(s(n),1-i).map(r=>r.join``).join`
`

การใช้งาน: d(10)ส่งคืนสตริงตามตัวอย่างการท้าทาย N = 10

กำหนดฟังก์ชั่นr(a,n)เพื่อหมุนอาร์เรย์aโดยการnหมุน; ฟังก์ชั่นs(n)ในการสร้างอาร์เรย์ 2 มิติที่เป็นตัวแทนของขนาดเกลียวnโดยการหมุนซ้ำและเพิ่มระยะห่างและเส้น (ไม่หมุนกลับไปที่ตำแหน่งเริ่มต้น); และฟังก์ชั่นd(n)ในการวาดขนาดเกลียวnหมุนอย่างสม่ำเสมอตามความท้าทายและแสดงผลเป็นสตริงที่ส่งคืน

นี่เป็นความท้าทายที่สนุกมาก: ¬)