กำหนดจำนวนเต็มคี่บวกเดียวเป็นอินพุตให้ส่งคืนซิกแซกที่รวมกันเป็นรายการของสตริงรายการของรายการอักขระหรือสตริงที่คั่นด้วยบรรทัดใหม่ในรูปแบบนี้:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

คุณสามารถแทนที่#ด้วยอักขระที่ไม่ใช่ช่องว่างที่สอดคล้องกัน อนุญาตช่องว่างต่อท้ายในแต่ละบรรทัดและอนุญาตให้ขึ้นบรรทัดใหม่ได้

zig-zag เริ่มต้นที่คอลัมน์1และสำหรับแต่ละแถวจะเลื่อนไปทางขวาหนึ่งคอลัมน์จนกระทั่งถึงคอลัมน์n(ซึ่งnเป็นอินพุต) จากนั้นมันจะย้ายไปทางซ้าย2แล้วไปทางขวาจากนั้นไปn-1ทางซ้าย3โดยที่ทั้งสองขอบเขตจะบรรจบกันจนกระทั่งซิกแซกสิ้นสุดลงในคอลัมน์กลาง ( (n+1)/2)

กรณีทดสอบ

5ตัวอย่างข้างต้นเป็นกรณีทดสอบสำหรับ

กรณีทดสอบต่อไปนี้เป็นรายบุคคล:

3
#
 #
  #
 #

7
#
 #
  #
   #
    #
     #
      #
     #
    #
   #
  #
 #
  #
   #
    #
     #
    #
   #
  #
   #
    #
   #

1

#

C (gcc) , 89 ไบต์

f(n,a,b){puts("0");for(a=n;--a>n/2;)for(b=n-2*a;b<=2*a-n;)printf(" %*d\n",a-abs(b++),0);}

ลองออนไลน์!

ทำงานโดยการวิเคราะห์ลำดับของจำนวนช่องว่างเป็น (สำหรับ n = 7):

          0
1 2 3 4 5 6 5 4 3 2 1
    2 3 4 5 4 3 2
        3 4 3

และสำหรับ n = 3:

  0
1 2 1

เราจะเห็นได้ว่าหมายเลขกลาง ( aในรหัส) วิ่งจาก [n-1, n / 2) จากนั้นความแตกต่างระหว่างหมายเลขแรกและหมายเลขกลางคือ:

a  n  b  2a-n
-------------
6  7  5  5
5  7  3  3
4  7  1  1
2  3  1  1

ดังนั้นถ้าเราbผ่าน [- (2a-n), 2a-n] a-abs(b)จะให้ลำดับที่เราต้องการ นี่คือสิ่งที่รหัสทำ

ถ่าน , 10 8 ไบต์

ＦＮ«↗ι‖»/

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน แก้ไข: บันทึกไว้ 2 ไบต์ขอบคุณที่ @dzaima สำหรับการชี้ให้เห็นว่าผมไม่ได้มีการใช้#s

Python 2 , 78 ไบต์

l=range(1,input())
print 8
for i in l:
 for i in l:print' '*i+'8'
 l=l[-2::-1]

ลองออนไลน์!

เยลลี่ขนาด 14 ไบต์

ṖṖṚ$ÐĿẎ0;⁶ẋp1Y

ลองออนไลน์!

โปรแกรมเต็มรูปแบบ

1การใช้ประโยชน์

-1 ขอบคุณที่โจนาธานอัลลัน
-1 ขอบคุณที่โจนาธานอัลลัน

Haskell , 72 ไบต์

g[]=[]
g a=a++g(reverse$init a)
r="#":map(' ':)r
("#":).g.tail.(`take`r)

ลองออนไลน์!

เรากำหนดรายการอนันต์rเป็นเส้นทแยงมุมของ#s เริ่มจากมุมบนซ้าย

จากนั้นเราจะกำหนดฟังก์ชั่นgที่ทำงานหนัก gจะใช้รายการและย้อนกลับซ้ำ ๆ และลบองค์ประกอบแรกจนกว่ารายการจะว่างเปล่าจากนั้นทำการเชื่อมโยงผลลัพธ์ของแต่ละการกระทำ

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

SOGL V0.12 , 19 ไบต์

┘.»∫«I╝:±jk+jl0;±Iž

ลองที่นี่!

05AB1E , 22 ไบต์

i8ë<LZFD¨R})˜0¸ìε8sú}»

ลองออนไลน์!

8การใช้ประโยชน์

05AB1E , 6 ไบต์

LN71SΛ

ลองออนไลน์!

     Λ     use the canvas function with

L          a range list [1 .. input] as lengths for each path 

 N         a "0" as character to be printed 
           (N is the index variable used by loops. If there was no loop yet, its
           default value is 0. By using N, I avoid an extra space between 0 and 71)

  71S      and the directions 7 and 1 (NW and NE), that alternate automatically until
           the range list is finished.

CJam , 29 ไบต์

ri,(;_,{_);W%}*]e_0\+Sf*8f+N*

ลองออนไลน์!

8การใช้ประโยชน์

Pyth, 23 ไบต์

8JStQKdVQjbm+*\ d8J=_PJ

ลองที่นี่

จาวาสคริปต์, 127 ไบต์

คำนวณเป้าหมาย ( g) เพื่อไปที่ เมื่อถึงเป้าหมายนี้ให้หันไปยังเป้าหมายต่อไป ยังใช้เคล็ดลับเพื่อหลีกเลี่ยงการใช้Math.round()โดยการเพิ่ม0.5ทุกหมายเลขไม่สม่ำเสมอ

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f(5);

Haskell, 74 ไบต์

f[x]=[x]
f s=s++tail(f$reverse$tail s)
g n=f[(' '<$[2..x])++"#"|x<-[1..n]]

ลองออนไลน์!

มันทำงานอย่างไร:

    [(' '<$[2..x])++"#"|x<-[1..n]]     -- build the first diagonal, e.g. for n=3:
                                         -- ["#", " #", "  #"]
  f                                      -- call f, which is

f s = s ++                               -- the input list, followed by
           tail                          -- all but the first element of
                f                        -- a recursive call with
                  reverse                -- the reverse of
                          tail s         -- all but the first element of the input 
                                         -- list
f[x]=[x]                                 -- base case: stop if the input list a
                                         -- singleton list

การโทรซ้ำแต่ละครั้งเพื่อต่อfท้ายทแยงมุมต่อไป

Husk , 19 ไบต์

mo`:'#R' ∫`Ṙ¢e1_1tṫ

ลองออนไลน์!

คำอธิบาย

รู้สึกแบบนี้เล็กน้อย

mo`:'#R' ∫`Ṙ¢e1_1tṫ  Input is n (e.g. 5)
                  ṫ  Range from input to 1: [5,4,3,2,1]
                 t   Drop first element: [4,3,2,1]
             e1_1    The list [1,-1]
            ¢        repeated infinitely: [1,-1,1,-1,..
          `Ṙ         Clone with respect to the list above: [1,1,1,1,-1,-1,-1,1,1,-1]
         ∫           Cumulative sum: [0,1,2,3,4,3,2,1,2,3,2]
mo                   For each element k (e.g. 3) do this:
      R'             Repeat space k times: "   "
  `:'#               Append '#': "   #"
                     Print implicitly separated by linefeeds.

Python 3 , 82 ไบต์

def z(n):l=range(1,n);print(8);exec("[print(' '*i+'8')for i in l];l=l[-2::-1];"*n)

ลองออนไลน์!

เรติน่า 71 ไบต์

.+
$* 
^
:>
 $
:
;{*T`:<>`_#
( ) >(:)|( )<
$1<$2$3
(:)( )<|>( )
$2$1$3>

ลองออนไลน์! คำอธิบาย: สามขั้นตอนแรกแปลงอินพุตเป็นรูปแบบ:> :ที่จำนวนอักขระระหว่าง:s คือหมายเลขอินพุต สองขั้นตอนสุดท้ายจะกระดอน>(หรือ<เมื่อเคลื่อนที่ไปทางซ้าย) ระหว่าง:s ขั้นตอนที่สี่ลูปเด้งพิมพ์ชิ้นส่วนที่ต้องการของสตริงในแต่ละครั้ง ;หยุดสตริงจากการถูกตีพิมพ์หลังจากที่วง

05AB1E , 16 ไบต์

Î<L¤F¦})˜Ôð×X«»

ลองออนไลน์!

คำอธิบาย

Î<L               # push 0 and range [1 ... input-1]
   ¤              # get the last element of the list
    F             # that many times do
     Â            # bifurcate
      ¦           # remove the head
       })˜        # end loop and wrap in flattened list
          Ô       # remove consecutive duplicates
           ð×     # repeat space a number of times corresponding to each number in the list
             X«   # append 1 to each
               »  # join on newline

K (Kona), 27 ไบต์

`0:{|x$"#"}'1,,/{1_|x}\-2-!

สร้างลำดับตัวเลขพื้นฐานโดยการย้อนกลับและวางหัวของเวกเตอร์ซ้ำ ๆ จนกว่าจะว่างเปล่า

PHP, 65 ไบต์

<?while(--$n||$n=$d=--$argn)echo str_pad("X
",2+$x-=$d&1?:-1);?>X

เรียกใช้เป็นท่อด้วย -nFหรือทดสอบออนไลน์

คำอธิบาย:

การวนซ้ำครั้งแรก: $nคือNULLดังนั้นจึง--$nไม่มีผลกระทบใด ๆ และประเมินเป็นNULL
-> set $nและ$dอาร์กิวเมนต์ที่ลดค่าล่วงหน้า
1. การเพิ่มขึ้น$xสำหรับการเท่าการ$dลดลงของคี่$d
2. การพิมพ์Xบรรทัดใหม่และ$xช่องว่าง

การทำซ้ำเพิ่มเติม: การลดลง$n; เมื่อกระทบ0ให้รีเซ็ต$n(และ$d) เป็นอาร์กิวเมนต์ที่ลดค่าล่วงหน้า

ตอนจบ: Xพิมพ์อีกครั้งหนึ่ง

Japt , 31 ไบต์

Ç+V ç +QÃê ¯-2 c´U?ß´UVÄ :Vç +Q

โซลูชันแบบเรียกซ้ำที่ส่งคืนอาร์เรย์ของบรรทัด

ลองออนไลน์! ใช้-Rแฟล็กเพื่อเข้าร่วมเอาต์พุตกับบรรทัดใหม่

Python 2, 159 145 141 136 ไบต์

print"".join([" "*p+"#\n"for p in(lambda l:[sum(l[:i])for i in range(len(l))])(sum([i*[1-i%2*2]for i in range(input())[::-1]],[])+[1])])

มีเวอร์ชันไพ ธ อนที่ค่อนข้างดีอยู่แล้วสำหรับปัญหานี้ แต่ฉันคิดว่าฉันยังคงโพสต์หนึ่งซับที่น่ากลัวของฉัน (โดยไม่มีเครื่องหมายอัฒภาค!)

แก้ไข: 14 ไบต์ลงโดยใช้ผลรวมแทนความเข้าใจสองรายการ

แก้ไข: เพิ่งสังเกตเห็นในหลาม 2 คุณสามารถใช้อินพุตแทน raw_input ฉันมักจะใช้หลัง

Mathematica, 142 102 ไบต์ (อิสระ)

วิธีการแก้ปัญหานี้มีรสชาติทางคณิตศาสตร์:

UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&

นี่เป็นการคำนวณส่วนที่เราอยู่ (โดยการกลับฟังก์ชั่นหมายเลขสามเหลี่ยม) แล้วเลื่อนไปทางซ้ายหรือขวาโดยการเพิ่มกำลังของ -1

คุณสามารถทดสอบได้ในWolfram Code Sandboxโดยวางรหัสเช่นUnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormและกด Shift + Enter หรือ Numpad Enter หรือคลิกที่ Gear -> "Evaluate Cell"

สิ่งนี้จะมีความยาวเท่ากับพอร์ตที่ไม่ถูกต้องดั้งเดิมของฉันของโซลูชัน Python 2ของErik (พอร์ตนี้ให้เอาต์พุตสำหรับอินพุตที่สูงกว่าหนึ่ง):

(Print[X];l=Range@#;Do[Do[Print[StringRepeat[" ",l[[j]]]<>"X"],{j,Length@l}];l=l[[-2;;1;;-1]],{i,#}])&