Bir tamsayıyı verilen n 2B gösterimi ≥ 1, çıkış ^† genişliği olan bir yüzde işareti n . İnşaat aşağıdaki gibi gider:

1. Bir oluşturma n ile n sıfır ile dolu matris (veya listelerin liste).
2. Sol üst ve sağ alt köşelere olanlar yerleştirin.
3. Bunları köşegen sol alttan sağ üst köşeye yerleştirin.

N = 4 girişi için bu yapı şöyle görünür:

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

Bu bir kod golf , yani bayt cinsinden en kısa program kazanır.

^† 1s ve 0s bir matris kullanırım, ancak boşluk olmayan karakter ve boşluklardan oluşan bir dize kullanmak da kabul edilebilir. Yani, yukarıdaki örnek şöyle görünebilir:

#  #
  # 
 #  
#  #

veya

#     #
    #
  # 
#     #

Test durumları

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

Son not

Bir açıklama eklemek büyük memnuniyet duyacaktır.

Jöle , 6 bayt

²Rm’Ṭs

Çevrimiçi deneyin!

Nasıl çalışır

²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 bayt

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

V , 15 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

GNU APL, 17 15 bayt

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

Bu garip bir gün ... GNU aslında Dyalog APL'yi yendi.

TIO GNU APL'yi desteklemiyor ...

Açıklama (giriş ⍵):

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 bayt

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

Çevrimiçi deneyin!

Çıkışlar gibi

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

Python 2,48 bayt

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

Çevrimiçi deneyin!

Çıkışlar gibi

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

Python 3 , 48 bayt

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

Çevrimiçi deneyin!

Python 3'te oldukça farklı bir string-ikame yaklaşımı. Çıktılar:

1001
0010
0100
1001

Jöle , 9 bayt

=þ¹UF1Q¦s

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Giriş 1 için bu işi yapmak 6 bayt ekledi.

Test 4'e bakıldığında çıktının görüldüğünü görüyoruz.

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

Bu temelde matris boyunca 10 0 tekrar edilir. Başka bir deyişle, 4'e 4 matris şeklinde 1 0 0. Bu nedenle, bu çözümde, ilk önce bu vektörü 1 kullanarak 1=⍳⍵-1ve 0'ı izleyerek kullanırız ve sonra onu şekillendiririz ⍵ ⍵⍴. Fakat bu girdi 1 için borçlanıyor, bu yüzden bir koşullu yaratmalı ve 6 bayt kazanmalıyız ...

{⍵=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 bayt

İlk önce benim yaklaşımım, aktarılan kimlik matrisini tekrarlı bir şekilde oluşturmaktı, ancak sonra ilk ve son çizgiyi düzeltmek, çirkin / uzun vaka ayrımları gerektiriyordu. Ben de bu fikri nasıl bulduğumu tanımlayan matris oluşturmak için başka bir yol aradım .

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

Çevrimiçi deneyin!

açıklama

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

bu matrisi oluşturur (için n=4):

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

Gördüğünüz gibi sol üst öğe 2(genel olarak), tüm çapraz öğeler 5(genel olarak n+1) ve sağ alt öğe 8(genel olarak 2*n) 'dir. Yani tek yapmamız gereken x+ybir unsurun olup olmadığını kontrol etmek [2,n+1,2*n].

R , 54 42 bayt

Jarko Dubbeldam sayesinde -12 bayt

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

bir matris döndürür; stdin'den okur. bir kimlik matrisi oluşturur , yukarıdan aşağıya doğru diag(n)döndürür [,n:1], sol üst ve alt sağa ayarlar, 1sonra ''genişlikle konsoluna ( ) yazar n.

Çevrimiçi deneyin!

MATL , 7 bayt

XyPl5L(

MATL Online'da deneyin !

açıklama

Kimlik matrisi ( Xy) oluşturun, dikey olarak çevirin ( P), write ( () değer 1 l( 5L), sol üst ve sağ alt olan ilk ve son girişlere ( ) ( ).

Dyalog APL, 12 11 10 bayt

,⍨⍴×,2↓⊢↑×

Çevrimiçi deneyin

Lstefano sayesinde -1 bayt.

Nasıl?

,⍨⍴×,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 bayt

-30 bayt çünkü eski yol aptaldı.

Değişken başlatma etrafında hareket ederek -3 bayt

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

Çevrimiçi deneyin!

Döngüler, 1'leri doldurmak için diziyi aşağı iter. 1 ve 0'ın bir dizisini döndürür.

05AB1E , 14 11 7 bayt

n<ÝI<Öô

Çevrimiçi deneyin!

açıklama

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

Kömür , 14 12 7 bayt

^{-5 sayesinde bayt Neil !}

↗Ｎ⸿/‖Ｏ↘

Çevrimiçi deneyin!

C ++, 144 bayt

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

'#' Ve 35 arasındaki bir bayt farkından yararlanır

Mathematica, 72 bayt

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

giriş

[5]

çıktı

1 0 0 0 1
0 0 0 1 0
0 0 1 0 0
0 0 1 0 0 0
1 0 0 0 1 ÖREME

Python 2 , 86 62 bayt

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

Çevrimiçi deneyin!

-24 bytes: Rod'dan bir fikir sayesinde!

PowerShell , 67 bayt

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

Çevrimiçi deneyin!

Giriş alır $ngelen ve döngüler 0için --$n(diğer bir deyişle, $nön-azaltılır). Her yineleme, onu 1takip eden bir dizge oluştururuz $n-1 0, sonra bunu zaman 3zamanını çarpın (örneğin, 100010001000giriş için 5). Sonra başlayarak dönüşümlü olarak o içine dizine 0için 0 + $n. Bu karakterler -join, boru hattında bırakılan bir dize içine yazılır. Çıktı kapalı.

(Not - Bu, özel durumun ele alınması için ek bir 9 bayt gerektirir n=1. Garantili olmamız durumunda 58-byte kodu aşağıdadır n>1)

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

Dyalog APL v16, 23 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

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

Dene

Kod oldukça basit. M'yi ilk argümana ayarlar, sonra bir sayıya dönüştürmek için 0 ekler, ardından Y koordinatı için geriye doğru yinelenir, X koordinatından ileriye doğru gider ve # = x == y ise veya diğer köşelerde ise # koyar.

Bu program hiçbir zaman "if" anahtar sözcüğünü kullanmaz.

Octave, 37 bayt

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

Çevrimiçi deneyin!

Yüzde işaretini temsil eden seyrek bir matris oluşturur.

Japt , 12 bayt

²ovUÉ hT1 òU

2B dizi / matris döndürür.

Çevrimiçi deneyin! -Qdizi biçiminde çıktı göstermek için bayrak kullanma .

açıklama

²ovUÉ hT1 òU

Kapalı: U= tamsayı girişi

²o

Square U( ²), array [0, U*U)( o) oluşturun ve her öğeyi ... ile eşleştirin

vUÉ

1bölünebilir ise ( v) ile U-1( UÉ), başka şekilde 0.

hT1

h0 ( T) dizinindeki öğeyi ( ) olarak ayarlayın 1.

òU

Diziyi dilimlere ayırın (ò uzunluktaki )U .

PHP, 53 bayt

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

Matrisin kenarının uzunluğu $l. Bu kod bir PHP Bildirimi'ne ve hatta 0'a bölündüğü zaman bir PHP Uyarısına sahiptir $l=0, ancak işi yapar!

Python 2 , 93 bayt

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

Çevrimiçi deneyin!

Ruby, 47 bayt

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

Bir dizi dizisi döndürür.

Kod oldukça basit.

• İlk eleman olarak bir n-1dizi oluşturur 1ve geri kalanı 0s ile doldurulur (örn.[1, 0, 0, 0] )
• Onu tekrarlar
• Öğelerin ndilimlerini alırn

Çevrimiçi deneyin!

J, 14 bayt

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

Ungolfed:

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

Çevrimiçi deneyin!

Python 3, 97 bayt

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

açıklama

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

Bu bir liste kavramadır, 0+(j==n-i-1)bir int'ye dönüştürmek j==n-i-1için daha kısa bir yoldur ( intişlev yerine) ve sonra m[-1]=m[0]üst ve alt sıralar aynı olduğundan, sağ alt 1 yapmaktan daha kısadır.

İleri, 273 (yorumsuz ) 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 yorum yorumlanan sürümü netleştirmek için:)

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

(Boşluk, Forth'taki birincil sınırlayıcı olduğundan, her satır başının kaldırılmasının bir fark yaratmayacağına dikkat edin. Girinti, elbette.)

(Yorumlandı:)

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

(Yürütme örnekleri:)

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

(Son not: Forth tercümanının bit genişliğinden daha azına çalışır. Yukarıdakileri AMD64 gforth'da koştum. Eski bir 16-bit Forth sadece 15 bit genişliğe gider ve biraz modifikasyona ihtiyaç duyardı.)

C # (.NET Core) , 65 bayt

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

Çevrimiçi deneyin!

Algoritma, diğer C # cevabından belirgin bir şekilde farklıdır, bu yüzden bir geliştirme yerine ayrı ayrı göndermeye karar verdim. En çok oy alan Jelly cevabından esinlenerek, daha önce biraz daha az kompakt bir şey yapıyordum. Çıktı doğrusal bir dizidir, bu yüzden olduğu gibi yöntemin dışında bir 2D'ye sarmak için bir miktar mantık gerektirir. Alternatif bir sürüm, gerçek bir 2D dizi olarak çıktısı almak için 6 ek byte gerektirir:

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

Ayrıca ilginç olmayan rakip bir versiyonum da var.

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

Bu hemen hemen doğru çıktıyla sonuçlanır IEnumerable<bool>ve 1/0 yerine true / false ile sonuçlanır ve 2D yapısından ziyade lineerdir ve bu kesin kod satırı için gerekli olmasa using System.Collections.Genericda, çıktı. Dediğim gibi, geçerli olmak için çok yakın ama tam değil.