Les rectangles ont cette belle propriété - un rectangle se compose d’exactement caractères!$n \times m$$n \times m$

Une propriété plus intéressante est que les rectangles peuvent être bien alignés dans une table de multiplication - par exemple, une table :$3 \times 3$

# ## ###

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

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

Votre défi consiste à, étant donné un nombre ( n> 1 ), générer une table de multiplication formatée n \ times n .$n$$n > 1$$n \times n$

Règles

• Vous pouvez prendre l’entrée un au dessus ou au dessous de $n$
• Les règles d'E / S par défaut s'appliquent
• Vous pouvez choisir n'importe quel caractère non-blanc pour représenter les blocs; tout autre caractère (bien que les nouvelles lignes soient spéciales) est considéré comme un espace. Le caractère choisi peut être différent pour différentes entrées, mais doit être identique tout au long de la saisie.
• Le résultat peut avoir des caractères inutiles, tant que la table est alignée et qu'il n'y a aucune occurrence du caractère choisi qui ne fasse pas partie de la sortie requise.
• Les séparateurs doivent avoir 1 caractère de largeur / hauteur et les rectangles doivent être remplis (c.-à-d. Pas de séparateurs entre leurs caractères)
• Les lignes vides peuvent être vides, le remplissage n'est pas obligatoire
• Le résultat peut être une chaîne, une matrice, un vecteur de lignes, un tableau de tableaux de caractères ou n'importe quoi 2Dish
• Vous pouvez également générer une matrice / un vecteur de vecteurs / tout élément fini, mais l'arrière-plan et le premier plan doivent être deux nombres distincts (qui peuvent varier en entrée, mais pas dans une sortie) et aucun autre nombre ne peut être présent. Les caractères supplémentaires qui l'entourent sont également autorisés avec ce format (bien qu'ils doivent correspondre au numéro d'arrière-plan)
• C'est code-golf , la réponse la plus courte en octets, par langue, gagne!

Exemples

Pour l’entrée 2, une sortie ascii-art valide, avec le caractère ∙, est:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{oui, le point est juste pour vous embrouiller.}
Une autre réponse valable sous forme de matrice de nombres, 2 étant le numéro de fond et 9 le premier plan:

[[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 exemple de sortie non valide serait

#  # #


#  # #

#  # #

comme les rectangles ont des séparateurs entre eux.

Exemple de sorties pour :$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 octets

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

Essayez-le en ligne!

Une approche intelligente de Ørjan Johansen produisant avec des 0 et des 1, générant chaque 10...00partie comme représentation sous forme de chaîne d’une puissance de 10.

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell , 49 octets

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

Essayez-le en ligne!

Génère un motif comme [1,0,1,0,0,1,0,0,0,...], puis crée une 2D en prenant le nombre minde paires. L'étrangeté sans points sauve 2 octets sur le plus lisible:

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

Essayez-le en ligne!

R , 56 54 43 36 30 octets

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

Essayez-le en ligne!

Prend l'entrée un au dessus de $n$ (retourne donc la matrice 3x3 pour $n = 4$ ). Renvoie une matrice de $1s$ (au premier plan) et de $0s$ (arrière-plan) avec une ligne / colonne supplémentaire de zéros au premier plan.

Merci à digEmAll pour -7 octets.

JavaScript (ES6),  73 72  69 octets

Renvoie une chaîne composée de 1, d'espaces et de sauts de ligne.

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

Essayez-le en ligne!

JavaScript (ES7),  87 83  82 octets

3 octets sauvés grâce à @dzaima

Retourne une matrice binaire, qui est construite cellule par cellule.

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

Essayez-le en ligne!

Comment?

La largeur $w$ de la matrice est donnée par:

(NB: comme le permettent les règles de challenge, nous produisons une matrice de largeur $w+1$ place.)

De même, la cellule située en $(X,Y)$ est vide si le quadratique suivant admet une racine entière pour $k=X$ ou $k=Y$ :

dont le déterminant est:

MATL, 14 à 10 octets

:"@:Fv]g&*

Cette réponse utilise 1pour les blocs et 0pour le fond

Essayez-le sur MATL Online

Explication

     % 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

Gelée , 8 octets

1ẋⱮj0ȧþ`

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Edit: -2 octets de ngn. +2 octets car les réponses précédentes étaient invalides (avec une idée grâce à ngn et dzaima).

Explication

∘.×⍨∊,\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 sortie devrait ressembler à:

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

Gelée , 7 octets

‘RÄṬ|þ`

Essayez-le en ligne!

$0$$1$

Explication

‘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

$(x,y)$$1$$x$$y$$0$RṬs’arrête au plus grand élément indiqué dans l’entrée, il faut donc tracer une ligne à droite et en bas.) Les espaces entre les nombres triangulaires sont les entiers consécutifs, donc les blocs rectangulaires formés par les espaces entre les lignes se terminent comme les tailles demandées par la question; et l'utilisation d'une opération OU (dans ce cas, au niveau des bits) permet aux lignes de se croiser correctement.

05AB1E , 9 octets

$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δ*

Utilise le 05AB1E -encoding . Essayez-le en ligne! ou utilisez la version joliment imprimée .

Explication:

$ # Poussez le nombre 1 et l'entrée n 
 L # Créez la liste [1, 2, 3, ..., n ]
  × # Multiplication de chaînes vectorisée: 1 × [1, 2, 3, ..., n ]
                 Cela donnerait ["1", "11", "111", ..., "1" × n ]
   0ý # Rejoignez la liste résultante avec '0', résultant en "10110111011110111110 ..."
     S # Découpe en chiffres simples: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Dδ * # Table de multiplication avec elle-même

C # (compilateur interactif Visual C #) , 96 95 octets

-1 octet grâce à l' incarnation de l'ignorance

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

Essayez-le en ligne!

Python 2 , 67 octets

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

Essayez-le en ligne!

Imprime les lignes vides pour les lignes vides, ce que le défi permet.

Même longueur (avec l'entrée une ci-dessus n):

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 41 octets

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

Essayez-le en ligne!

Charbon de bois , 18 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

   Ｎ                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 octets

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

Essayez-le en ligne!

Une version beaucoup révisée grâce aux différentes personnes utiles (voir les commentaires).

PowerShell , 42 ans 40 octets

-2 octets grâce à mazzy .

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

Essayez-le en ligne!

Java 11, 109 octets

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

Port de @ ASCII uniquement réponse C # .NET .

Essayez-le en ligne.

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 octets

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

Explication:

(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 

Exemple:

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

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

Essayez-le en ligne!

Souris 2002 , 79 octets

Abuser des macros de la souris pour répéter la fonctionnalité.

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

Essayez-le en ligne!

Ruby , 55 octets

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

Essayez-le en ligne!

Comment?

Commencez par créer la première ligne, puis parcourez ses caractères. Imprimer la ligne entière si le caractère est '#', sinon, imprimer le caractère unique (qui est un espace)

Flak cérébrale , 170 octets

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

Essayez-le en ligne!

Perl 6 , 35 33 octets

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

Essayez-le en ligne!

Anonymous Callable qui prend un nombre et imprime la table de multiplication avec * s avec une nouvelle ligne.

Explication:

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

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

Retourne une matrice de nombres.

Essayez-le en ligne!

Variantes de favec le même nombre d'octets:

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

Stax , 7 octets

é╫▐§╘←╘

Exécuter et déboguer

Le personnage choisi est un backtick. (Comment codez-vous le format dans Markdown?)

Cela signifie aet bsont considérés comme des espaces blancs superflus.

MathGolf , 20 octets

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

Essayez-le en ligne!

MathGolf a vraiment besoin de plus de fonctionnalités pour scinder des listes et créer des listes 2D.

Explication

╒                      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

Encre , 151 152 151 octets

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

Essayez-le en ligne!

C'est une bonne chose que les règles autorisent les personnages excédentaires.

Edit: +1: Espacement fixe. De plus, affichez en utilisant @ (qui n'a pas besoin d'être échappé) au lieu de # (qui le fait)

Edit: -1: Apparemment, ce correctif signifiait également que je n'avais plus besoin d'une période de fin pour forcer une nouvelle ligne sur les lignes non vides. Soigné.

C ++, 170 156 octets

Merci à 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 octets

Sortie graphique. L'entrée estN-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 octets

-5 octets de Jo King

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

Essayez-le en ligne!

Perl 6, 63 octets

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

C (gcc) , 108 104 octets

-4 octets grâce à 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:"");}

Essayez-le en ligne!