Bei einer Ganzzahl n ≥ 1 wird eine 2D-Darstellung ^† eines Prozentzeichens der Breite n ausgegeben . Der Aufbau läuft wie folgt ab:

1. Erstellen eine n durch n - Matrix (oder eine Liste von Listen) , gefüllt mit Nullen.
2. Fügen Sie diese oben links und unten rechts ein.
3. Legen Sie diese von links unten nach rechts oben auf die Diagonale.

Für die Eingabe n = 4 würde diese Konstruktion folgendermaßen aussehen:

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

Dies ist ein Code-Golf , also gewinnt das kürzeste Programm in Bytes.

^† Ich verwende eine Matrix aus 1 und 0, aber es ist auch akzeptabel, Zeichen und Leerzeichen zu verwenden, die keine Leerzeichen sind. Das obige Beispiel könnte also so aussehen:

#  #
  # 
 #  
#  #

oder

#     #
    #
  # 
#     #

Testfälle

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

Schlussbemerkung

Das Hinzufügen einer Erklärung wäre sehr dankbar.

Gelee , 6 Bytes

²Rm’Ṭs

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

GNU APL, 17-15 Bytes

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

Dies ist ein seltsamer Tag ... GNU hat Dyalog APL tatsächlich besiegt ... woah.

TIO unterstützt GNU APL nicht ...

Erklärung (Eingabe ist ⍵):

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 Bytes

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

Probieren Sie es online!

Ausgänge mögen

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

Python 2 , 48 Bytes

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

Probieren Sie es online!

Ausgänge mögen

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

Python 3 , 48 Bytes

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

Probieren Sie es online!

Ein ganz anderer Ansatz zum Ersetzen von Strings in Python 3. Ausgaben wie:

1001
0010
0100
1001

Gelee , 9 Bytes

=þ¹UF1Q¦s

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Damit dies für Eingang 1 funktioniert, wurden 6 Bytes hinzugefügt.

Wenn wir uns Testfall 4 ansehen, sehen wir, dass die Ausgabe ist

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

Dies wird im Grunde genommen in der gesamten Matrix wiederholt. Mit anderen Worten, 1 0 0 wird in einer 4-mal-4-Matrix geformt. In dieser Lösung generieren wir diesen Vektor also zuerst mit 1 und nachgestellten 0en 1=⍳⍵-1und formen ihn dann mit ⍵ ⍵⍴. Aber das funktioniert für Eingang 1, also müssen wir eine Bedingung erstellen und 6 Bytes gewinnen ...

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

Zuerst bestand mein Ansatz darin, die transponierte Identitätsmatrix rekursiv zu generieren, aber dann erforderte die Korrektur der ersten und letzten Zeile einige hässliche / langwierige Fallunterscheidungen. Also suchte ich nach einem anderen Weg, um die Identitätsmatrix zu generieren, wie ich diese Idee fand.

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

Probieren Sie es online!

Erläuterung

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

generiert diese Matrix (für n=4):

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

Wie Sie sehen, ist das obere linke Element 2(im Allgemeinen), alle diagonalen Elemente sind 5(im Allgemeinen n+1) und das untere rechte Element ist 8(im Allgemeinen 2*n). Wir müssen also nur prüfen, ob x+yes sich um ein Element von handelt [2,n+1,2*n].

R , 54 42 Bytes

-12 Bytes dank Jarko Dubbeldam

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

gibt eine Matrix zurück; liest aus stdin. Erstellt eine Identitätsmatrix diag(n), dreht sie von oben nach unten [,n:1], setzt oben links und unten rechts auf 1und schreibt dann ''mit der Breite in console ( )n .

Probieren Sie es online!

MATL , 7 Bytes

XyPl5L(

Probieren Sie es bei MATL Online!

Erläuterung

Erstelle eine Identitätsmatrix ( Xy), drehe sie vertikal ( P) um und schreibe ( () den Wert 1 ( l) zu den ersten und letzten Einträgen ( 5L), die oben links und unten rechts sind.

Dyalog APL, 12 11 10 Bytes

,⍨⍴×,2↓⊢↑×

Probieren Sie es online aus

-1 Byte dank lstefano.

Wie?

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

-30 Bytes, weil der alte Weg dumm war.

-3 Bytes durch Bewegen der Variableninitialisierung

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

Probieren Sie es online!

Loops durchlaufen das Array, um die Einsen auszufüllen. Gibt ein Array von 1 und 0 zurück.

05AB1E , 14 11 7 Bytes

n<ÝI<Öô

Probieren Sie es online!

Erläuterung

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

Kohle , 14 12 7 Bytes

^{-5 Bytes danke an Neil !}

↗Ｎ⸿/‖Ｏ↘

Probieren Sie es online!

C ++, 144 Bytes

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

Die 1-Byte-Differenz zwischen '#' und 35 wird ausgenutzt

Mathematica, 72 Bytes

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

Eingang

[5]

Ausgabe

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 Bytes

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

Probieren Sie es online!

-24 Bytes: Dank einer Idee von Rod!

PowerShell , 67 Byte

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

Probieren Sie es online!

Übernimmt Eingaben $nund Schleifen von 0bis --$n(dh $nvordekrementiert). Bei jeder Iteration konstruieren wir eine Folge von 1gefolgt von $n-1 0s und multiplizieren diese aus den 3Zeiten (z. B. 100010001000für die Eingabe von 5). Dann indizieren wir das abwechselnd von 0bis 0 + $n. Diese Zeichen werden -joinzu einer Zeichenfolge zusammengefasst, die in der Pipeline verbleibt. Die Ausgabe ist implizit.

(NB - Dies erfordert zusätzliche 9 Bytes, um den Sonderfall von zu behandeln n=1. Unten ist der 58-Byte-Code, wenn wir garantiert sind. n>1)

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

Dyalog APL v16, 23 Bytes

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

Probieren Sie es online!

Erläuterung:

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

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

Versuch es

Code ist ziemlich einfach. Es setzt m auf das erste Argument, fügt 0 hinzu, um es in eine Zahl umzuwandeln, iteriert dann rückwärts für die Y-Koordinate, vorwärts durch die X-Koordinate und setzt ein #, wenn x == y oder wenn es die anderen Ecken sind.

Dieses Programm verwendet niemals das Schlüsselwort "if".

Oktave, 37 Bytes

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

Probieren Sie es online!

Erzeugt eine dünne Matrix, die das Prozentzeichen darstellt.

Japt , 12 Bytes

²ovUÉ hT1 òU

Gibt ein 2D-Array / eine 2D-Matrix zurück.

Probieren Sie es online! Verwendung der-Q Flag, um die Ausgabe im Array-Format anzuzeigen.

Erläuterung

²ovUÉ hT1 òU

Implizit: U= Ganzzahl eingeben

²o

Square U( ²), erstelle das Array [0, U*U)( o) und ordne jedes Element ...

vUÉ

1wenn es vdurch U-1( UÉ) teilbar ist , sonst 0.

hT1

Stellen Sie den Punkt ( h) bei Index 0 ( T) auf 1.

òU

Teilen Sie das Array in Segmente ( ò) mit einer Länge auf U.

PHP, 53 Bytes

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

Die Länge der Seite der Matrix beträgt $l. Dieser Code hat einen PHP-Hinweis und sogar eine PHP-Warnung für die Division durch 0, wenn $l=0, aber macht den Job!

Python 2 , 93 Bytes

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

Probieren Sie es online!

Ruby, 47 Bytes

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

Es gibt ein Array von Arrays zurück.

Der Code ist ziemlich einfach.

• Es erzeugt ein n-1Array mit 1als erstem Element und den Rest mit 0s (zB [1, 0, 0, 0])
• Es wiederholt es
• Es dauert nScheiben von nElementen

Probieren Sie es online!

J, 14 Bytes

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

Ungolfed:

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

Probieren Sie es online!

Python 3, 97 Bytes

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

Erläuterung

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

Dies ist ein Listenverständnis. Dies ist eine 0+(j==n-i-1)kürzere Methode zum Konvertieren j==n-i-1in ein int (im Gegensatz zu intfunction) und ist dann m[-1]=m[0]kürzer als das Erstellen von bottom right 1, da die oberen und unteren Zeilen identisch sind.

Forth, 273 (ohne Kommentare) 170 (Golfspiel)

: % 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 Version zur Klarstellung der kommentierten Version:)

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

(Beachten Sie, dass das Entfernen jedes Wagenrücklaufs keinen Unterschied macht, da Leerzeichen das primäre Begrenzungszeichen in Forth ist. Einrückung natürlich.)

(Kommentiert:)

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

(Ausführungsbeispiele:)

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

(Letzte Anmerkung: Funktioniert mit einem Wert, der kleiner als die Bitbreite des Forth-Interpreters ist. Ich habe den obigen Befehl auf gforth, AMD64, ausgeführt. Ein alter 16-Bit-Forth würde nur eine Breite von 15 Bit haben und eine gewisse Modifikation erfordern.)

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

Probieren Sie es online!

Der Algorithmus unterscheidet sich erheblich von der anderen C # -Antwort, daher habe ich mich entschieden, ihn separat und nicht als Verbesserung zu veröffentlichen. Inspiriert von der bestbewerteten Jelly-Antwort, habe ich vorher etwas weniger Kompaktes gemacht. Die Ausgabe ist ein lineares Array, daher ist eine gewisse Logik erforderlich, um sie außerhalb der eigentlichen Methode in ein 2D-Array zu verpacken. Eine alternative Version benötigt 6 zusätzliche Bytes, um als echtes 2D-Array auszugeben:

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

Ich habe auch eine interessante nicht konkurrierende Version.

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

Dies führt zu fast der richtigen Ausgabe, was zu einem IEnumerable<bool>mit true / false anstelle von 1/0 führt, und es ist eher eine lineare als eine 2D-Struktur, und obwohl dies für die genaue Codezeile nicht benötigt wird, using System.Collections.Genericist es notwendig, etwas Nützliches mit dem zu tun Ausgabe. Wie ich schon sagte, es ist sehr nahe daran, gültig zu sein, aber nicht ganz.