矩形具有这个不错的属性-一个矩形正好由字符组成！$n \times m$$n \times m$

A ..更有趣的属性是矩形可以在乘法表中很好地对齐-例如表：$3 \times 3$

# ## ###

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

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

您面临的挑战是，给定数字（），输出格式化的乘法表。$n$$n > 1$$n \times n$

规则

• 您可以在上方或下方输入一个$n$
• 默认的I / O规则适用
• 您可以选择任何非空白字符来表示块。其他字符（尽管换行符很特殊）都被认为是空格。对于不同的输入，所选字符可以不同，但​​是在整个输入中必须相同
• 只要表格对齐，结果就可以有不需要的字符，并且不会出现不属于所需输出的所选字符
• 分隔符必须为1个字符宽/高，并且必须包装矩形（即，其字符之间没有分隔符）
• 空行可以为空，不需要填充
• 结果可以是字符串，矩阵，行向量，字符数组或任何2Dish
• 您可以选择输出矩阵/向量/任何2Dish数字，但是背景和前景必须是2个不同的数字（可以改变输入对输入的范围，但不能贯穿整个输出），并且不能存在其他数字。此格式也允许使用多余的周围字符（尽管它们必须与背景编号匹配）
• 这是代码高尔夫，最短答案（以字节为单位），每种语言都胜出！

例子

对于输入2，具有字符的有效ascii-art输出∙为：

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{是的，那段时间只是在使您感到困惑。}
另一个有效答案是一个数字矩阵，其中2是背景数字，9是前景：

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

无效的输出示例将是

#  # #


#  # #

#  # #

因为矩形之间有分隔符。

示例输出：$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个字节

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

在线尝试！

ØrjanJohansen的聪明方法是输出0和1，将每个10...00部分生成为10的幂的字符串表示。

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell，49个字节

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

在线尝试！

生成像的图案[1,0,1,0,0,1,0,0,0,...]，然后通过min对进行2D制作。无点怪异度比可读性高2个字节：

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

在线尝试！

R，56 54 43 36 30字节

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

在线尝试！

需要输入一个以上$n$（以便返回3x3矩阵为$n = 4$）。返回（前景）和（背景）的矩阵， 前面有一个额外的零行/列。$1s$$0s$

感谢-7字节的digEmAll。

JavaScript（ES6）， 73 72  69字节

返回由1，空格和换行符组成的字符串。

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

在线尝试！

JavaScript（ES7）， 87 83  82字节

@dzaima节省了3个字节

返回一个二进制矩阵，该矩阵是逐个单元构建的。

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

在线尝试！

怎么样？

矩阵的宽度$w$由下式给出：

（注意：在挑战规则允许的情况下，我们改为输出宽度为的矩阵。）$w+1$

同样，如果以下二次方为或接受整数根，则位于的单元格为空：$(X,Y)$$k=X$$k=Y$

其决定因素是：

MATL，14个10字节

:"@:Fv]g&*

此答案1用于块和0背景

在MATL Online上尝试

说明

     % 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

果冻，8字节

1ẋⱮj0ȧþ`

在线尝试！

APL（Dyalog Unicode），12 10 12 字节^SBCS

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

在线尝试！

编辑：从ngn -2字节。+2个字节，因为先前的答案无效（感谢ngn和dzaima的帮助）。

说明

∘.×⍨∊,\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.

输出应如下所示：

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

果冻，7个字节

‘RÄṬ|þ`

在线尝试！

输出一个数字矩阵，对矩形使用，对矩形之间使用。TIO链接包含一个页脚，该页脚通过排列行和列以人类可读的方式格式化数字矩阵。$0$$1$

说明

‘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

如果或是一个三角数，则结果表的单元格上的数字将为，否则为（因为按位或的作用类似于对0和1进行逻辑或）。（我们使用，范围从1开始，因为Jelly使用基于1的索引，因此我们不必担心列0会错误地充满0；我们必须在输入中添加1，因为由产生的数组$(x,y)$$1$$x$$y$$0$RṬ停在输入中给定的最大元素上，因此我们需要在右侧和底部画一条线。）三角形之间的间隙是连续的整数，因此由线之间的间隙形成的矩形块结束达到问题要求的大小；并且使用或运算（在这种情况下为按位运算）可以使线正确地相互交叉。

05AB1E，9个字节

定义程序。$f\texttt{: }\color{purple}{\texttt{Nat}} →\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{Nat}}\texttt{]]}$

码：

$L×0ýSDδ*

采用05AB1E -encoding。在线尝试！或使用印刷精美的版本。

说明：

$＃按下数字1并输入n 
 L＃创建列表[1、2、3，...，n ]
  ×＃向量化的字符串乘法：1×[1、2、3，...，n ]
                 这将导致[“ 1”，“ 11”，“ 111”，...，“ 1”× n ]
   0ý＃将结果列表与“ 0”连接，结果为“ 10110111011110111110 ...”
     S＃拆分为个位数：[1、0、1、1、0、1、1、1、0、1、1、1、1、0，...]
      Dδ*＃乘法表本身

C＃（Visual C＃交互式编译器），96 95字节

-1字节归功于无知的体现

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

在线尝试！

Python 2，67字节

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

在线尝试！

将空白行打印为空行，这是挑战所允许的。

相同长度（上面输入一n）：

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

在线尝试！

Wolfram语言（Mathematica），41个字节

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

在线尝试！

木炭，18字节

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

在线尝试！链接是详细版本的代码。说明：

   Ｎ                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核心），208个 155字节

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:"");}}

在线尝试！

经过多方帮助的人（请参阅注释）对版本进行了大幅修订。

的PowerShell，42 40字节

-2个字节，感谢mazzy。

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

在线尝试！

Java 11，109字节

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

@ ASCII-only的C＃.NET Answer的端口。

在线尝试。

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个字节

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

说明：

(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 

例：

⎕:
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个字节

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

在线尝试！

鼠标 2002，79字节

滥用鼠标的宏来重复功能。

?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%:)@

在线尝试！

Ruby，55个字节

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

在线尝试！

怎么样？

首先，创建第一行，然后遍历其字符。如果字符为“＃”，则打印整行，否则打印单个字符（空格）

脑高射炮，170个字节

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

在线尝试！

Perl 6的，35个 33字节

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

在线尝试！

Anonymous Callable，它接受一个数字，并在*s后面加上一个换行符后输出乘法表。

说明：

{                             }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字节

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

返回数字矩阵。

在线尝试！

f具有相同字节数的变体：

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

Stax，7 个字节

é╫▐§╘←╘

运行并调试

选择的字符是反引号。（如何在markdown中编码格式？）

这意味着a并且b被认为是多余的空格。

MathGolf，20个字节

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

在线尝试！

MathGolf确实需要获得更多功能来拆分列表和创建2D列表。

说明

╒                      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

墨，151个 152 151字节

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)
}
.->->

在线尝试！

好的规则是允许多余的字符。

编辑：+1：固定间距。另外，使用@（不需要转义）而不是＃（需要）进行显示

编辑：-1：显然，该修复程序还意味着我不再需要尾随时间来在非空行上强制换行。整齐。

C ++，170个 156字节

感谢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字节

图形输出。输入为N-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个字节

来自Jo King的 -5字节

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

在线尝试！

Perl 6，63位元组

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

C（gcc），108104字节

--4个字节，感谢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:"");}

在线尝试！