Diberikan bilangan bulat n ≥ 1, menghasilkan representasi 2D ^† dari tanda persen lebar n . Konstruksi berjalan sebagai berikut:

1. Buat n oleh n matriks (atau daftar daftar) diisi dengan nol.
2. Masukkan yang di sudut kiri atas dan kanan bawah.
3. Tempatkan yang diagonal dari kiri bawah ke kanan atas.

Untuk input n = 4, konstruksi ini akan terlihat seperti:

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

Ini adalah kode-golf , sehingga program terpendek dalam byte menang.

^† Saya menggunakan matriks 1s dan 0s, tetapi juga dapat diterima untuk menggunakan string karakter dan spasi non-spasi apa pun. Jadi, contoh di atas dapat terlihat seperti:

#  #
  # 
 #  
#  #

atau

#     #
    #
  # 
#     #

Uji kasus

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

Catatan akhir

Menambahkan penjelasan akan sangat dihargai.

Jelly , 6 byte

²Rm’Ṭs

Cobalah online!

Bagaimana itu bekerja

²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

Cobalah online!

Penjelasan

Àé<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

Cobalah online!

GNU APL, 17 15 byte

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

Ini adalah hari yang aneh ... GNU benar-benar mengalahkan Dyalog APL ... wah.

TIO tidak mendukung APL GNU ...

Penjelasan (input ⍵):

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)

Cobalah online!

Output seperti

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

Cobalah online!

Output seperti

[(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)

Cobalah online!

Pendekatan substitusi string yang sangat berbeda dalam Python 3. Output seperti:

1001
0010
0100
1001

Jelly , 9 byte

=þ¹UF1Q¦s

Cobalah online!

Bagaimana itu bekerja

=þ¹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}

Cobalah online!

Membuat ini berfungsi untuk input 1 telah menambahkan 6 byte.

Melihat testcase 4, kita melihat outputnya

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

Ini pada dasarnya 1 0 0 diulangi sepanjang matriks. Dengan kata lain, 1 0 0 dibentuk dalam matriks 4-oleh-4. Jadi dalam solusi ini, pertama-tama kita menghasilkan vektor ini dengan 1 dan mengekor 0s menggunakan 1=⍳⍵-1dan kemudian membentuknya menggunakan ⍵ ⍵⍴. Tapi ini borks untuk input 1, jadi kita perlu membuat kondisional dan mendapatkan 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

Pada awalnya pendekatan saya adalah secara rekursif menghasilkan matriks identitas yang ditransposisikan, tetapi kemudian memperbaiki baris pertama dan terakhir membutuhkan beberapa perbedaan kasus yang jelek / panjang. Jadi saya mencari cara lain untuk menghasilkan matriks identitas yang merupakan cara saya menemukan ide ini .

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

Cobalah online!

Penjelasan

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

menghasilkan matriks ini (untuk n=4):

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

Seperti yang Anda lihat elemen kiri atas adalah 2(secara umum), semua elemen diagonal adalah 5(secara umum n+1) dan elemen kanan bawah adalah 8(secara umum 2*n). Jadi yang perlu kita lakukan adalah memeriksa apakah x+yelemen [2,n+1,2*n].

R , 54 42 byte

-12 byte terima kasih kepada Jarko Dubbeldam

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

mengembalikan sebuah matriks; dibaca dari stdin. membuat matriks identitas diag(n), membaliknya ke atas [,n:1], mengatur kiri atas dan kanan bawah 1, dan kemudian menulis ke konsol ( '') dengan lebar n.

Cobalah online!

MATL , 7 byte

XyPl5L(

Cobalah di MATL Online!

Penjelasan

Buat matriks identitas ( Xy), balik vertikal ( P), tulis ( () nilai 1 ( l) ke entri pertama dan terakhir ( 5L), yang merupakan kiri atas dan kanan bawah.

Dyalog APL, 12 11 10 byte

,⍨⍴×,2↓⊢↑×

Cobalah online

-1 byte terima kasih kepada lstefano.

Bagaimana?

,⍨⍴×,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 karena cara lama itu bodoh.

-3 byte dengan menggerakkan inisialisasi variabel

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

Cobalah online!

Loop mengulangi array untuk mengisi 1. Mengembalikan array 1 dan 0.

05AB1E , 14 11 7 byte

n<ÝI<Öô

Cobalah online!

Penjelasan

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

Arang , 14 12 7 byte

^{-5 byte terima kasih kepada Neil !}

↗Ｎ⸿/‖Ｏ↘

Cobalah online!

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

Ini mengambil keuntungan dari perbedaan satu byte antara '#' dan 35

Mathematica, 72 byte

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

memasukkan

[5]

keluaran

1 0 0 0 1
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0 0 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

Cobalah online!

-24 byte: Berkat ide dari Rod!

PowerShell , 67 byte

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

Cobalah online!

Mengambil input $ndan loop dari 0ke --$n(yaitu, $npre-decremented). Setiap iterasi, kami membuat string 1diikuti dengan $n-1 0s, lalu mengalikan 3waktu itu (misalnya, 100010001000untuk input 5). Lalu kami indeks ke dalam itu secara bergiliran mulai dari 0ke 0 + $n. Karakter-karakter itu -joindiedarkan ke dalam sebuah string, yang tersisa di jalur pipa. Output tersirat.

(NB - Ini membutuhkan 9 byte tambahan untuk menangani kasus khusus n=1. Di bawah ini adalah kode 58-byte jika kami dijamin n>1)

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

Dyalog APL v16, 23 byte

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

Cobalah online!

Penjelasan:

{(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

Cobalah

Kode ini cukup sederhana. Ini menetapkan m ke argumen pertama, kemudian menambahkan 0 untuk mengubahnya menjadi angka, kemudian beralih ke belakang untuk koordinat Y, meneruskan melalui koordinat X dan akan menempatkan # jika x == y atau jika itu sudut lainnya.

Program ini tidak pernah menggunakan kata kunci "jika".

Oktaf, 37 byte

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

Cobalah online!

Menghasilkan matriks tipis yang mewakili tanda persen.

Japt , 12 byte

²ovUÉ hT1 òU

Mengembalikan array 2D / matriks.

Cobalah online!menggunakan -Qflag untuk menampilkan output berformat array.

Penjelasan

²ovUÉ hT1 òU

Tersirat: U= input integer

²o

Kuadrat U( ²), buat larik [0, U*U)( o), dan petakan setiap item dengan ...

vUÉ

1jika itu dapat dibagi ( v) oleh U-1( UÉ), yang lain 0.

hT1

Atur item ( h) pada indeks 0 ( T) ke 1.

òU

Pisahkan array menjadi irisan ( ò) dengan panjang U.

PHP, 53 byte

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

Panjang sisi matriks adalah $l. Kode ini memiliki Pemberitahuan PHP dan bahkan Peringatan PHP untuk pembagian sebanyak 0 saat $l=0, tetapi berhasil!

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

Cobalah online!

Ruby, 47 byte

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

Ini mengembalikan array array.

Kode ini cukup mudah.

• Itu menciptakan n-1array dengan 1sebagai elemen pertama dan sisanya diisi dengan 0s (misalnya [1, 0, 0, 0])
• Mengulanginya
• Dibutuhkan nirisan nelemen

Cobalah online!

J, 14 byte

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

Tidak Disatukan:

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

Cobalah online!

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

Penjelasan

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

Ini adalah pemahaman daftar, 0+(j==n-i-1)cara yang lebih pendek untuk mengkonversi j==n-i-1ke int (sebagai lawan dari intfungsi) dan kemudian m[-1]=m[0]lebih pendek daripada membuat kanan bawah 1, karena baris atas dan bawah identik.

Keempat, 273 (tanpa komentar) 170 (golf-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 ;

(273 versi untuk memperjelas versi komentar:)

: 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 ! ;

(Perhatikan bahwa, karena spasi putih adalah pembatas utama di Forth, menghapus setiap carriage return tidak akan ada bedanya. Lekukan, tentu saja, tidak.)

(Berkomentar:)

( 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 ! ;

(Contoh eksekusi:)

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

(Catatan akhir: berfungsi kurang dari satu lebar bit dari penerjemah Forth. Saya menjalankan di atas pada gforth, AMD64. Forth 16-bit kuno hanya akan memiliki lebar 15 bit, dan akan membutuhkan sedikit modifikasi.)

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

Cobalah online!

Algoritma secara signifikan berbeda dari jawaban C # lainnya, jadi saya memutuskan untuk mempostingnya secara terpisah daripada sebagai perbaikan. Terinspirasi oleh jawaban Jelly berperingkat teratas sebenarnya, saya melakukan sesuatu yang sedikit kurang kompak sebelumnya. Outputnya adalah array linier, jadi akan membutuhkan beberapa logika untuk membungkusnya menjadi 2D di luar metode apa adanya. Versi alternatif membutuhkan 6 byte tambahan untuk dihasilkan sebagai array 2D yang sebenarnya:

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

Saya juga memiliki versi yang tidak bersaing yang menarik.

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

Ini berakhir dengan hampir output yang benar, menghasilkan IEnumerable<bool>benar / salah bukan 1/0, dan itu adalah struktur linear daripada 2D, dan meskipun tidak diperlukan untuk baris kode yang tepat, using System.Collections.Genericdiperlukan untuk melakukan sesuatu yang berguna dengan keluaran. Seperti yang saya katakan, sangat dekat dengan valid tetapi tidak cukup.