整数所与N ≥1、出力2次元表現^†幅のパーセント記号のN。構成は次のとおりです。

1. 作成のnをすることにより、n個のマトリックス（またはリストのリスト）ゼロでいっぱい。
2. 左上隅と右下隅に挿入します。
3. 対角線上に左下から右上に配置します。

入力n = 4の場合、この構造は次のようになります。

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

これはcode-golfであるため、バイト単位の最短プログラムが優先されます。

^† 1と0のマトリックスを使用しますが、空白以外の文字とスペースの文字列を使用することも許容されます。したがって、上記の例は次のようになります。

#  #
  # 
 #  
#  #

または

#     #
    #
  # 
#     #

テストケース

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

最後のメモ

説明を追加していただければ幸いです。

ゼリー、6バイト

²Rm’Ṭs

オンラインでお試しください！

使い方

²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バイト

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

V、15バイト

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

オンラインでお試しください！

説明

Àé<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バイト

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

オンラインでお試しください！

GNU APL、17 15バイト

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

これは奇妙な一日です... GNUは実際にDyalog APLを打ち負かしました...ああ。

TIOはGNU APLをサポートしていません...

説明（入力は⍵）：

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バイト

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

オンラインでお試しください！

のような出力

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

Python 2、48バイト

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

オンラインでお試しください！

のような出力

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

Python 3、48バイト

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

オンラインでお試しください！

Python 3のまったく異なる文字列置換アプローチ。次のような出力。

1001
0010
0100
1001

ゼリー、9バイト

=þ¹UF1Q¦s

オンラインでお試しください！

使い方

=þ¹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バイト

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

オンラインでお試しください！

入力1でこの作業を行うと、6バイトが追加されます。

テストケース4を見ると、出力が

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

これは基本的にマトリックス全体で繰り返される1 0 0です。言い換えると、4行4列の行列に整形された1 0 0です。したがって、このソリューションでは、最初に1を使用してこのベクトルを生成し1=⍳⍵-1、0を使用して後続の0を生成し⍵ ⍵⍴ます。しかし、これは入力1を妨げるため、条件を作成して6バイトを獲得する必要があります...

{⍵=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バイト

最初は、転置された恒等行列を再帰的に生成するアプローチでしたが、最初と最後の行を修正するには、ugい/長いケースの区別が必要でした。それで、私はこの考えを見つけたアイデンティティ行列を生成する別の方法を探しました。

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

オンラインでお試しください！

説明

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

この行列を生成します（n=4）：

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

ご覧のとおり、左上の要素は2（一般的に）、すべての対角要素は5（一般的にn+1）、右下の要素は8（一般的に2*n）です。したがって、必要なのx+yは、の要素かどうかを確認することだけです[2,n+1,2*n]。

R、54 42バイト

Jarko Dubbeldamのおかげで-12バイト

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

マトリックスを返します。stdinから読み取ります。アイデンティティマトリックスを作成し、diag(n)それを上から下に反転し[,n:1]、左上と右下を設定し1、そして''幅でconsole（）に書き込みますn。

オンラインでお試しください！

MATL、7バイト

XyPl5L(

MATL Onlineでお試しください！

説明

単位行列を作成（Xy）、垂直に反転（P）、(値1（l）を最初と最後のエントリ（5L）（左上と右下）に書き込みます。

Dyalog APL、12 11 10バイト

,⍨⍴×,2↓⊢↑×

オンラインで試す

lstefanoのおかげで-1バイト。

どうやって？

,⍨⍴×,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バイト

古い方法は愚かだったので、-30バイト。

変数の初期化を移動することにより、-3バイト

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

オンラインでお試しください！

ループは配列を反復して1を埋めます。1と0の配列を返します。

05AB1E、14 11 7バイト

n<ÝI<Öô

オンラインでお試しください！

説明

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

炭、14 12 7バイト

^{ニールのおかげで-5バイト！}

↗Ｎ⸿/‖Ｏ↘

オンラインでお試しください！

C ++、144バイト

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

'＃'と35の1バイトの違いを利用します

Mathematica、72バイト

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

入力

[5]

出力

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

パイソン2、86の 62バイト

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

オンラインでお試しください！

-24バイト：Rodのアイデアのおかげです！

PowerShell、67バイト

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

オンラインでお試しください！

入力を受け取り$n、0to からループします--$n（つまり、$n事前にデクリメントされます）。繰り返しごとに、s が1続く文字列を作成し、$n-1 0その出力3時間を乗算します（たとえば、100010001000入力の場合5）。次に、から開始し0て順番にインデックスを作成し0 + $nます。これらの文字は-join文字列に変換され、パイプラインに残ります。出力は暗黙的です。

（NB-これには、特殊なケースを処理するために追加の9バイトが必要ですn=1。以下が保証されている場合の58バイトのコードですn>1）

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

Dyalog APL v16、23バイト

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

オンラインでお試しください！

説明：

{(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バイト

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

それを試してみてください

コードはとても簡単です。最初の引数にmを設定し、0を追加して数値に変換し、Y座標に対して逆方向に反復し、X座標を順方向に反復し、x == yの場合、または他のコーナーの場合は＃を配置します。

このプログラムは、キーワード「if」を使用しません。

オクターブ、37バイト

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

オンラインでお試しください！

パーセント記号を表すスパース行列を生成します。

Japt、12バイト

²ovUÉ hT1 òU

2D配列/行列を返します。

オンラインでお試しください！を使用して-Qフラグを配列形式の出力を表示します。

説明

²ovUÉ hT1 òU

暗黙的：U=入力整数

²o

正方形U（²）、配列[0, U*U)（o）を作成し、各項目をマッピングする...

vUÉ

1（v）で割り切れる場合U-1（UÉ）、else 0。

hT1

hインデックス0（T）のアイテム（）をに設定します1。

òU

配列をò長さのスライス（）に分割しUます。

PHP、53バイト

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

行列の辺の長さは$lです。このコードには、PHP通知があり、0で除算する場合のPHP警告もあります$l=0が、機能します！

Python 2、93バイト

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

オンラインでお試しください！

ルビー、47バイト

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

配列の配列を返します。

コードは非常に簡単です。

• 最初の要素としてn-1配列を作成し1、残りを0sで埋めます（例：[1, 0, 0, 0]）
• 繰り返す
• 要素のnスライスを取りnます

オンラインでお試しください！

J、14バイト

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

ゴルフをしていない：

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

オンラインでお試しください！

Python 3、97バイト

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

説明

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

これはリストの内包表記であり、（関数ではなく）int 0+(j==n-i-1)に変換するより短い方法であり、上下の行が同じであるため、右下1にするよりも短くなります。j==n-i-1intm[-1]=m[0]

Forth、273（コメントなし） 170（ゴルフ風）

: % 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バージョン：）

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

（空白はForthの主要な区切り文字なので、すべてのキャリッジリターンを削除しても違いはありません。インデントはもちろん違います。）

（コメント：）

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

（実行例：）

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

（最後のメモ：Forthインタープリターのビット幅よりも1つ小さい範囲で動作します。gforth、AMD64で上記を実行しました。古代の16ビットForthは15ビット幅にしかならず、少し変更する必要があります。）

C＃（.NET Core）、65バイト

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

オンラインでお試しください！

このアルゴリズムは他のC＃の回答とは大きく異なるため、改善としてではなく、個別に投稿することにしました。実際にトップ評価のゼリーの答えに触発されて、私は以前は少しコンパクトなものをやっていました。出力は線形配列であるため、メソッドの外部の2Dにそのままラップするには、何らかのロジックが必要です。別のバージョンでは、真の2D配列として出力するために6バイト追加する必要があります。

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

面白い非競合バージョンもあります。

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

これは、ほぼ正しい出力になり、IEnumerable<bool>1/0ではなくtrue / falseになり、2D構造ではなく線形になります。その正確なコード行にusing System.Collections.Genericは必要ありませんが、出力。私が言ったように、それは有効であることに非常に近いが、完全ではありません。