Los rectángulos tienen esta buena propiedad: ¡un rectángulo $n \times m$ consta de exactamente $n \times m$ caracteres!

Una propiedad más interesante es que los rectángulos se pueden alinear muy bien en una tabla de multiplicar, por ejemplo, una tabla $3 \times 3$ :

# ## ###

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

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

Su desafío es, dado un número $n$ ( $n > 1$ ), generar una tabla de multiplicación $n \times n$ formateada .

Reglas

• Puede tomar la entrada arriba o abajo $n$
• Se aplican las reglas de E / S predeterminadas
• Puede elegir cualquier carácter que no sea un espacio en blanco para representar los bloques; todos los demás caracteres (aunque las nuevas líneas son especiales) se consideran espacios en blanco. El carácter elegido puede ser diferente para diferentes entradas, pero debe ser el mismo en toda la entrada.
• El resultado puede tener caracteres innecesarios, siempre que la tabla se alinee y no haya ocurrencias del carácter elegido que no formen parte de la salida requerida.
• Los separadores deben tener 1 carácter de ancho / alto, y los rectángulos deben estar empaquetados (es decir, sin separadores entre sus caracteres)
• Las líneas vacías pueden estar vacías, no se requiere relleno
• El resultado puede ser una cadena, matriz, vector de líneas, matriz de matrices de caracteres o cualquier cosa 2Dish
• Alternativamente, puede generar una matriz / vector-de-vectores / cualquier cosa 2Dish de números, pero el fondo y el primer plano deben ser 2 números distintos (que pueden variar de entrada a entrada, pero no a lo largo de una salida) y no pueden estar presentes otros números. También se permiten caracteres circundantes adicionales con este formato (aunque deben coincidir con el número de fondo)
• Este es el código de golf , la respuesta más corta en bytes, por idioma, ¡gana!

Ejemplos

Para la entrada 2, una salida válida de ascii-art, con el carácter ∙, es:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{sí, el período está ahí solo para confundirte}
Otra respuesta válida como una matriz de números, siendo 2 el número de fondo y 9 el primer plano:

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

Un ejemplo de salida no válido sería

#  # #


#  # #

#  # #

ya que los rectángulos tienen separadores entre ellos.

Ejemplo de salidas para $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]

Pruébalo en línea!

Un enfoque inteligente de Ørjan Johansen que genera 0 y 1, generando cada 10...00parte como la representación de cadena de una potencia de 10.

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]]

Pruébalo en línea!

Genera un patrón como [1,0,1,0,0,1,0,0,0,...], luego crea un 2D tomando los minpares. La rareza sin puntos ahorra 2 bytes sobre los más legibles:

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

Pruébalo en línea!

R , 56 54 43 36 30 bytes

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

Pruébalo en línea!

Toma la entrada uno arriba de $n$ (entonces devuelve una matriz 3x3 para $n = 4$ ). Devuelve una matriz de $1s$ (primer plano) y $0s$ (fondo) con una fila / columna adicional de ceros al frente.

Gracias a digEmAll por -7 bytes.

JavaScript (ES6),  73 72  69 bytes

Devuelve una cadena compuesta de 1, espacios y saltos de línea.

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

Pruébalo en línea!

JavaScript (ES7),  87 83  82 bytes

Guardado 3 bytes gracias a @dzaima

Devuelve una matriz binaria, que se construye celda por celda.

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

Pruébalo en línea!

¿Cómo?

El ancho $w$ de la matriz viene dado por:

(Nota: según lo permitido por las reglas de desafío, generamos una matriz de ancho $w+1$ ).

De manera similar, la celda ubicada en $(X,Y)$ está vacía si la siguiente cuadrática admite una raíz entera para $k=X$ o $k=Y$ :

cuyo determinante es:

MATL, 14 10 bytes

:"@:Fv]g&*

Esta respuesta se usa 1para los bloques y0 para el fondo.

Pruébalo en MATL Online

Explicación

     % 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

Jalea , 8 bytes

1ẋⱮj0ȧþ`

Pruébalo en línea!

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

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

Pruébalo en línea!

Editar: -2 bytes de ngn. +2 bytes porque las respuestas anteriores no eran válidas (con idea gracias a ngn y dzaima).

Explicación

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

La salida debería verse así:

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

Jalea , 7 bytes

‘RÄṬ|þ`

Pruébalo en línea!

Emite una matriz de dígitos, utilizando $0$ para los rectángulos y $1$por el relleno entre ellos. El enlace TIO contiene un pie de página que formatea una matriz de dígitos de manera legible alineando las filas y columnas.

Explicación

‘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

El número en la celda $(x,y)$ de la tabla resultante será $1$ si alguno $x$ o $y$ es un número triangular, o $0$de lo contrario (porque OR bit a bit funciona como OR lógico en 0 y 1). (Usamos R, rango de 1, porque Jelly usa indexación basada en 1, por lo que no tenemos que preocuparnos de que la columna 0 esté incorrectamente llena de 0; tenemos que agregar 1 a la entrada porque la matriz producida por se Ṭdetiene en el más grande elemento dado en la entrada, por lo que debemos dibujar una línea en el lado derecho y en la parte inferior.) Los espacios entre los números triangulares son los enteros consecutivos, por lo que los bloques rectangulares formados por los espacios entre las líneas terminan como los tamaños solicitado por la pregunta; y el uso de una operación OR (en este caso, bit a bit) permite que las líneas se crucen entre sí correctamente.

05AB1E, 9 bytes

Defines a program $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δ*

Uses the 05AB1E-encoding. Try it online! or use the pretty-printed version.

Explanation:

$              # Push the number 1 and the input n
 L             # Create the list [1, 2, 3, ..., n]
  ×            # Vectorized string multiplication: 1 × [1, 2, 3, ..., n]
                 This would result in ["1", "11", "111", ..., "1" × n]
   0ý          # Join the resulting list with '0', resulting in "10110111011110111110..."
     S         # Split into single digits: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Dδ*      # Multiplication table with itself

C# (Visual C# Interactive Compiler), 96 95 bytes

-1 byte thanks to Embodiment of Ignorance

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

Try it online!

Python 2 , 67 bytes

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

Pruébalo en línea!

Imprime líneas en blanco para líneas vacías, lo que permite el desafío.

Misma longitud (con la entrada uno arriba n):

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 41 bytes

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

Pruébalo en línea!

Carbón , 18 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Pruébalo en línea!

Una versión muy revisada gracias a varias personas útiles (ver los comentarios).

PowerShell , 42 40 bytes

-2 bytes gracias a mazzy .

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

Pruébalo en línea!

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

Puerto de respuesta C # .NET de @ ASCII-only .

Pruébalo en línea.

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

Explicación:

(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 

Ejemplo:

⎕:
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.

Pruébalo en línea!

Ratón-2002 , 79 bytes

Abusar de las macros del mouse para repetir la funcionalidad.

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

Pruébalo en línea!

Ruby , 55 bytes

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

Pruébalo en línea!

¿Cómo?

Primero, crea la primera línea, luego itera a través de sus caracteres. Imprima la línea completa si el carácter es '#'; de lo contrario, imprima el carácter único (que es un espacio)

Brain-Flak , 170 bytes

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

Pruébalo en línea!

Perl 6 , 35 33 bytes

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

Pruébalo en línea!

Llamable anónimo que toma un número e imprime la tabla de multiplicar con * s con una nueva línea final.

Explicación:

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

Devuelve una matriz de números.

Pruébalo en línea!

Variantes de fcon el mismo número de bytes:

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

Stax , 7 bytes

é╫▐§╘←╘

Ejecutar y depurarlo

El personaje elegido es backtick. (¿Cómo codifica el formato en Markdown?)

Eso significa ay bse consideran espacios en blanco extraños.

MathGolf , 20 bytes

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

Pruébalo en línea!

MathGolf realmente necesita más funcionalidad para dividir listas y crear listas 2D.

Explicación

╒                      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

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

Pruébalo en línea!

Lo bueno es que las reglas permiten el exceso de caracteres.

Editar: +1: Espaciado fijo. Además, muestre usando @ (que no necesita escapar) en lugar de # (que sí)

Editar: -1: Al parecer, esa solución también significaba que ya no necesitaba un período final para forzar una nueva línea en las líneas no vacías. Ordenado.

C ++, 170 156 bytes

Gracias a 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

Salida gráfica La entrada esN-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

Pitón 3 , 88 83 bytes

-5 bytes de Jo King

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

Pruébalo en línea!

Perl 6, 63 bytes

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

C (gcc) , 108104 bytes

-4 bytes gracias a 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:"");}

Pruébalo en línea!