Bạn sẽ được cung cấp một số nguyên dương Nlàm đầu vào. Nhiệm vụ của bạn là xây dựng một Semi-Zigzag, gồm các Ncạnh, mỗi chiều dài N. Vì tương đối khó để mô tả rõ ràng nhiệm vụ, đây là một số ví dụ:

• N = 1:

  Ôi
  

• N = 2:

  Ôi
   Ôi
  

• N = 3:

  Ôi
   Ôi
    OOo
  

• N = 4:

  OOo
   Ôi
    Ôi
     OOo
  

• N = 5:

  OOo
   OOo
    OOo
     OOo
      OOo
  

• N = 6:

  OOo
   OOo
    OOo
     OOo
      OOo
       OOOOOOOOOOOO
  

• N = 7:

  OOOOOOOOO
   OOo
    OOo
     OOo
      OOo
       OOo
        OOOOOOOOOOOOOO
  

• Một trường hợp thử nghiệm lớn hơn với N = 9

Như bạn có thể thấy, Semi-Zigzag được tạo thành từ các đường chéo và đường chéo xen kẽ, và nó luôn bắt đầu bằng một đường chéo từ trên trái sang dưới phải. Hãy lưu ý rằng các ký tự trên các đường ngang được phân cách bằng một khoảng trắng.

Quy tắc

• Bạn có thể chọn bất kỳ ký tự không phải khoảng trắng thay vì O, nó thậm chí có thể không nhất quán.

• Bạn có thể xuất / trả kết quả dưới dạng Chuỗi hoặc dưới dạng danh sách Chuỗi, mỗi chuỗi đại diện cho một dòng .

• Bạn có thể có một dòng mới hoặc hàng đầu.

• Lỗ hổng mặc định áp dụng.

• Bạn có thể lấy đầu vào và cung cấp đầu ra theo bất kỳ giá trị trung bình tiêu chuẩn nào .

• Nếu có thể, vui lòng thêm một liên kết thử nghiệm để gửi của bạn. Tôi sẽ nêu lên bất kỳ câu trả lời nào cho thấy nỗ lực chơi gôn và có lời giải thích.

• Đây là mã golf , vì vậy mã ngắn nhất tính theo byte trong mọi ngôn ngữ sẽ thắng!

Than , 24 byte

ＦＮ«↶§7117ι×⁺#× ﹪ι²⁻Ｉθ¹»#

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

-5 cảm ơn Neil .

AST:

Program
├Ｆ: For
│├Ｎ: Input number
│└Program
│ ├↶: Pivot Left
│ │└§: At index
│ │ ├'7117': String '7117'
│ │ └ι: Identifier ι
│ └Print
│  └×: Product
│   ├⁺: Sum
│   │├'#': String '#'
│   │└×: Product
│   │ ├' ': String ' '
│   │ └﹪: Modulo
│   │  ├ι: Identifier ι
│   │  └2: Number 2
│   └⁻: Difference
│    ├Ｉ: Cast
│    │└θ: Identifier θ
│    └1: Number 1
└Print
 └'#': String '#'

Python 2 , 157 153 byte

n=input()
o,s=q='O '
def p(k,t=q*n+s*(4*n-6)):print(t*n)[k*~-n:][:n*3/2*~-n+1]
p(2)
for i in range(n-2):p(0,i*s+s+o+s*(4*n-7-2*i)+o+s*(2*n+i-2))
n>1>p(5)

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

• n*3/2*~-n+1 là chiều rộng của mỗi dòng: 3n / 2⌋ · (n 1) + 1 ký tự.
• Chuỗi q*n+s*(4*n-6)đại diện cho các hàng trên cùng và dưới cùng. Nếu chúng ta lặp lại nó và cắt [2*(n-1):]chúng ta sẽ nhận được hàng trên cùng; nếu chúng ta cắt [5*(n-1):]chúng ta có được hàng dưới cùng. Do đó định nghĩa pvà các cuộc gọi đến p(2)và p(5). Nhưng vì chúng ta cần sự lặp lại và cắt độ dài dòng cho tất cả các dòng khác, nên chúng ta sử dụng lại ptrong vòng lặp.
• Đây i*s+s+o+…chỉ là một biểu thức nhàm chán cho các hàng giữa.
• n>1>p(5)sẽ ngắn mạch nếu n≯1, gây ra p(5)không được đánh giá. Do đó, nó là viết tắt cho if n>1:p(5).

Toán học, 126 125 121 112 104 89 86 byte

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&

• #là số đầu vào cho một hàm ẩn danh (kết thúc bằng cuối cùng &).
• m=" "&~Array~{#,#^2-#+1};tạo một ma trận các ký tự không gian có kích thước phù hợp bằng cách điền vào một mảng các kích thước đã cho #,#^2-#+1bằng các đầu ra của hàm ẩn danh không đổi "xuất ra một khoảng trắng" " "&.
• Do[foo,{j,#},{i,#}]là một cặp vòng lặp lồng nhau, trong đó jphạm vi từ 1đến #và bên trong iphạm vi đó từ 1đến #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"đặt phần tương ứng của ma trận thành ký tự Xdựa trên jvà i. Việc -isử dụng lập chỉ mục tiêu cực để lưu byte từ #-i+1. (Tôi quên viết Mod[j,4]như j~Mod~4trong phiên bản gốc của mã này.) Jenny_mathy chỉ ra rằng chúng ta có thể sử dụng phần dư mô-đun để lập chỉ mục trực tiếp vào danh sách (thay vì sử dụng Switch) để lưu 9 byte và JungHwan Min chỉ ra rằng chúng tôi đã không ' Không cần sử dụng ReplacePartvì chúng ta có thể thiết lập một phần của mảng và 1[i,#,-i][[j~Mod~4]]sử dụng hành vi và tính tổng quát của [[foo]]để lưu byte qua{1,i,#,-i}[[j~Mod~4+1]]
• Vì meta đã xác định rằng danh sách các ký tự là một chuỗi (như JungHwan Min đã chỉ ra ), chúng ta không cần ánh xạ bất kỳ chức năng nào qua các hàng của ma trận các ký tự vì nó đã là một danh sách các "chuỗi".

Bạn có thể kiểm tra điều này trong hộp cát Wolfram Cloud bằng cách dán mã như sau và nhấn Shift + Enter hoặc numpad Enter:

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&@9//MatrixForm

C ++, 321 234 byte

-87 byte nhờ Zacharý

#include<vector>
#include<string>
auto z(int n){std::vector<std::string>l;l.resize(n,std::string(n*n+n/2*(n-1),32));l[0][0]=79;int i=0,j,o=0;for(;i<n;++i)for(j=1;j<n;++j)l[i%4?i%4-1?i%4-2?0:n-j-1:n-1:j][i*n+j-i+(o+=i%2)]=79;return l;}

Trả về một vectơ của chuỗi

Toán học, 179 byte

Rotate[(c=Column)@(t=Table)[{c@(a=Array)[" "~t~#<>(v="o")&,z,0],c@t[t[" ",z-1]<>v,z-1],c@a[t[" ",z-2-#]<>v&,z-1,0],c@t[v,z-Boole[!#~Mod~4<1]-1]}[[i~Mod~4+1]],{i,0,(z=#)-1}],Pi/2]&

chỉnh sửa cho @JungHwanMin

05AB1E , 21 20 19 byte

Mã

Sử dụng chế độ canvas mới:

Fx<)Nè'ONÉúR3212NèΛ

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Giải trình:

F                      # For N in range(0, input)
 x<)                   #   Push the array [input, 2 × input - 1]
    Nè                 #   Retrieve the Nth element
      'ONÉúR           #   Push "O" if N is odd, else "O "
            3212Nè     #   Retrieve the Nth element of 3212
                  Λ    #   Write to canvas

Đối với đầu vào 6 , điều này đưa ra các đối số sau (theo cùng thứ tự) cho khung vẽ:

[<num>, <fill>, <patt>]
[6,     'O',     3]
[11,    'O ',    2]
[6,     'O',     1]
[11,    'O ',    2]
[6,     'O',     3]
[11,    'O ',    2]

Để giải thích những gì canvas làm, chúng tôi chọn bộ đối số đầu tiên từ danh sách trên.

Số 6 xác định độ dài của chuỗi sẽ được ghi vào khung vẽ. Chất độn được sử dụng để viết trên khung vẽ, trong trường hợp này là O. Nó chạy theo chu kỳ thông qua chuỗi phụ. Hướng của chuỗi được xác định bởi đối số cuối cùng, hướng. Các hướng là:

7  0  1
 \ | /
6- X -2
 / | \
5  4  3

Điều này có nghĩa là cả 3 đặt hướng về phía đông nam , cũng có thể được thử trực tuyến .

SOGL V0.12 , 36 byte

╝.H∫2\?.╝}F2%?№@.┌Ο};1w⁄Hh1ž}.4%1>?№

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

Ý tưởng cơ bản là cho mỗi số của phạm vi đầu vào, chọn thêm một đường chéo hoặc phần chấm nằm ngang, trong trường hợp đó, nó sẽ xoay mảng xung quanh để dễ dàng thêm vào. Giải trình:

╝                                     get a diagonal from the bottom-left corner with the length of the input - the starting canvas
 .H∫                        }         for each number in the range [1,inp-1] do, pushing counter
    2\?  }                              if it divides by 2, then
       .╝                                 create another diagonal of the input
          F2%                           push counter % 2
             ?     }                    if that [is not 0]
              №                           reverse the current canvas upside down
               @.┌Ο                       get an alternation of spaces and dashes with the dash amount of the input length
                    ;                   get the canvas on top of the stack
                     1w⁄                get its 1st element length
                        H               decrease it
                         h              swap the bottom 2 items - the canvas is now at the bottom and the current addition ontop
                          1             push 1
                           ž            at 1-indexed coordinates [canvasWidth-1, 1] in the canvas insert the current part made by the Ifs
                             .4%1>?   if input%4 > 1
                                   №    reverse the array vertically

Nếu đầu vào của 1 không được phép, thì ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№ nó cũng sẽ hoạt động. Nếu số ngẫu nhiên nổi xung quanh được cho phép .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№cũng sẽ làm việc. Nếu tôi không lười biếng và thực hiện ‼, }F2%?có thể được thay thế bằng ‼-4 byte

Toán học, 106 87 byte

SparseArray[j=i=1;k=#-1;Array[{j+=Im@i;k∣#&&(i*=I);j,#+1}->"o"&,l=k#+1,0],{#,l}," "]&

Trả về một SparseArray đối tượng của Strings. Để hình dung đầu ra, bạn có thể nối thêm Grid@. Ném một lỗi cho trường hợp 1, nhưng nó an toàn để bỏ qua.

Giải trình

j=i=1

Đặt ivàj thành 1.

k=#-1

Bộ k thành đầu vào - 1.

l=k#+1

Đặt lthànhk*input + 1

Array[ ..., l= ...,0]

Lặp lại lthời gian, bắt đầu từ 0, tăng dần theo 1từng lần ...

j+=Im@i

Thêm các thành phần tưởng tượng của iđể j...

k∣#&&(i*=I)

Nếu phép lặp hiện tại chia hết cho k, nhân ivới đơn vị tưởng tượng ...

{... j,#+1}->"o"

Tạo một Ruleđối tượng thay đổi thành phần tại vị trí {j, current iteration + 1}thành"o"

SparseArray[ ...,{#,l}," "]

Tạo một SparseArrayđối tượng bằng cách tạoRule đối tượng , với kích thước {input, l}, sử dụng " "dưới dạng trống.

Hãy thử nó trên Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 byte

-11 byte Nhờ @Mr. Xcoder

-2 byte Cảm ơn @Mr. Xcoder

def f(n,s=range):
 x=y=t=c=0;z=[]
 for i in s(n*n-n+2):c+=i%(n-(2<=n))<1;z+=[[x,y]];t=max(t,x);x+=2-c%2;y+=[-1,1][c%4<3]*(c%2)
 return'\n'.join(''.join(' O'[[k,j]in z]for k in s(t))for j in s(n))

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

Giải thích và mã ít chơi gôn:

def f(n):
 x=y=t=c=0;z=[]                       #initialize everything
 for i in range(n*n-n+2):             #loop n*n-n+2 times which is the numberr of 'o's expected
    c+=i%[~-n,n]<n-1                  #if one cycle has been completed, increase c by 1, if n>1.                                            
    z+=[[x,y]]                        #add [x,y] to z(record the positions of 'o')
    t=max(t,x)                        #trap maximum value of x-coordinate(to be used later while calculatng whole string)
    r=[[2,0],[1,1],[2,0],[1,-1]][c%4] #r gives direction for x and y to move, adjust it as per c i.e. cycles
    x+=r[0];y+=r[1]                   #yield newer values of x and y 
 return '\n'.join(''.join(' o'[[k,j]in z]for k in range(t))for j in range(n)) #place space or 'o' accordingly as per the recorded posititons in z

Haskell , 197 byte

a n c=take(2*n)$cycle$c:" "
r i n x y=take(div(3*n)2*(n-1)+1)$(' '<$[1..i])++(cycle$"O "++(a(2*n-i-3)y)++"O "++(a(n+i-2)x))
z n=take n$(r 0 n 'O' ' '):[r i n ' ' ' '|i<-[1..n-2]]++[r(n-1)n ' ' 'O']

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

Cảm ơn @Lynn: đã sửa các khoảng trắng giữa O các s trên các đoạn nằm ngang của zigzag, nhưng nó tốn rất nhiều byte!

Một số giải thích:

• rlà một hàng của đầu ra: nó có 0 y y y y y 0 x x x 0 y ...định dạng, số lượng xvày tùy thuộc vào hàng và chữ cái đầun
• cho hàng trên cùng, x='0'vày=' '
• cho các hàng giữa x=' 'vày=' '
• cho hàng dưới cùng, x=' 'vày='0'
• take(div(3*n)2*(n-1)+1) cắt một hàng vô hạn ở đúng nơi
• mỗi đầu ra có một hàng trên cùng và một hàng dưới cùng trừ khi n=1: take nxử lý trường hợp này.

Python 2 , 155 151 146 137 byte

m=input()
n=m-1
r=range(n+2)
for L in zip(*[' '*i+'O'+n*' 'for i in(r+[n,m]*~-n+r[-2::-1]+([m,0]*n)[:-1])*m][:1+3*m/2*n]):print''.join(L)

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