Prostokąty mają tę przyjemną właściwość - prostokąt składa się z dokładnie znaków!$n \times m$$n \times m$

Ciekawszą właściwością jest to, że prostokąty można ładnie wyrównać w tabliczce mnożenia - na przykład w tabeli :$3 \times 3$

# ## ###

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

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

Twoim wyzwaniem jest uzyskanie sformatowanej tabeli mnożenia , biorąc pod uwagę liczbę ( ) .$n$$n > 1$$n \times n$

Zasady

• Możesz wziąć jeden wejściowy powyżej lub poniżej$n$
• Obowiązują domyślne reguły we / wy
• Możesz wybrać dowolny znak inny niż biały, który będzie reprezentował bloki; każda inna postać (choć znaki nowej linii są specjalne) jest uważana za spację. Wybrany znak może być różny dla różnych danych wejściowych, ale musi być taki sam dla danych wejściowych
• Rezultat może mieć niepotrzebne znaki, o ile tabela wyrównuje się i nie ma żadnych wystąpień wybranego znaku, które nie są częścią wymaganego wyniku
• Separatory muszą mieć 1 znak szerokości / wysokość, a prostokąty muszą być spakowane (tzn. Bez separatorów między ich znakami)
• Puste linie mogą być puste, wypełnienie nie jest wymagane
• Wynikiem może być ciąg, macierz, wektor linii, tablica tablic znaków lub cokolwiek 2Dish
• Możesz alternatywnie wyprowadzać macierz / wektor wektorów / cokolwiek 2Dish liczb, ale tło i pierwszy plan muszą być 2 różnymi liczbami (które mogą zmieniać wejście na wejście, ale nie na wyjściu) i żadne inne liczby nie mogą być obecne. Dodatkowe znaki otaczające są również dozwolone w tym formacie (chociaż muszą pasować do numeru tła)
• To jest golf golfowy , najkrótsza odpowiedź w bajtach, na język, wygrywa!

Przykłady

Dla danych wejściowych 2poprawnym wyjściem ascii-art, ze znakiem ∙, jest:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{tak, kropka jest po to, aby Cię pomylić}
Kolejna ważna odpowiedź jako matryca liczbowa, gdzie 2 to numer tła, a 9 pierwszy 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]]

Przykładem może być niepoprawny wynik

#  # #


#  # #

#  # #

ponieważ prostokąty mają między sobą separatory.

Przykładowe dane wyjściowe dla :$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 bajty

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

Wypróbuj online!

Sprytne podejście Ørjana Johansena generujące zera i jedynki, generujące każdą 10...00część jako ciąg znaków reprezentujący potęgę 10.

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell , 49 bajtów

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

Wypróbuj online!

Generuje wzór podobny [1,0,1,0,0,1,0,0,0,...], a następnie tworzy 2D, biorąc minpary. Bezcelowa dziwność oszczędza 2 bajty na bardziej czytelnym:

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

Wypróbuj online!

R , 56 54 43 36 30 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe powyżej (więc zwraca macierz 3x3 dla ). Zwraca macierz (pierwszy plan) i (tło) z dodatkowym wierszem / kolumną zer z przodu.$n$$n = 4$$1s$$0s$

Dzięki digEmAll dla -7 bajtów.

JavaScript (ES6),  73 72  69 bajtów

Zwraca ciąg znaków złożony z 1, spacji i linii.

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

Wypróbuj online!

JavaScript (ES7),  87 83  82 bajtów

Zaoszczędź 3 bajty dzięki @dzaima

Zwraca macierz binarną, która jest budowana komórka po komórce.

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

Wypróbuj online!

W jaki sposób?

Szerokość matrycy jest dana przez:$w$

(NB: Zgodnie z regułami wyzwania, zamiast tego wyprowadzamy macierz szerokości ).$w+1$

Podobnie, komórka znajdująca się w jest pusta, jeśli poniższy kwadrat potwierdzi liczbę całkowitą dla lub :$(X,Y)$$k=X$$k=Y$

których wyznacznikiem jest:

MATL, 14 10 bajtów

:"@:Fv]g&*

Ta odpowiedź używa 1bloków i 0tła

Wypróbuj w MATL Online

Wyjaśnienie

     % 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

Galaretka , 8 bajtów

1ẋⱮj0ȧþ`

Wypróbuj online!

APL (Dyalog Unicode) , 12 10 12 bajtów ^SBCS

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

Wypróbuj online!

Edycja: -2 bajty z ngn. +2 bajty, ponieważ poprzednie odpowiedzi były nieprawidłowe (pomysł dzięki ngn i dzaima).

Wyjaśnienie

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

Dane wyjściowe powinny wyglądać następująco:

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

Galaretka , 7 bajtów

‘RÄṬ|þ`

Wypróbuj online!

Wysyła macierz cyfr, używając dla prostokątów i dla wypełnienia między nimi. Łącze TIO zawiera stopkę, która formatuje matrycę cyfrową w sposób czytelny dla człowieka przez wyrównanie wierszy i kolumn.$0$$1$

Wyjaśnienie

‘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

Liczba w komórce wynikowej tabeli będzie wynosić jeśli lub jest liczbą trójkątną, lub przeciwnym razie (ponieważ bitowe OR działa jak logiczne OR na 0 i 1). (Używamy , zakres od 1, ponieważ Jelly używa indeksowania opartego na 1, więc nie musimy się martwić, że kolumna 0 będzie niepoprawnie wypełniona zerami; musimy dodać 1 do danych wejściowych, ponieważ tablica utworzona przez$(x,y)$$1$$x$$y$$0$RṬzatrzymuje się na największym elemencie podanym na wejściu, dlatego musimy narysować linię po prawej stronie iu dołu). Przerwy między liczbami trójkątnymi to kolejne liczby całkowite, więc prostokątne bloki utworzone przez przerwy między liniami kończą się w górę o rozmiary wymagane przez pytanie; a użycie operacji OR (w tym przypadku bitowej) pozwala na prawidłowe skrzyżowanie linii.

05AB1E , 9 bajtów

Definiuje program .$f\texttt{: }\color{purple}{\texttt{Nat}} →\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{Nat}}\texttt{]]}$

Kod:

$L×0ýSDδ*

Wykorzystuje kodowanie 05AB1E . Wypróbuj online! lub użyj ładnej wersji drukowanej .

Wyjaśnienie:

$ # Naciśnij cyfrę 1 i wprowadź n 
 L # Utwórz listę [1, 2, 3, ..., n ]
  × # Wektoryzacja mnożenia ciągów znaków: 1 × [1, 2, 3, ..., n ]
                 Spowoduje to powstanie [„1”, „11”, „111”, ..., „1” × n ]
   0ý # Dołącz do wynikowej listy za pomocą „0”, w wyniku czego „10110111011110111110 ...”
     S # Podziel na pojedyncze cyfry: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Dδ * # Tabliczka mnożenia z samym sobą

C # (interaktywny kompilator Visual C #) , 96 95 bajtów

-1 bajt dzięki Embodiment of Ignorance

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

Wypróbuj online!

Python 2 , 67 bajtów

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

Wypróbuj online!

Drukuje puste linie dla pustych linii, na co pozwala wyzwanie.

Ta sama długość (z wejściem powyżej n):

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

Wypróbuj online!

Wolfram Language (Mathematica) , 41 bajtów

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

Wypróbuj online!

Węgiel drzewny , 18 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

   Ｎ                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 bajtów

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

Wypróbuj online!

Znacznie zmieniona wersja dzięki różnym pomocnym osobom (patrz komentarze).

PowerShell , 42 40 bajtów

-2 bajty dzięki mazzy .

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

Wypróbuj online!

Java 11, 109 bajtów

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

Port odpowiedzi C # .NET tylko @ ASCII .

Wypróbuj online.

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 bajtów

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

Wyjaśnienie:

(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 

Przykład:

⎕:
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 bajtów

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

Wypróbuj online!

Mouse-2002 , 79 bajtów

Wykorzystywanie makr myszy do powtarzania funkcji.

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

Wypróbuj online!

Rubinowy , 55 bajtów

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

Wypróbuj online!

W jaki sposób?

Najpierw utwórz pierwszy wiersz, a następnie iteruj jego znaki. Wydrukuj całą linię, jeśli znak to „#”, w przeciwnym razie wydrukuj pojedynczy znak (który jest spacją)

Brain-Flak , 170 bajtów

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

Wypróbuj online!

Perl 6 , 35 33 bajtów

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

Wypróbuj online!

Anonimowy wywoływalny, który pobiera liczbę i drukuje tabliczkę mnożenia zs ze *znakiem nowej linii.

Wyjaśnienie:

{                             }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 bajtów

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

Zwraca macierz liczb.

Wypróbuj online!

Warianty o ftej samej liczbie bajtów:

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

Stax , 7 bajtów

é╫▐§╘←╘

Uruchom i debuguj

Wybrana postać jest odwrócona. (W jaki sposób kodujesz to w markdown?)

Oznacza to ai bsą uważane za obce białe znaki.

MathGolf , 20 bajtów

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

Wypróbuj online!

MathGolf naprawdę potrzebuje więcej funkcji do dzielenia list i tworzenia list 2D.

Wyjaśnienie

╒                      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

Atrament , 151 152 151 bajtów

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

Wypróbuj online!

Dobrze, że zasady dopuszczają nadmiar postaci.

Edycja: +1: Naprawiono odstępy. Wyświetlaj także za pomocą @ (który nie wymaga zmiany znaczenia) zamiast # (co robi)

Edycja: -1: Najwyraźniej ta poprawka oznaczała również, że nie potrzebowałem już kropki, aby wymusić nowy wiersz na niepustych liniach. Schludny.

C ++, 170 156 bajtów

Dzięki 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 bajtów

Wyjście graficzne. Dane wejściowe toN-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 bajtów

-5 bajtów od Jo King

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

Wypróbuj online!

Perl 6, 63 bajtów

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

C (gcc) , 108 104 bajtów

-4 bajty dzięki pułapkowi cat

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

Wypróbuj online!