Cho một số nguyên lẻ dương duy nhất làm đầu vào, trả về một zigzag hội tụ dưới dạng danh sách các chuỗi, danh sách các danh sách các ký tự hoặc chuỗi phân tách dòng mới, trong mẫu này:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

Bạn có thể thay thế #bằng bất kỳ ký tự không khoảng trắng nhất quán nào. Khoảng trắng lưu trữ trên mỗi dòng được cho phép và một dòng mới được phép.

Zig-zag bắt đầu tại cột 1và cho mỗi hàng di chuyển sang phải một cột, cho đến khi đến cột n(nơi nlà đầu vào). Sau đó, nó di chuyển sang trái 2, rồi sang phải n-1, rồi sang trái 3, với hai giới hạn hội tụ cho đến khi đường ngoằn ngoèo kết thúc ở cột giữa ( (n+1)/2).

Các trường hợp thử nghiệm

Ví dụ trên là trường hợp thử nghiệm cho 5.

Sau đây là các trường hợp thử nghiệm riêng lẻ:

3
#
 #
  #
 #

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

1

#

C (gcc) , 89 byte

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);}

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

Hoạt động bằng cách phân tích chuỗi số khoảng trắng dưới dạng (với n = 7):

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

Và với n = 3:

  0
1 2 1

Chúng ta có thể thấy rằng số giữa ( atrong mã) chạy từ [n-1, n / 2). Sau đó, sự khác biệt giữa số đầu tiên và số giữa là:

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

Vì vậy, nếu chúng ta đã btrải qua [- (2a-n), 2a-n], a-abs(b)sẽ cho chúng ta chuỗi mong muốn. Đây thực chất là những gì mã làm.

Than , 10 8 byte

ＦＮ«↗ι‖»/

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Đã lưu 2 byte nhờ @dzaima vì đã chỉ ra rằng tôi không phải sử dụng #s.

Python 2 , 78 byte

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

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

Thạch , 14 byte

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

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

Chương trình đầy đủ.

Công dụng 1.

-1 cảm ơn Jonathan Allan .
-1 cảm ơn Jonathan Allan .

Haskell , 72 byte

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

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

Chúng tôi xác định một danh sách vô hạn rlà đường chéo của #s bắt đầu từ góc trên bên trái.

Sau đó, chúng tôi xác định một chức năng gmà làm việc chính. gsẽ lấy một danh sách và liên tục đảo ngược nó và loại bỏ phần tử đầu tiên của nó cho đến khi danh sách trống, sau đó nối kết quả của mỗi hành động.

Chức năng chính của chúng tôi ở đây là một chức năng không có điểm. Hàm này bắt đầu bằng cách lấy ncác phần tử từ danh sách vô hạn r, sau đó chọn các phần tử đầu tiên và áp dụng g. Cuối cùng chúng ta phải thêm một #trở lại từ đầu, điều này là do thông số kỹ thuật cho câu hỏi hơi kỳ lạ, tôi không chắc tại sao đường chéo đầu tiên luôn dài hơn một lần nhưng nó là vậy, vì vậy chúng ta phải thêm aa #.

SOGL V0.12 , 19 byte

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

Hãy thử nó ở đây!

05AB1E , 22 byte

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

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

Công dụng 8.

05AB1E , 6 byte

LN71SΛ

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

     Λ     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 byte

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

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

Công dụng 8.

Bình thường, 23 byte

8JStQKdVQjbm+*\ d8J=_PJ

Hãy thử nó ở đây.

JavaScript, 127 byte

Tính mục tiêu ( g) để đi đến. Khi đạt được mục tiêu này, hãy quay lại mục tiêu tiếp theo. Cũng sử dụng một mẹo để tránh sử dụng Math.round()bằng cách thêm 0.5vào mỗi số không đồng đều.

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 byte

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

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

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

    [(' '<$[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

Mỗi cuộc gọi đệ quy để fnối thêm đường chéo tiếp theo.

Husk , 19 byte

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

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

Giải trình

Điều này cảm thấy một chút lộn xộn.

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 byte

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

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

Võng mạc , 71 byte

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

Hãy thử trực tuyến! Giải thích: Ba giai đoạn đầu tiên chuyển đổi đầu vào thành dạng :> :trong đó số lượng ký tự giữa các :s là số đầu vào. Hai giai đoạn cuối sau đó nảy >(hoặc <, khi di chuyển sang trái) giữa các :s. Giai đoạn thứ tư lặp lại các lần nảy, in các phần cần thiết của chuỗi mỗi lần. Việc ;dừng chuỗi được in sau vòng lặp.

05AB1E , 16 byte

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

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

Giải trình

Î<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 byte

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

Tạo chuỗi số cơ bản bằng cách liên tục đảo ngược và thả đầu vectơ cho đến khi trống.

PHP, 65 byte

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

Chạy như ống với -nFhoặc kiểm tra nó trực tuyến .

giải trình:

Lặp lại đầu tiên: $nlà NULL, vì vậy --$nkhông có tác dụng và đánh giá thành NULL
-> thiết lập $nvà $dđối số giảm trước
1. tăng $xcho chẵn $d, giảm cho lẻ $d
2. in X, một dòng mới và $xkhoảng trắng

lặp đi lặp lại: giảm dần $n; khi nó chạm 0, thiết lập lại $n(và$d ) thành đối số giảm trước

đêm chung kết: in thêm một lần nữa X.

Japt , 31 byte

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

Giải pháp đệ quy trả về một mảng các dòng.

Hãy thử trực tuyến! sử dụng -Rcờ để tham gia đầu ra với dòng mới.

Python 2, 159 145 141 136 byte

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])])

Đã có các phiên bản Python khá hay cho vấn đề này nhưng tôi nghĩ tôi vẫn đăng bài một lót khủng khiếp của mình. (Không có dấu chấm phẩy!)

Chỉnh sửa: giảm 14 byte, sử dụng tổng thay vì hiểu danh sách kép

Chỉnh sửa: Chỉ cần chú ý trong python 2, bạn có thể sử dụng đầu vào thay vì raw_input. Tôi đã luôn luôn sử dụng sau này.

Mathicala, 142 102 byte (độc lập)

Giải pháp này có một hương vị toán học:

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

Điều này về cơ bản tính toán phân khúc chúng ta đang ở (bằng cách đảo ngược hàm số tam giác) và sau đó di chuyển sang trái hoặc phải bằng cách thêm công suất -1.

Bạn có thể kiểm tra nó trên Wolfram Code Sandbox bằng cách dán mã như UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormvà nhấn Shift + Enter hoặc Numpad Enter hoặc nhấp vào Gear -> "Đánh giá ô".

Điều này xảy ra có cùng độ dài với cổng không chính xác ban đầu của tôi về giải pháp Python 2 của Erik (Cổng này cung cấp đầu ra cho đầu vào cao hơn):

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