정수 n ≥ 1이 주어지면, 너비 n 의 퍼센트 부호의 2D 표현 ^† 을 출력하십시오 . 구성은 다음과 같습니다.

1. 0으로 채워진 n x 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.

자바 스크립트 (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

파이썬 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을 능가했습니다 ... woah.

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

파이썬 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')]

파이썬 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)]

파이썬 3 , 48 바이트

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

온라인으로 사용해보십시오!

파이썬 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 반복됩니다. 다시 말해, 1 0 0은 4x4 행렬로 형성됩니다. 따라서이 솔루션에서는 먼저 1을 사용하여 후행 0으로이 벡터를 생성 한 다음를 사용하여 1=⍳⍵-1모양을 ⍵ ⍵⍴만듭니다. 그러나 이것은 입력 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

하스켈 , 55 바이트

처음에 나의 접근법은 재귀 적으로 전치 된 항등 행렬을 생성하는 것이었지만 첫 번째 줄과 마지막 줄을 수정하려면 추악하고 긴 경우가 필요했습니다. 그래서 저는 이 아이디어를 찾은 방법으로 항등 행렬을 생성하는 다른 방법을 찾았습니다 .

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

이 행렬을 생성합니다 (for 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한 다음 ''너비 가있는 콘솔 ( )에 씁니다 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 코어) , 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 바이트

^{Neil 덕분에 -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에서와 루프 0에 --$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)

루아, 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입니다. 이 코드에는 when $l=0및 0으로 나누기위한 PHP Notice 및 PHP Warning이 있지만 작업을 수행합니다!

파이썬 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))

온라인으로 사용해보십시오!

파이썬 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]

넷째, 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 인터프리터의 비트 너비보다 작은 너비로 작동합니다. AMD gforth에서 위의 코드를 실행했습니다. 16 비트 Forth는 15 비트 너비에 불과하며 약간의 수정이 필요합니다.)

C # (. NET 코어) , 65 바이트

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

온라인으로 사용해보십시오!

알고리즘은 다른 C # 답변과 크게 다르므로 개선보다는 별도로 게시하기로 결정했습니다. 실제로 최고 등급의 Jelly 답변에서 영감을 얻은 결과 이전에는 약간 덜 컴팩트 한 작업을 수행했습니다. 출력은 선형 배열이므로 메소드 외부의 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의 참 /의 거짓과, 그것이 오히려 2D 구조보다 선형, 그리고 코드의 정확한 라인에 필요하지 않지만, using System.Collections.Generic유용 아무것도 할 필요가있다 산출. 내가 말했듯이, 그것은 유효하지는 않지만 매우 가깝습니다.