Biorąc pod uwagę liczbę całkowitą n ≥ 1, wyświetl dwuwymiarową reprezentację ^† znaku procentu szerokości n . Konstrukcja wygląda następująco:

1. Utwórz macierz n na n (lub listę list) wypełnioną zerami.
2. Wstaw je w lewym górnym i prawym dolnym rogu.
3. Umieść je po przekątnej od lewego dolnego rogu do prawego górnego rogu.

Dla danych wejściowych n = 4 ta konstrukcja wyglądałaby następująco:

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

To jest golf golfowy , więc wygrywa najkrótszy program w bajtach.

^† Używam macierzy 1 i 0, ale dopuszczalne jest również użycie ciągów znaków i spacji niebiałych białych znaków. Tak więc powyższy przykład może wyglądać następująco:

#  #
  # 
 #  
#  #

lub

#     #
    #
  # 
#     #

Przypadki testowe

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

Ostatnia uwaga

Bardzo byłoby mile widziane dodanie wyjaśnienia.

Galaretka , 6 bajtów

²Rm’Ṭs

Wypróbuj online!

Jak to działa

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

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

V , 15 bajtów

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

Wypróbuj online!

Wyjaśnienie

Àé<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 bajtów

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

Wypróbuj online!

GNU APL, 17 15 bajtów

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

To jest jeden dziwny dzień ... GNU faktycznie pokonało Dyalog APL ... woah.

TIO nie obsługuje GNU APL ...

Objaśnienie (wejście jest ⍵):

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 bajtów

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

Wypróbuj online!

Wyjścia jak

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

Python 2 , 48 bajtów

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

Wypróbuj online!

Wyjścia jak

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

Python 3 , 48 bajtów

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

Wypróbuj online!

Zupełnie inne podejście do podstawiania ciągów w Pythonie 3. Dane wyjściowe, takie jak:

1001
0010
0100
1001

Galaretka , 9 bajtów

=þ¹UF1Q¦s

Wypróbuj online!

Jak to działa

=þ¹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 bajtów

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

Wypróbuj online!

Aby ta praca działała dla wejścia 1, dodano 6 bajtów.

Patrząc na przypadek testowy 4, widzimy wynik

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

Zasadniczo jest to 1 0 0 powtarzane w całej matrycy. Innymi słowy, 1 0 0 ukształtowany w matrycy 4 na 4. Tak więc w tym rozwiązaniu najpierw generujemy ten wektor z 1 i końcowymi zerami za pomocą, 1=⍳⍵-1a następnie kształtujemy go za pomocą ⍵ ⍵⍴. Ale to borks dla wejścia 1, więc musimy stworzyć warunek i uzyskać 6 bajtów ...

{⍵=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 bajtów

Początkowo moim podejściem było rekurencyjne generowanie transponowanej macierzy tożsamości, ale następnie ustalenie pierwszej i ostatniej linii wymagało pewnych brzydkich / długich rozróżnień wielkości liter. Więc szukałem innego sposobu na wygenerowanie matrycy tożsamości, w jaki sposób znalazłem ten pomysł.

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

Wypróbuj online!

Wyjaśnienie

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

generuje tę macierz (dla n=4):

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

Jak widać, lewy górny element to 2(ogólnie), wszystkie elementy ukośne to 5(ogólnie n+1), a dolny prawy element to 8(ogólnie 2*n). Więc wszystko, co musimy zrobić, to sprawdzić, czy x+yjest elementem [2,n+1,2*n].

R , 54 42 bajtów

-12 bajtów dzięki Jarko Dubbeldam

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

zwraca macierz; czyta ze standardowego. tworzy matrycę tożsamości diag(n), odwraca ją od góry do dołu [,n:1], ustawia lewy górny i prawy dolny na 1, a następnie zapisuje w konsoli ( '') o szerokości n.

Wypróbuj online!

MATL , 7 bajtów

XyPl5L(

Wypróbuj w MATL Online!

Wyjaśnienie

Utwórz macierz tożsamości ( Xy), odwróć w pionie ( P), napisz ( () wartość 1 ( l) do pierwszego i ostatniego wpisu ( 5L), które są lewym górnym i prawym dolnym rogu.

Dyalog APL, 12 11 10 bajtów

,⍨⍴×,2↓⊢↑×

Wypróbuj online

-1 bajt dzięki lstefano.

W jaki sposób?

,⍨⍴×,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 bajtów

-30 bajtów, bo stary sposób był głupi.

-3 bajty poprzez zmianę inicjalizacji zmiennej

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

Wypróbuj online!

Pętle iterują tablicę, wypełniając jedynki. Zwraca tablicę 1 i 0.

05AB1E , 14 11 7 bajtów

n<ÝI<Öô

Wypróbuj online!

Wyjaśnienie

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

Węgiel drzewny , 14 12 7 bajtów

^{-5 bajtów dzięki Neilowi !}

↗Ｎ⸿/‖Ｏ↘

Wypróbuj online!

C ++, 144 bajty

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

Wykorzystuje różnicę jednobajtową między „#” a 35

Mathematica, 72 bajty

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

wkład

[5]

wydajność

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 bajtów

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

Wypróbuj online!

-24 bajty: Dzięki pomysłowi Rod!

PowerShell , 67 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe $ni pętle od 0do --$n(tj. $nWstępnie dekrementowane). Podczas każdej iteracji tworzymy ciąg znaków 1poprzedzony $n-1 0s, a następnie mnożymy te 3czasy (np. 100010001000Dla wprowadzenia 5). Następnie indeksujemy to rotacyjnie, zaczynając od 0do 0 + $n. Znaki te są -joinedytowane w ciąg, który pozostawia się w potoku. Wynik jest niejawny.

(Uwaga: Wymaga to dodatkowych 9 bajtów, aby obsłużyć specjalny przypadek n=1. Poniżej znajduje się 58-bajtowy kod, jeśli mamy gwarancję n>1)

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

Dyalog APL v16, 23 bajty

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

Wypróbuj online!

Wyjaśnienie:

{(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 bajtów

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

Spróbuj

Kod jest dość prosty. Ustawia m na pierwszy argument, następnie dodaje do niego 0, aby przekonwertować go na liczbę, a następnie iteruje do tyłu dla współrzędnej Y, do przodu przez współrzędną X i wstawi # jeśli x == y lub jeśli są to pozostałe rogi.

Ten program nigdy nie używa słowa kluczowego „if”.

Oktawa, 37 bajtów

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

Wypróbuj online!

Generuje rzadką macierz reprezentującą znak procentu.

Japt , 12 bajtów

²ovUÉ hT1 òU

Zwraca tablicę / macierz 2D.

Wypróbuj online! używając-Q flagi, aby wyświetlić wyjście w formacie tablicowym.

Wyjaśnienie

²ovUÉ hT1 òU

Implikowany: U= liczba całkowita wejściowa

²o

Square U( ²), utwórz tablicę [0, U*U)( o) i zamapuj każdy element przez ...

vUÉ

1jeśli jest podzielna ( v) przez U-1( UÉ), else 0.

hT1

Ustaw pozycję ( h) w indeksie 0 ( T) na 1.

òU

Podziel tablicę na plasterki ( ò) o długości U.

PHP, 53 bajty

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

Długość boku matrycy wynosi $l. Ten kod zawiera Powiadomienie PHP, a nawet Ostrzeżenie PHP dla dzielenia przez 0 kiedy $l=0, ale działa!

Python 2 , 93 bajty

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

Wypróbuj online!

Ruby, 47 bajtów

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

Zwraca tablicę tablic.

Kod jest dość prosty.

• Tworzy n-1tablicę 1jako pierwszy element, a resztę wypełnia 0s (np. [1, 0, 0, 0])
• Powtarza to
• Zajmuje nplastry nelementów

Wypróbuj online!

J, 14 bajtów

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

Nie golfowany:

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

Wypróbuj online!

Python 3, 97 bajtów

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

Wyjaśnienie

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

Jest to zrozumienie listy, 0+(j==n-i-1)jest to krótszy sposób na konwersję j==n-i-1na int (w przeciwieństwie do intfunkcji), a następnie m[-1]=m[0]jest krótszy niż wykonanie prawej dolnej 1, ponieważ górne i dolne rzędy są identyczne.

Dalej, 273 (bez komentarzy) 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 ;

(Wersja 273 w celu wyjaśnienia wersji komentowanej:)

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

(Zauważ, że ponieważ białe znaki są głównym ogranicznikiem w Forth, usunięcie każdego powrotu karetki nie zrobiłoby żadnej różnicy. Wcięcie oczywiście tak.)

(Skomentowane:)

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

(Przykłady wykonania:)

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

(Uwaga końcowa: działa do jednego bitu mniej niż szerokość interpretera Fortha. Uruchomiłem powyższe na gforth, AMD64. Starożytny 16-bitowy Forth miałby szerokość tylko 15 bitów i wymagałby niewielkiej modyfikacji.)

C # (.NET Core) , 65 bajtów

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

Wypróbuj online!

Algorytm różni się znacznie od innych odpowiedzi w języku C #, więc postanowiłem opublikować go osobno, a nie jako ulepszenie. Zainspirowany faktycznie najlepiej ocenianą odpowiedzią Jelly, robiłem wcześniej coś nieco mniej kompaktowego. Dane wyjściowe są tablicą liniową, więc wymagałoby to pewnej logiki, aby zawinąć je w 2D poza metodą w obecnej postaci. Alternatywna wersja wymaga 6 dodatkowych bajtów do wyprowadzenia jako prawdziwa tablica 2D:

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

Mam też ciekawą, niekonkurującą wersję.

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

W efekcie uzyskuje się prawie prawidłowy wynik, co daje w wyniku IEnumerable<bool>true / false zamiast 1/0, i jest to struktura raczej liniowa niż 2D, i chociaż nie jest potrzebna dla tej dokładnej linii kodu, using System.Collections.Genericjest niezbędna do zrobienia czegokolwiek przydatnego z wydajność. Tak jak powiedziałem, jest to bardzo ważne, ale nie do końca.