Đưa ra một số nguyên n ≥ 1, sản lượng một đại diện 2D ^† của một ký hiệu phần trăm của chiều rộng n . Việc xây dựng diễn ra như sau:

1. Tạo một n bởi n ma trận (hoặc danh sách liệt kê) đầy zero.
2. Chèn những cái ở góc trên bên trái và dưới cùng bên phải.
3. Đặt những cái trên đường chéo từ dưới cùng bên trái sang trên cùng bên phải.

Đối với đầu vào n = 4, cấu trúc này sẽ trông như sau:

1. 4x4 matrix of 0s
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
2. 1s in TL and BR corners
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 1
3. 1s across BL-TR diagonal
1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

Đây là một môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

^† tôi sử dụng một ma trận của 1s và 0s, nhưng nó cũng có thể chấp nhận sử dụng một chuỗi của bất kỳ nhân vật phi khoảng trắng và không gian. Vì vậy, ví dụ trên có thể giống như:

#  #
  # 
 #  
#  #

hoặc là

#     #
    #
  # 
#     #

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

n
output

1
1

2
1 1
1 1

3
1 0 1
0 1 0
1 0 1

4
1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

10
1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 1

Lưu ý cuối cùng

Thêm một lời giải thích sẽ được đánh giá rất cao.

Thạch , 6 byte

²Rm’Ṭs

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

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

²Rm’Ṭs  Main link. Argument: n

²       Square; yield n².
 R      Range; yield [1, ..., n²].
   ’    Decrement; yield n-1.
  m     Modular; yield every (n-1)-th element of the range, staring with the first.
    Ṭ   Untruth; yield a Boolean array with 1's at the specified indices.
     s  Split the resulting array into chunks of length n, creating a matrix.

JavaScript (ES6), 52 byte

n=>[...Array(n)].map((_,y,a)=>a.map(_=>y++%~-n<1|0))

V , 15 byte

Àé ÀÄ|r#L.|ò.kl

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

Giải trình

Àé<space>        " Argument times insert a space
ÀÄ               " Argument times duplicate this line
                 " This gives an arg-by-arg matrix of spaces
                 "  and brings the cursor to the end of the first line
|r#              " Go to the beginning of this line and replace the first character with #
L.               " Go to the end of this matrix (bottom-right corner) and replace that character with a #
|                " Go to the beginning of the last line
ò                " Recursively do:
 .               "  Repeat the last action, r#, replace the character under the cursor with #
 kl              "  Go 1 up and 1 right

Python 2 , 58 57 byte

n=input()
x='#'.ljust(n-1)*3
exec'print x[:n];x=x[1:];'*n

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

GNU APL, 17 15 byte

{1=⍵∨⍵⍵⍴1=⍳⍵-1}

Đây là một ngày kỳ lạ ... GNU thực sự đã đánh bại Dyalog APL ... woah.

TIO không hỗ trợ GNU APL ...

Giải thích (đầu vào là ⍵):

1=⍳⍵-1 - 1 followed by ⍵-2 0's
⍵⍵⍴    - fit into a square
⍵∨     - gcd ⍵ (0 gcd n = n)
1=     - test each element for equality with 1

Python 2 , 46 byte

lambda n:zip(*[iter(`10L**n`[:-3]*-~n+'1')]*n)

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

Đầu ra như

[('1', '0', '0', '1'), ('0', '0', '1', '0'), ('0', '1', '0', '0'), ('1', '0', '0', '1')]

Python 2 , 48 byte

lambda n:zip(*[iter([1]+(n*[0]+[1])[2:]*-~n)]*n)

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

Đầu ra như

[(1, 0, 0, 1), (0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 1)]

Python 3 , 48 byte

lambda n:('%d'*n+'\n')*n%(1,*(*[0]*n,1)[2:]*-~n)

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

Một cách tiếp cận thay thế chuỗi khá khác nhau trong Python 3. Các kết quả như:

1001
0010
0100
1001

Thạch , 9 byte

=þ¹UF1Q¦s

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

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

=þ¹UF1Q¦s  Main link. Argument: n

  ¹        Identity; yield n.
=þ         Equals table; compare each i in [1, ..., n] with each j in [1, ..., n].
           This yields the n×n identity matrix.
   U       Upend; reverse each row.
    F      Flatten the matrix.
       ¦   Sparse application:
      Q        Unique; yield the unique elements of the constructed array, i.e.,
               [1] if n = 1 and [0, 1] if n > 1.
     1         Yield 1.
           This replaces the elements at indices 0 (last) and 1 (first) with 1.
        s  Split the resulting array into chunks of length n.

APL (Dyalog) , 18 byte

{⍵=1:⍵⋄⍵ ⍵⍴1=⍳⍵-1}

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

Làm cho công việc này cho đầu vào 1 đã thêm 6 byte.

Nhìn vào testcase 4, chúng ta thấy đầu ra là

1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

Điều này về cơ bản là 1 0 0 lặp đi lặp lại trong suốt ma trận. Nói cách khác, hình 1 0 0 trong ma trận 4 nhân 4. Vì vậy, trong giải pháp này, trước tiên chúng ta tạo vectơ này với 1 và dấu 0 bằng cách sử dụng 1=⍳⍵-1và sau đó định hình nó bằng cách sử dụng ⍵ ⍵⍴. Nhưng cái nút này cho đầu vào 1, vì vậy chúng ta cần tạo một điều kiện và đạt được 6 byte ...

{⍵=1:⍵⋄⍵ ⍵⍴1=⍳⍵-1}    The right argument is ⍵
 ⍵=1:⍵                 If ⍵ is 1 return itself
⋄                      Otherwise
 ⍳⍵-1                   Create a range 1 .. ⍵-1
 1=                     Equals 1; 1 0 0 {⍵-2 0's} ...
 ⍵ ⍵⍴                   Shape in a ⍵-by-⍵ matrix

Haskell , 55 byte

Lúc đầu, cách tiếp cận của tôi là tạo đệ quy ma trận danh tính được chuyển đổi, nhưng sau đó sửa dòng đầu tiên và dòng cuối cùng yêu cầu một số phân biệt trường hợp xấu / dài. Vì vậy, tôi đã tìm một cách khác để tạo ra ma trận danh tính, đó là cách tôi tìm thấy ý tưởng này .

f n=[[sum[1|x+y`elem`[2,n+1,2*n]]|y<-[1..n]]|x<-[1..n]]

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

Giải trình

[[x+y|y<-[1..n]]|x<-[1..n]]

tạo ma trận này (cho n=4):

[2,3,4,5]
[3,4,5,6]
[4,5,6,7]
[5,6,7,8]

Như bạn có thể thấy phần tử trên cùng bên trái là 2(nói chung), tất cả các phần tử đường chéo là 5(nói chung n+1) và phần tử dưới cùng bên phải là 8(nói chung 2*n). Vì vậy, tất cả những gì chúng ta cần làm là kiểm tra xem có phải x+ylà một yếu tố của [2,n+1,2*n].

R , 54 42 byte

-12 byte nhờ Jarko Dubbeldam

n=scan();m=diag(n)[,n:1];m[1,1]=m[n,n]=1;m

trả về một ma trận; đọc từ stdin. tạo một ma trận danh tính diag(n), lật nó từ trên xuống dưới [,n:1], đặt trên cùng bên trái và dưới cùng bên phải 1, sau đó ghi vào console ( '') với chiều rộng n.

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

MATL , 7 byte

XyPl5L(

Hãy thử nó tại MATL Online!

Giải trình

Tạo ma trận danh tính ( Xy), lật theo chiều dọc ( P), write ( () giá trị 1 ( l) cho các mục nhập đầu tiên và cuối cùng ( 5L), là trên cùng bên trái và dưới cùng bên phải.

APL Dyalog, 12 11 10 byte

,⍨⍴×,2↓⊢↑×

Dùng thử trực tuyến

-1 byte nhờ lstefano.

Làm sao?

,⍨⍴×,2↓⊢↑×
       ⊢↑× - argument-length extension of the sign of the argument (1)
     2↓    - Drop the first two elements
   ×,      - Prepend a one
,⍨⍴        - Shape into a square array with dimensions of input x input

C # (.NET Core) , 121 91 88 byte

-30 byte vì cách cũ là ngu ngốc.

-3 byte bằng cách di chuyển xung quanh việc khởi tạo biến

n=>{int i=0,k=n-1;int[,]b=new int[n,n];b[0,0]=b[k,k]=1;for(;i<n;)b[i++,k--]=1;return b;}

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

Vòng lặp lặp xuống mảng để điền vào 1's. Trả về một mảng 1 và 0.

05AB1E , 14 11 7 byte

n<ÝI<Öô

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

Giải trình

n<Ý      # push range [0 ... n^2-1]
   I<Ö   # check each for equality to 0 when modulus with n-1 is taken
      ô  # split in pieces of size n

Than , 14 12 7 byte

^{-5 byte nhờ Neil !}

↗Ｎ⸿/‖Ｏ↘

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

C ++, 144 byte

#include<string>
#define S std::string
S p(int n){S r;for(int i=0;i<n;++i){r+=S(n,32);r[r.size()-1-i]=35;r+=10;}r[0]=r[r.size()-2]=35;return r;}

Nó tận dụng sự khác biệt một byte giữa '#' và 35

Toán học, 72 byte

(s=Table[0,#,#];s[[1,1]]=s[[#,#]]=1;Table[s[[#+1-i,i]]=1,{i,#}];Grid@s)&

đầu vào

[5]

đầu ra

1 0 0 0 1
0 0 0 1 0
0 0 1 0 0
0 1 0 0 0
1 0 0 0 1

Python 2 , 86 62 byte

n=input();a=('1'+'0'*(n-2))*2+'1'
exec'print a[:n];a=a[1:];'*n

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

-24 byte: Nhờ một ý tưởng từ Rod!

PowerShell , 67 byte

param($n)0..--$n|%{-join(("1"+"0"*(($n-1),0)[!$n])*3)[$_..($_+$n)]}

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

Đưa đầu vào $nvà các vòng lặp từ 0đến --$n(nghĩa là $ngiảm trước). Mỗi lần lặp, chúng ta xây dựng một chuỗi 1theo sau bởi $n-1 0s, sau đó nhân số 3lần đó (ví dụ: 100010001000cho đầu vào của 5). Sau đó, chúng tôi lập chỉ mục vào đó trên cơ sở luân phiên bắt đầu từ 0đến 0 + $n. Những ký tự này được -joined thành một chuỗi, được để lại trên đường ống. Đầu ra là ẩn.

(NB - Điều này yêu cầu thêm 9 byte để xử lý trường hợp đặc biệt n=1. Dưới đây là mã 58 byte nếu chúng tôi đảm bảo n>1)

param($n)0..--$n|%{-join(("1"+"0"*($n-1))*3)[$_..($_+$n)]}

Dyalog APL v16, 23 byte

{(1@(1 1)(⍵ ⍵))⌽∘.=⍨⍳⍵}

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

Giải trình:

{(1@(1 1)(⍵ ⍵))⌽∘.=⍨⍳⍵} -(input ⍵) 
                ∘.=⍨⍳⍵  - identity matrix with size ⍵×⍵
               ⌽        - flip that
 (1@(1 1)(⍵ ⍵))         - place 1 into the corners using the v16 operator @ (At)

Lua, 117 byte

m=arg[1]+0 for y=m,1,-1 do s=""for x=1,m do s=s..((x==1 and y==m or x==m and y==1 or x==y)and"#"or" ")end print(s)end

Thử nó

Mã khá đơn giản. Nó đặt m thành đối số đầu tiên, sau đó thêm 0 vào nó để chuyển đổi nó thành một số, sau đó lặp lại cho tọa độ Y, chuyển tiếp qua tọa độ X và sẽ đặt # if x == y hoặc nếu đó là các góc khác.

Chương trình này không bao giờ sử dụng từ khóa "nếu".

Octave, 37 byte

@(n)sparse([1 n:-1:1 n],[1 1:n n],!0)

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

Tạo một ma trận thưa thớt đại diện cho dấu phần trăm.

Japt , 12 byte

²ovUÉ hT1 òU

Trả về một mảng / ma trận 2D.

Hãy thử trực tuyến! sử dụng -Qcờ để hiển thị đầu ra có định dạng mảng.

Giải trình

²ovUÉ hT1 òU

Ngụ ý: U= số nguyên đầu vào

²o

Square U( ²), tạo mảng [0, U*U)( o) và ánh xạ từng mục bằng ...

vUÉ

1nếu nó chia hết ( v) bởi U-1( UÉ), thì khác 0.

hT1

Đặt mục ( h) tại chỉ mục 0 ( T) thành 1.

òU

Chia mảng thành các lát ( ò) có độ dài U.

PHP, 53 byte

for(;$i<$l*$l;)echo($i++%($l-1)?0:1).($i%$l?'':"\n");

Độ dài của cạnh của ma trận là $l. Mã này có Thông báo PHP và thậm chí Cảnh báo PHP để chia cho 0 khi $l=0, nhưng thực hiện công việc!

Python 2 , 93 byte

n=input()
a='1'+'0'*(n-2)+'1'
print a
for i in range(1,n-1):print str(10**i).zfill(n)
print a

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

Ruby, 47 byte

->n{([1]+[0]*(n-2)).cycle.each_slice(n).take n}

Nó trả về một mảng các mảng.

Mã này khá đơn giản.

• Nó tạo ra một n-1mảng với 1phần tử đầu tiên và phần còn lại chứa 0s (vd [1, 0, 0, 0])
• Nó lặp lại
• Nó có ncác nphần tử

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

J, 14 byte

-]\*:$1,0$~-&2 

Ung dung:

- ]\ (*: $ (1,0 $~ -&2))

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

Python 3, 97 byte

def f(n):
    m=[[0+(j==n-i-1)for j in range(n)]for i in range(n)]
    m[0][0]=1
    m[-1]=m[0]
    return m

Giải trình

m=[[0+(j==n-i-1)for j in range(n)]for i in range(n)]

Đây là một sự hiểu biết danh sách, 0+(j==n-i-1)là một cách ngắn hơn để chuyển đổi j==n-i-1thành một int (trái ngược với intchức năng) và sau đó m[-1]=m[0]ngắn hơn so với việc tạo dưới cùng bên phải 1, vì các hàng trên cùng và dưới cùng là giống hệt nhau.

Forth, 273 (không có ý kiến) 170 (golfed-ish)

: % 2 base ! cr dup 1- 1 swap lshift 1 or . cr 2 over 2 - dup 0< 0= if
0 ?do 2dup s>d rot <# 0 ?do # loop #> type cr 2*  loop
1 or . else drop drop then cr drop decimal ;

(Phiên bản 273 để làm rõ phiên bản nhận xét :)

: newbase
 base @ swap base ! ;
: 0u.r
 swap s>d rot <# 0 ?do # loop #> type ;
: frame
 1- 1 swap lshift 1 or ;
: %
 2 newbase swap
 cr dup frame . cr
 2 over 2 -
 dup 0< 0= if
  0 ?do
   2dup swap 0u.r cr
   2* 
  loop
  1 or .
 else
  drop drop
 then
cr
drop base ! ;

(Lưu ý rằng, vì khoảng trắng là dấu phân cách chính trong Forth, việc loại bỏ mọi lợi nhuận vận chuyển sẽ không có gì khác biệt. Tất nhiên, thụt lề là có.)

(Đã bình luận :)

( Uses bit array, max 64 width on AMD64 with gforth. )

( Could shave an extra thirty or so bytes by not restoring )
( the numeric base, )
( and a few more by pulling frame and 0u.r into the definition. )

: newbase ( n -- oldbase )  ( swap base with n )
 base @ swap base ! ;

: 0u.r ( u width -- )  ( unsigned numeric output, no leading zero suppression )
 swap s>d rot <# 0 ?do # loop #> type ;

: frame ( n -- f )  ( frame )
 1- 1 swap lshift 1 or ;

: %  ( n -- )  ( Make the % sign )
 2 newbase swap ( Use binary output. )
 cr dup frame . cr ( Frame the first line. )
 2 over 2 -
 dup 0< 0= if ( Are we already done? )
  0 ?do ( Loop doesn't do the first or last. )
   2dup swap 0u.r cr ( Zero fill, right justify. )
   2* 
  loop
  1 or . ( Put the second frame out. )
 else
  drop drop
 then
cr
drop base ! ;

(Ví dụ thực hiện :)

1 % 
1 

 ok
2 % 
11 
11 
 ok
3 % 
101 
010
101 
 ok
10 % 
1000000001 
0000000010
0000000100
0000001000
0000010000
0000100000
0001000000
0010000000
0100000000
1000000001 
 ok
40 % 
1000000000000000000000000000000000000001 
0000000000000000000000000000000000000010
0000000000000000000000000000000000000100
0000000000000000000000000000000000001000
0000000000000000000000000000000000010000
0000000000000000000000000000000000100000
0000000000000000000000000000000001000000
0000000000000000000000000000000010000000
0000000000000000000000000000000100000000
0000000000000000000000000000001000000000
0000000000000000000000000000010000000000
0000000000000000000000000000100000000000
0000000000000000000000000001000000000000
0000000000000000000000000010000000000000
0000000000000000000000000100000000000000
0000000000000000000000001000000000000000
0000000000000000000000010000000000000000
0000000000000000000000100000000000000000
0000000000000000000001000000000000000000
0000000000000000000010000000000000000000
0000000000000000000100000000000000000000
0000000000000000001000000000000000000000
0000000000000000010000000000000000000000
0000000000000000100000000000000000000000
0000000000000001000000000000000000000000
0000000000000010000000000000000000000000
0000000000000100000000000000000000000000
0000000000001000000000000000000000000000
0000000000010000000000000000000000000000
0000000000100000000000000000000000000000
0000000001000000000000000000000000000000
0000000010000000000000000000000000000000
0000000100000000000000000000000000000000
0000001000000000000000000000000000000000
0000010000000000000000000000000000000000
0000100000000000000000000000000000000000
0001000000000000000000000000000000000000
0010000000000000000000000000000000000000
0100000000000000000000000000000000000000
1000000000000000000000000000000000000001 
 ok

(Lưu ý cuối cùng: hoạt động nhỏ hơn một chút so với độ rộng bit của trình thông dịch Forth. Tôi đã chạy ở trên trên gforth, AMD64. Một Forth 16 bit cổ đại sẽ chỉ rộng 15 bit và cần sửa đổi một chút.)

C # (.NET Core) , 65 byte

w=>{var l=new int[w*w];for(int i=0;i<w*w;i+=w-1)l[i]=1;return l;}

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

Thuật toán khác biệt đáng kể so với câu trả lời C # khác, vì vậy tôi quyết định đăng riêng nó thay vì cải tiến. Lấy cảm hứng từ câu trả lời Jelly được đánh giá hàng đầu thực sự, tôi đã làm một cái gì đó hơi nhỏ gọn trước đây. Đầu ra là một mảng tuyến tính, do đó sẽ yêu cầu một số logic để bọc nó thành 2D bên ngoài phương thức nguyên trạng. Một phiên bản thay thế yêu cầu 6 byte bổ sung để xuất thành một mảng 2D thực sự:

w=>{var l=new int[w,w];for(int i=0;i<w*w;i+=w-1)l[i/w,i%w]=1;return l;}

Tôi cũng có một phiên bản không cạnh tranh thú vị.

using System.Linq;w=>new int[w*w].Select((_,i)=>i%(w-1)<1)

Điều này kết thúc với đầu ra gần như đúng, dẫn đến kết quả là IEnumerable<bool>đúng / sai thay vì 1/0 và đó là cấu trúc tuyến tính chứ không phải 2D, và mặc dù không cần thiết cho dòng mã chính xác đó, using System.Collections.Genericlà cần thiết để làm bất cứ điều gì hữu ích với đầu ra. Như tôi đã nói, nó rất gần với giá trị nhưng không hoàn toàn.