사각형에는이 멋진 속성이 있습니다 사각형은 정확히 문자 로 구성됩니다 !$n \times m$$n \times m$

A .. 더 흥미로운 특성은 곱셈 테이블에서 사각형을 잘 정렬 할 수 있다는 것입니다 (예 : 테이블).$3 \times 3$

# ## ###

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

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

숫자 ( )이 주어지면 형식화 된 곱셈표를 출력해야 합니다.$n$$n > 1$$n \times n$

규칙

• 보다 위 또는 아래에서 입력을받을 수 있습니다$n$
• 기본 I / O 규칙이 적용됩니다
• 공백이 아닌 문자를 선택하여 블록을 나타낼 수 있습니다. 다른 모든 문자 (개행은 특별하지만)는 공백으로 간주됩니다. 선택한 문자는 입력에 따라 다를 수 있지만 입력 전체에서 동일해야합니다.
• 테이블이 정렬되고 필요한 출력의 일부가 아닌 선택된 문자가 나타나지 않는 한 결과에 불필요한 문자가있을 수 있습니다.
• 구분자는 1 자 너비 / 높이 여야하고 사각형을 묶어야합니다 (즉, 문자 사이에 구분자가 없어야 함).
• 빈 줄은 비워 둘 수 있으며 패딩은 필요하지 않습니다.
• 결과는 문자열, 행렬, 라인 벡터, 문자 배열 배열 또는 2Dish 일 수 있습니다.
• 다른 방법으로 행렬 / 벡터-벡터 / 어떤 2Dish 숫자를 출력 할 수 있지만 배경과 전경은 2 개의 고유 숫자 (입력에 따라 입력이 가능하지만 출력 전체가 아닌) 여야하며 다른 숫자는 존재할 수 없습니다. 배경 형식과 일치해야하지만 추가 주변 문자도이 형식으로 사용할 수 있습니다.
• 이것은 code-golf , 바이트 단위의 짧은 대답, 언어 별, 승리입니다!

예

input의 2경우 문자 ∙가 있는 유효한 ASCII 아트 출력 은 다음과 같습니다.

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{예, 기간은 당신을 혼란스럽게합니다}
숫자 행렬로 유효한 또 다른 대답은 2이며 배경 숫자는 9이고 전경은 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

하스켈 , 43 바이트

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

온라인으로 사용해보십시오!

0과 1로 출력하는 Ørjan Johansen의 영리한 접근 방식은 각 10...00부분을 ​​10의 거듭 제곱의 문자열 표현으로 생성합니다 .

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

하스켈 , 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

온라인으로 사용해보십시오!

위의 입력을 하나 받습니다 (따라서 3x3 행렬을 반환합니다 ). 의 행렬을 반환 $n$$n = 4$$1s$$0s$

-7 바이트의 digEmAll에 감사합니다.

자바 스크립트 (ES6),  73 72  69 바이트

1, 공백 및 줄 바꿈으로 구성된 문자열을 반환합니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (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$

(NB : 챌린지 규칙에서 허용하는대로 너비 의 행렬을 대신 출력합니다 .)$w+1$

마찬가지로, 다음 2 차가 또는 대한 정수 루트를 허용하면 에있는 셀 이 비어 있습니다 .$(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

결과 테이블의 셀 에있는 숫자는 또는 가 삼각 숫자 이면 이되고, 그렇지 않으면 됩니다 (비트 OR은 0과 1의 논리 OR처럼 작동하기 때문에). (우리가 사용하는 젤리 1 기반 색인을 사용하기 때문에 우리가 열 0 0의 잘못 전체 것에 대해 걱정을하지 않아도, 1, 범위를 우리는 배열에 의해 생성하기 때문에 입력에 1을 추가해야$(x,y)$$1$$x$$y$$0$RṬ입력에 주어진 가장 큰 요소에서 멈추므로 오른쪽과 아래쪽에 선을 그려야합니다.) 삼각형 숫자 사이의 간격은 연속적인 정수이므로 선 끝 사이의 간격으로 형성된 직사각형 블록 질문에 의해 요청 된 크기만큼; OR 연산 (이 경우 비트 단위)을 사용하면 선이 서로 올바르게 교차 할 수 있습니다.

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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! 또는 인쇄본 버전을 사용하십시오 .

설명:

$ # 숫자 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:"");}

온라인으로 사용해보십시오!

파이썬 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 Language (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 바이트

mazzy 덕분에 -2 바이트 .

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

온라인으로 사용해보십시오!

자바 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 전용 포트 C # .NET 답변 .

온라인으로 사용해보십시오.

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.

온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!

루비 , 55 바이트

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

온라인으로 사용해보십시오!

어떻게?

먼저 첫 번째 줄을 만든 다음 문자를 반복하십시오. 문자가 '#'이면 전체 줄을 인쇄하고 그렇지 않으면 공백 인 단일 문자를 인쇄하십시오.

Brain-Flak , 170 바이트

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

온라인으로 사용해보십시오!

펄 6 , 35 33 바이트

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

온라인으로 사용해보십시오!

익명의 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

하스켈, 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 바이트

é╫▐§╘←╘

실행 및 디버깅

선택한 캐릭터는 백틱입니다. (마크 다운에서 어떻게 코드를 포맷합니까?)

즉 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

파이썬 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)

온라인으로 사용해보십시오!

펄 6, 63 바이트

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

C (gcc) , 108104 바이트

ceilingcat 덕분에 -4 바이트

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

온라인으로 사용해보십시오!