Hình chữ nhật có thuộc tính đẹp này - một hình chữ nhật bao gồm chính xác ký tự!$n \times m$$n \times m$

Một .. đặc tính thú vị hơn là các hình chữ nhật có thể được căn chỉnh độc đáo trong bảng nhân - ví dụ: bảng :$3 \times 3$

# ## ###

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

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

Thử thách của bạn là, đưa ra một số ( ), đưa ra bảng nhân được định dạng .$n$$n > 1$$n \times n$

Quy tắc

• Bạn có thể lấy đầu vào ở trên hoặc dưới$n$
• Quy tắc I / O mặc định được áp dụng
• Bạn có thể chọn bất kỳ ký tự không phải khoảng trắng nào để thể hiện các khối; mọi ký tự khác (mặc dù dòng mới là đặc biệt) được coi là khoảng trắng. Ký tự được chọn có thể khác nhau cho các đầu vào khác nhau, nhưng phải giống nhau trong suốt đầu vào
• Kết quả có thể có các ký tự không cần thiết, miễn là bảng căn chỉnh và không có sự xuất hiện của ký tự được chọn mà không phải là một phần của đầu ra cần thiết
• Dấu phân cách phải rộng 1 ký tự / cao và hình chữ nhật phải được đóng gói (nghĩa là không có dấu phân cách giữa các ký tự của chúng)
• Các dòng trống có thể trống, không cần đệm
• Kết quả có thể là một chuỗi, ma trận, vectơ của các dòng, mảng các mảng ký tự hoặc bất cứ thứ gì 2Dish
• Bạn có thể xuất ra một ma trận / vectơ vectơ / bất cứ thứ gì 2Dish của các số, nhưng nền & tiền cảnh phải là 2 số riêng biệt (có thể thay đổi đầu vào thành đầu vào, nhưng không thể xuất hiện trong một đầu ra). Các ký tự xung quanh cũng được cho phép với định dạng này (mặc dù chúng phải khớp với số nền)
• Đây là mã golf , câu trả lời ngắn nhất tính theo byte, mỗi ngôn ngữ, sẽ thắng!

Ví dụ

Đối với đầu vào 2, một đầu ra nghệ thuật hợp lệ, với ký tự ∙, là:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{vâng, khoảng thời gian ở đó chỉ khiến bạn bối rối}
Một câu trả lời hợp lệ khác là ma trận số, với 2 là số nền và 9 tiền cảnh:

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

Một ví dụ đầu ra không hợp lệ sẽ là

#  # #


#  # #

#  # #

như các hình chữ nhật có dấu phân cách ở giữa chúng.

Kết quả ví dụ cho :$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 byte

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

Hãy thử trực tuyến!

Một cách tiếp cận thông minh của Ørjan Johansen xuất ra với 0 và 1, tạo ra mỗi 10...00phần dưới dạng chuỗi đại diện cho sức mạnh 10.

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell , 49 byte

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

Hãy thử trực tuyến!

Tạo một mô hình như thế [1,0,1,0,0,1,0,0,0,...], sau đó tạo 2D bằng cách lấy các mincặp. Sự kỳ lạ không có điểm giúp tiết kiệm 2 byte hơn mức dễ đọc hơn:

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

Hãy thử trực tuyến!

R , 56 54 43 36 30 byte

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

Hãy thử trực tuyến!

$n$$n = 4$$1s$$0s$

Nhờ digEmAll cho -7 byte.

JavaScript (ES6),  73 72  69 byte

Trả về một chuỗi được tạo bởi 1, khoảng trắng và nguồn cấp dữ liệu dòng.

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

Hãy thử trực tuyến!

JavaScript (ES7),  87 83  82 byte

Đã lưu 3 byte nhờ @dzaima

Trả về một ma trận nhị phân, được xây dựng từng ô.

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

Hãy thử trực tuyến!

Làm sao?

$w$

(NB: Khi được cho phép bởi các quy tắc thử thách, chúng tôi sẽ tạo ra một ma trận có chiều rộng thay thế.)$w+1$

Tương tự, ô nằm ở trống nếu phương trình bậc hai sau thừa nhận một số nguyên cho hoặc :$(X,Y)$$k=X$$k=Y$

có yếu tố quyết định là:

MATL, 14 10 byte

:"@:Fv]g&*

Câu trả lời này sử dụng 1cho các khối và 0cho nền

Dùng thử tại MATL Online

Giải trình

     % 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

Thạch , 8 byte

1ẋⱮj0ȧþ`

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Chỉnh sửa: -2 byte từ ngn. +2 byte vì các câu trả lời trước không hợp lệ (với ý tưởng nhờ ngn và dzaima).

Giải trình

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

Đầu ra sẽ giống như:

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

Thạch , 7 byte

‘RÄṬ|þ`

Hãy thử trực tuyến!

Xuất ra một ma trận chữ số, sử dụng cho các hình chữ nhật và cho phần đệm giữa chúng. Liên kết TIO chứa chân trang định dạng ma trận chữ số theo cách dễ đọc của con người bằng cách xếp các hàng và cột.$0$$1$

Giải trình

‘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

Số tại ô của bảng kết quả sẽ là nếu hoặc là số tam giác hoặc nếu không (vì bitwise OR hoạt động như logic OR trên 0 và 1). (Chúng tôi sử dụng , phạm vi từ 1, vì Jelly sử dụng lập chỉ mục dựa trên 1, vì vậy chúng tôi không phải lo lắng về việc cột 0 có đầy đủ 0 không; chúng tôi phải thêm 1 vào đầu vào vì mảng được tạo bởi$(x,y)$$1$$x$$y$$0$RṬdừng lại ở phần tử lớn nhất được đưa ra trong đầu vào, vì vậy chúng ta cần vẽ một đường thẳng ở phía bên tay phải và phía dưới.) Khoảng cách giữa các số tam giác là các số nguyên liên tiếp, do đó các khối hình chữ nhật được tạo bởi các khoảng trống giữa các dòng kết thúc lên như kích thước của câu hỏi yêu cầu; và việc sử dụng thao tác OR (trong trường hợp này là bitwise) cho phép các đường thẳng giao nhau một cách chính xác.

05AB1E , 9 byte

Xác định chương trình .$f\texttt{: }\color{purple}{\texttt{Nat}} →\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{List}}\texttt{[}\color{purple}{\texttt{Nat}}\texttt{]]}$

Mã số:

$L×0ýSDδ*

Sử dụng 05AB1E -encoding . Hãy thử trực tuyến! hoặc sử dụng phiên bản in đẹp .

Giải trình:

$ # Đẩy số 1 và đầu vào n 
 L # Tạo danh sách [1, 2, 3, ..., n ]
  × # Phép nhân chuỗi Vectorized: 1 × [1, 2, 3, ..., n ]
                 Điều này sẽ dẫn đến ["1", "11", "111", ..., "1" × n ]
   0ý # Tham gia danh sách kết quả với '0', kết quả là "10110111011110111110 ..."
     S # Chia thành các chữ số đơn: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Bảng nhân Dδ * # với chính nó

C # (Trình biên dịch tương tác Visual C #) , 96 95 byte

-1 byte nhờ Hiện thân của sự thiếu hiểu biết

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

Hãy thử trực tuyến!

Python 2 , 67 byte

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

Hãy thử trực tuyến!

In các dòng trống cho các dòng trống, mà thách thức cho phép.

Cùng độ dài (với đầu vào ở trên n):

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 41 byte

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

Hãy thử trực tuyến!

Than , 18 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

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

Hãy thử trực tuyến!

Một phiên bản sửa đổi nhiều nhờ những người hữu ích khác nhau (xem các ý kiến).

PowerShell , 42 40 byte

-2 byte nhờ mazzy .

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

Hãy thử trực tuyến!

Java 11, 109 byte

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

Cổng của câu trả lời C # .NET của @ ASCII .

Hãy thử trực tuyến.

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 + THẮNG, 29 byte

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

Giải trình:

(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 

Thí dụ:

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

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

Hãy thử trực tuyến!

Chuột-2002 , 79 byte

Lạm dụng macro của Chuột để lặp lại chức năng.

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

Hãy thử trực tuyến!

Ruby , 55 byte

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

Hãy thử trực tuyến!

Làm sao?

Đầu tiên, tạo dòng đầu tiên, sau đó lặp qua ký tự của nó. In toàn bộ dòng nếu ký tự là '#', nếu không thì in ký tự đơn (là khoảng trắng)

Brain-Flak , 170 byte

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

Hãy thử trực tuyến!

Perl 6 , 35 33 byte

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

Hãy thử trực tuyến!

Có thể gọi được ẩn danh lấy một số và in bảng nhân với *s với một dòng mới.

Giải trình:

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

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

Trả về một ma trận các số.

Hãy thử trực tuyến!

Các biến thể fcó cùng số byte:

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

Stax , 7 byte

é╫▐§╘←╘

Chạy và gỡ lỗi nó

Nhân vật được chọn là backtick. (Làm thế nào để bạn mã định dạng mà trong markdown?)

Điều đó có nghĩa avà bđược coi là khoảng trắng bên ngoài.

MathGolf , 20 byte

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

Hãy thử trực tuyến!

MathGolf thực sự cần có thêm một số chức năng để chia nhỏ danh sách và tạo danh sách 2D.

Giải trình

╒                      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

Mực in , 151 152 151 byte

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

Hãy thử trực tuyến!

Điều tốt là các quy tắc cho phép nhân vật thừa.

Chỉnh sửa: +1: Khoảng cách cố định. Ngoài ra, hiển thị bằng cách sử dụng @ (không cần thoát) thay vì # (không)

Chỉnh sửa: -1: Rõ ràng sửa chữa đó cũng có nghĩa là tôi không còn cần một khoảng thời gian kéo dài để buộc một dòng mới trên các dòng không trống. Khéo léo.

C ++, 170 156 byte

Cảm ơn 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 byte

Đầu ra đồ họa. Đầu vào là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 byte

-5 byte từ Jo King

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

Hãy thử trực tuyến!

Perl 6, 63 byte

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

C (gcc) , 108 104 byte

-4 byte nhờ vào trần nhà

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

Hãy thử trực tuyến!