Rechtecke haben diese nette Eigenschaft - ein Rechteck besteht aus genau Zeichen!$n \times m$$n \times m$

Eine interessantere Eigenschaft ist, dass die Rechtecke in einer Multiplikationstabelle gut ausgerichtet werden können - zum Beispiel in einer Tabelle:$3 \times 3$

# ## ###

# ## ###
# ## ###

# ## ###
# ## ###
# ## ###

Ihre Herausforderung besteht darin, bei einer gegebenen Zahl ( ) eine formatierte Multiplikationstabelle auszugeben .$n$$n > 1$$n \times n$

Regeln

• Sie können die Eingabe oberhalb oder unterhalb von$n$
• Es gelten die Standard-E / A-Regeln
• Sie können ein beliebiges Nicht-Leerzeichen auswählen, um die Blöcke darzustellen. Jedes andere Zeichen (obwohl Zeilenumbrüche etwas Besonderes sind) wird als Leerzeichen betrachtet. Das gewählte Zeichen kann für verschiedene Eingaben unterschiedlich sein, muss jedoch für die gesamte Eingabe gleich sein
• Das Ergebnis kann nicht benötigte Zeichen enthalten, solange die Tabelle ausgerichtet ist und keine Vorkommen des ausgewählten Zeichens vorhanden sind, die nicht Teil der erforderlichen Ausgabe sind
• Die Trennzeichen müssen 1 Zeichen breit / hoch sein und die Rechtecke müssen gepackt sein (dh keine Trennzeichen zwischen ihren Zeichen)
• Die Leerzeilen können leer sein, ein Auffüllen ist nicht erforderlich
• Das Ergebnis kann eine Zeichenfolge, eine Matrix, ein Linienvektor, ein Array von Zeichenarrays oder eine 2D-Darstellung sein
• Sie können alternativ eine Matrix / einen Vektor von Vektoren / eine beliebige zweidimensionale Anzahl von Zahlen ausgeben, aber der Hintergrund und der Vordergrund müssen zwei verschiedene Zahlen sein (die von Eingabe zu Eingabe variieren können, jedoch nicht über die gesamte Ausgabe) und es dürfen keine anderen Zahlen vorhanden sein. Zusätzliche umgebende Zeichen sind auch in diesem Format zulässig (obwohl sie mit der Hintergrundnummer übereinstimmen müssen).
• Dies ist Code-Golf , kürzeste Antwort in Bytes, pro Sprache, gewinnt!

Beispiele

Für die Eingabe 2ist eine gültige ASCII-Kunst-Ausgabe mit dem Zeichen ∙:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{Ja, der Punkt ist nur da, um Sie zu verwirren.}
Eine weitere gültige Antwort als Zahlenmatrix, wobei 2 die Hintergrundzahl und 9 der Vordergrund ist:

[[9,2,9,9,2,2],
 [2,2,2,2,2,2],
 [9,2,9,9,2,2],
 [9,2,9,9,2,2]]

Ein ungültiges Ausgabebeispiel wäre

#  # #


#  # #

#  # #

da die Rechtecke Trennzeichen zwischen sich haben.

Beispielausgaben für :$4 \times 4$

# ## ### ####

# ## ### ####
# ## ### ####

# ## ### ####
# ## ### ####
# ## ### ####

# ## ### ####
# ## ### ####
# ## ### ####
# ## ### ####


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

Haskell , 43 Bytes

f n=map=<<flip(map.max)$show.(10^)=<<[1..n]

Probieren Sie es online!

Ein cleverer Ansatz von Ørjan Johansen, der mit Nullen und Einsen ausgibt und jeden 10...00Part als Zeichenfolgendarstellung einer Potenz von 10 generiert .

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell , 49 Bytes

f n=map=<<flip(map.max)$[0^i|x<-[1..n],i<-[0..x]]

Probieren Sie es online!

Erzeugt ein Muster wie [1,0,1,0,0,1,0,0,0,...], und erstellt dann eine 2D, indem die minPaare genommen werden. Die punktlose Verrücktheit spart 2 Bytes gegenüber den besser lesbaren:

f n|l<-do x<-[1..n];0:(1<$[1..x])=[[a*b|a<-l]|b<-l]

Probieren Sie es online!

R , 56 54 43 36 30 Bytes

x=!!sequence(2:scan())-1;x%o%x

Probieren Sie es online!

Übernimmt eine Eingabe über (gibt also eine 3x3-Matrix für ). Gibt eine Matrix aus (Vordergrund) und (Hintergrund) mit einer zusätzlichen Reihe / Spalte von Nullen vor.$n$$n = 4$$1s$$0s$

Dank digEmAll für -7 Bytes.

JavaScript (ES6),  73 72  69 Bytes

Gibt eine Zeichenfolge aus Einsen, Leerzeichen und Zeilenumbrüchen zurück.

n=>(g=s=>n-->0?g(s+`${p+=1} `):s[~n]?(+s[~n]?s:'')+`
`+g(s):'')(p='')

Probieren Sie es online!

JavaScript (ES7),  87 83  82 Bytes

3 Bytes dank @dzaima gespeichert

Gibt eine binäre Matrix zurück, die Zelle für Zelle erstellt wird.

n=>[...Array(n*(n+3)/2)].map((_,y,a)=>a.map(h=(z,x)=>(17+8*x)**.5%1&&(z||h(1,y))))

Probieren Sie es online!

Wie?

Die Breite der Matrix ist gegeben durch:$w$

(Anmerkung: Wie es die Herausforderungsregeln erlauben, geben wir stattdessen eine Matrix mit der Breite .)$w+1$

In ähnlicher Weise ist die Zelle bei leer, wenn das folgende Quadrat eine Ganzzahlwurzel für entweder oder zulässt :$(X,Y)$$k=X$$k=Y$

deren Determinante ist:

MATL, 14 10 Bytes

:"@:Fv]g&*

Diese Antwort wird 1für die Blöcke und 0für den Hintergrund verwendet

Probieren Sie es bei MATL Online aus

Erläuterung

     % Implicitly grab the input as an integer, N
     %   STACK: { 3 }
:    % Create an array from 1...N
     %   STACK: { [1, 2, 3] }
"    % For each element M in this array
  @: % Create an array from 1...M
     %   STACK (for 1st iteration): { [1] }
     %   STACK (for 2nd iteration): { [1; 0], [1, 2] }
     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0], [1, 2, 3] }
  F  % Push a zero to the stack
     %   STACK (for 1st iteration): { [1], 0 }
     %   STACK (for 2nd iteration): { [1; 0], [1, 2], 0 }
     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0], [1, 2, 3], 0 }
  v  % Vertically concatenate everything on the stack
     %   STACK (for 1st iteration): { [1; 0] }
     %   STACK (for 2nd iteration): { [1; 0; 1; 2; 0] }
     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0; 1; 2; 3; 0] }
] 
g    % Convert everything to be boolean (turns all non-zeros to 1)
     %   STACK: { [1; 0; 1; 1; 0; 1; 1; 1; 0] }
&*   % Perform element-wise multiplication to expand this array out into the 2D grid
     % Implicitly display the result

Gelee , 8 Bytes

1ẋⱮj0ȧþ`

Probieren Sie es online!

APL (Dyalog Unicode) , 12 10 12 Byte ^SBCS

∘.×⍨∊,\0,⎕⍴1

Probieren Sie es online!

Edit: -2 Bytes von ngn. +2 Bytes, weil die vorherigen Antworten ungültig waren (mit Idee dank ngn und dzaima).

Erläuterung

∘.×⍨∊,\0,⎕⍴1

         ⎕    Take input.
           ⍴1  An array of 1s of length our input. Example: 1 1 1
       0,      Prepend a 0. Example: 0 1 1 1
     ,\        Take all the prefixes and concatenate them. Example: 0  0 1  0 1 1  0 1 1 1
    ∊          Flatten the list. Example: 0 0 1 0 1 1 0 1 1 1
∘.×⍨           Turn the above list into a multiplication table of 0s and 1s
               by multiplying the list with itself.

Die Ausgabe sollte folgendermaßen aussehen:

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

Gelee , 7 Bytes

‘RÄṬ|þ`

Probieren Sie es online!

Gibt eine Ziffernmatrix aus, wobei für die Rechtecke und für den Abstand zwischen ihnen verwendet wird. Der TIO-Link enthält eine Fußzeile, in der eine Ziffernmatrix durch Aneinanderreihen der Zeilen und Spalten lesbar formatiert wird.$0$$1$

Erläuterung

‘RÄṬ|þ`
 R       Take a range from 1 to
‘          {the input} plus 1
  Ä      Cumulative sum; produces the first {input}+1 triangular numbers
   Ṭ     Produce an array with 1s at those indexes, 0s at other indexes
     þ   Create a table of {the array}
      `    with itself
    |      using bitwise OR

Die Zahl in Zelle der resultierenden Tabelle ist wenn entweder oder eine Dreieckszahl ist, oder sonst (weil bitweises ODER wie logisches ODER für 0 und 1 funktioniert). (Wir verwenden , reichen von 1, weil Jelly 1-basierte Indizierung verwendet, sodass wir uns keine Sorgen machen müssen, dass die Spalte 0 fälschlicherweise mit 0en gefüllt ist; wir müssen 1 zur Eingabe hinzufügen, weil das Array von erzeugt wird$(x,y)$$1$$x$$y$$0$RṬstoppt am größten in der Eingabe angegebenen Element, daher müssen wir rechts und unten eine Linie zeichnen.) Die Lücken zwischen dreieckigen Zahlen sind die aufeinanderfolgenden ganzen Zahlen, sodass die rechteckigen Blöcke, die durch die Lücken zwischen den Linien gebildet werden, enden als die von der Frage geforderten Größen; und durch die Verwendung einer ODER-Verknüpfung (in diesem Fall bitweise) können sich die Zeilen korrekt kreuzen.

05AB1E , 9 Bytes

Definiert ein Programm für .$f\texttt{: }\color{purple}{\texttt{Nat}} →\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{Nat}}\texttt{]]}$

Code:

$L×0ýSDδ*

Verwendet die 05AB1E- Kodierung . Probieren Sie es online! oder verwenden Sie die hübsche gedruckte Version .

Erläuterung:

$ # Drücken Sie die Nummer 1 und die Eingabe n 
 L # Erstellen Sie die Liste [1, 2, 3, ..., n ]
  × # Vektorisierte String-Multiplikation: 1 × [1, 2, 3, ..., n ]
                 Dies würde zu ["1", "11", "111", ..., "1" × n ] führen.
   0ý # Trete der resultierenden Liste mit '0' bei, was zu "10110111011110111110 ..." führt
     S # In einzelne Ziffern aufgeteilt: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Dδ * # Multiplikationstabelle mit sich selbst

C # (Visual C # Interactive Compiler) , 96 bis 95 Byte

-1 Byte dank Verkörperung der Ignoranz

n=>{var l="";for(;n>0;)l=new string('#',n--)+' '+l;for(;n<l.Length;)WriteLine(l[n++]>32?l:"");}

Probieren Sie es online!

Python 2 , 67 Bytes

s='';n=input()
while n:s='#'*n+' '+s;n-=1
for c in s:print(c>' ')*s

Probieren Sie es online!

Druckt Leerzeilen für Leerzeilen, was die Abfrage zulässt.

Gleiche Länge (bei Eingabe einer oben n):

r=range(input())
for n in r:print(' '.join(i*'#'for i in r)+'\n')*n

Probieren Sie es online!

Wolfram Language (Mathematica) , 41 Bytes

a#&/@(a=Flatten@Array[{0,1~Table~#}&,#])&

Probieren Sie es online!

Kohle , 18 Bytes

≔⪫ＥＮ×#⊕ι θＥθ⭆θ⌊⟦ιλ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

   Ｎ                Input number
  Ｅ                 Map over implicit range
       ι            Current value
      ⊕             Incremented
    ×               Repetitions of
     #              Literal `#`
 ⪫                  Join with spaces
≔        θ          Assign to variable
           θ        Retrieve variable
          Ｅ         Map over characters
             θ      Retrieve variable
            ⭆      Replace characters with
              ⌊     Minimum of
               ⟦    List of
                ι   Row character
                 λ  Column character
                    Implicitly print each row on its own line

C # (.NET Core) , 208 155 Bytes

class M{static void Main(string[]a){int i=int.Parse(a[0]);var l="";for(;i>0;)l=new string('#',i--)+' '+l;for(;;)System.Console.WriteLine(l[i++]>32?l:"");}}

Probieren Sie es online!

Eine viel überarbeitete Version dank verschiedener hilfsbereiter Leute (siehe die Kommentare).

PowerShell , 42 bis 40 Byte

-2 Bytes dank mazzy .

($r=1.."$args")|%{"$($r|%{'#'*$_})
"*$_}

Probieren Sie es online!

Java 11, 109 Bytes

n->{var l="";for(;n>0;)l="x".repeat(n--)+" "+l;for(;n<l.length();)System.out.println(l.charAt(n++)>32?l:"");}

Port der C # .NET-Antwort von @ ASCII-only .

Probieren Sie es online aus.

n->{                       // Method with integer parameter and no return-type
  var l="";                //  Line-String, starting empty
  for(;n>0;)               //  Loop until `n` is 0:
    l=...+l;               //   Prepend to `l`:
       "x".repeat(n--)+" " //    Repeat "x" `n` amount of times, appended with a space
                           //    And decrease `n` by 1 afterwards with `n--`
    for(;n<l.length();)    //   Inner loop as long as `n` is smaller than the length of `l`:
      System.out.println(  //    Print with trailing newline:
        l.charAt(n++)>32?  //     If the `n`'th character of the line-String is NOT a space:
                           //     And increase `n` by 1 afterwards with `n++`
         l                 //      Print the line-String
        :                  //     Else:
         "");}             //      Print nothing (so only the newlines)

APL + WIN, 29 Bytes

m/⍉(m←¯1↓∊(⍳n),¨¯1)/(n,n←⎕)⍴1

Erläuterung:

(n,n←⎕)⍴1 prompt for integer n and create a nxn matrix of 1s

(m←¯1↓∊(⍳n) replicate the columns by 1,2,.....n and insert 0s between each replication

m/⍉ repeat replication and 0 insertion for the rows from above 

Beispiel:

⎕:
3
1 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1
1 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1
1 0 1 1 0 1 1 1
1 0 1 1 0 1 1 1

J , 17 Bytes

[:*/~2=/\[:I.2+i.

Probieren Sie es online!

Mouse-2002 , 79 Bytes

Missbrauch von Mausmakros zur Wiederholung von Funktionen.

?1+n:#P,n,j,k,b#P,j,y,k,#P,n,i,' ,#P,i,x,35;;;;$P0 2%:(1%.2%.-^4%3%!'2%.1+2%:)@

Probieren Sie es online!

Ruby , 55 Bytes

->n{(s=(1..n).map{|x|?#*x}*' ').chars.map{|c|c<?!?c:s}}

Probieren Sie es online!

Wie?

Erstellen Sie zuerst die erste Zeile und durchlaufen Sie dann die Zeichen. Gibt die gesamte Zeile aus, wenn das Zeichen '#' ist, andernfalls wird das einzelne Zeichen (das ein Leerzeichen ist) gedruckt.

Brain-Flak , 170 Bytes

(({})<>){(({})<{({}[()]<(<>({})<>){(({})<{({}[(())])}>[()])}{}{}(([(()()()()())(){}]){})>)}{}(({}))>[()])}{}{}{}([]){{}({}<>((((()()){}){}){}){})<>([])}{}<>{({}<>)<>}<>{}

Probieren Sie es online!

Perl 6 , 35 33 Bytes

{((\*Xx$_+1)~"
"Xx$_+1)>>.say}o^*

Probieren Sie es online!

Anonym Callable, der eine Zahl annimmt und die Multiplikationstabelle mit *s mit einer nachgestellten Newline druckt.

Erläuterung:

{                             }o^* # Change the input to the range 0..n-1
  (\*Xx$_+1)    # Cross string multiply '*' by all of range 1..n
                # This creates the string "* ** *** ****" etc.
            ~"\n"                 # Append a newline
                 Xx$_+1           # Cross string multiply again
 (                     )>>.say    # And print all the lines

Haskell, 69-68 Bytes

(a#b)0=[]
(a#b)n=(a#b)(n-1)++b:(a<$[1..n])
f n=((1#0)n#(0<$(1#0)n))n

Gibt eine Zahlenmatrix zurück.

Probieren Sie es online!

Varianten fmit der gleichen Byteanzahl:

f n=((#)<*>(0<$)$(1#0)n)n
f n|l<-(1#0)n=(l#(0<$l))n

Stax , 7 Bytes

é╫▐§╘←╘

Führen Sie es aus und debuggen Sie es

Der gewählte Charakter ist backtick. (Wie codiert man das Format im Markdown?)

Das bedeutet aund bgilt als fremdes Leerzeichen.

MathGolf , 20 Bytes

╒ÉÄ10;]h\■mÆε*╣¡§y╠n

Probieren Sie es online!

MathGolf braucht dringend mehr Funktionen zum Teilen von Listen und zum Erstellen von 2D-Listen.

Erläuterung

╒                      range(1,n+1)
 É                     start block of length 3
  Ä                    start block of length 1
   1                   push 1
    0                  push 0
     ;                 discard TOS
      ]                end array / wrap stack in array
                       the stack now contains the list [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, ...]
       h               length of array/string without popping (used for splitting string)
        \              swap top elements
         ■             cartesian product with itself for lists, next collatz item for numbers
          m            explicit map
           Æ           start block of length 5
            ε*         reduce list by multiplication (logical AND)
              ╣¡       push the string " #"
                §      get character at index 0 or 1 based on logical AND value
                       block ends here, stack is now ['#',' ','#','#',' ','#',...]
                 y     join array without separator to string
                  ╠    pop a, b, push b/a (divides the string using the length of a single line)
                   n   join array of strings with newlines

Tinte , 151 152 151 Bytes

VAR k=0
=t(n)
~k=n
-(u)
~n--
{n+1:->s(k-n)->u}->->
=r(c)
->g(c)->
{k-c:<>->r(c+1)}->->
=g(n)
{n>1:@<>->g(n-1)}@->->
=s(n)
{n:
->r(1)->
->s(n-1)
}
.->->

Probieren Sie es online!

Gut, dass die Regeln überschüssige Zeichen zulassen.

Edit: +1: Feste Abstände. Zeigen Sie auch mit @ (ohne Escape-Zeichen) anstelle von # (ohne Escape-Zeichen) an.

Edit: -1: Anscheinend bedeutete dieses Update auch, dass ich keine Wartezeit mehr benötigte, um eine neue Zeile auf die nicht leeren Zeilen zu zwingen. Ordentlich.

C ++, 170 bis 156 Bytes

Danke an dzaima

#include<string>
using v=std::string;v f(int a){v s;for(int i=1;i<=a;++i,s+='\n')for(int k=0;k<i;++k,s+='\n')for(int j=1;j<=a;++j)s+=v(j,'#')+' ';return s;}

SmileBASIC, 83 77 Bytes

Grafische Ausgabe. Eingabe istN-1

INPUT N
FOR J=0TO N
X=0FOR I=0TO N
GFILL X,Y,X+I,Y+J
X=X+I+2NEXT
Y=Y+J+2NEXT

Python 3 , 88 83 Bytes

-5 Bytes von Jo King

n,l=range(int(input())),''
for i in n:l+='#'*-~i+' '
for j in n:print((l+'\n')*-~j)

Probieren Sie es online!

Perl 6, 63 Bytes

{(1..$_).map(((1..$_).map("#"x*).join(" ")~"\n")x*).join("\n")}

C (gcc) , 108 104 Bytes

-4 Bytes dank Ceilingcat

f(n,j){char*s,u[n*n],*t=s=u,i=0;for(;i++<n;*s++=32)for(j=i;j--;)*s++=35;for(s=t;*t;)puts(*t++>32?s:"");}

Probieren Sie es online!