Dikdörtgenler bu güzel özelliğe sahiptir - bir dikdörtgen tam olarak karakterlerinden oluşur!$n \times m$$n \times m$

Daha ilginç bir özellik ise, dikdörtgenlerin çarpım tablosunda - örneğin bir tabloda - güzelce hizalanmasıdır :$3 \times 3$

# ## ###

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

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

Buradaki zorluk ( ) sayısı verilen , biçimlendirilmiş çarpım tablosu oluşturmaktır.$n$$n > 1$$n \times n$

kurallar

• Girdiyi üstünde ya da altında alabilirsiniz.$n$
• Varsayılan G / Ç kuralları geçerlidir
• Blokları temsil etmek için herhangi bir boşluk olmayan karakter seçebilirsiniz; diğer her karakter (yeni satırlar özel olsa da) boşluk olarak kabul edilir. Seçilen karakter farklı girişler için farklı olabilir, ancak giriş boyunca aynı olmalıdır
• Sonuç, tablo hizalandığı ve gerekli çıktının bir parçası olmayan seçilen karakterin tekrarı olmadığı sürece, gereksiz karakterlere sahip olabilir.
• Ayırıcılar 1 karakter genişliğinde / yüksekliğinde olmalı ve dikdörtgenler paketlenmelidir (yani karakterleri arasında ayraç yoktur)
• Boş satırlar boş olabilir, doldurma gerekli değildir
• Sonuç, bir dize, matris, çizgi vektörü, karakter dizileri dizisi veya 2Dish gibi herhangi bir şey olabilir.
• Alternatif olarak bir matris / vektör-vektör / herhangi bir şey çıktısı alabilirsiniz. Sayıların 2B'si olabilir, ancak arka plan ve ön plan 2 ayrı sayı olmalıdır (bu girdiyi girdiye göre değişebilir, ancak çıktı boyunca değil) ve başka sayı bulunamaz. Ekstra çevre karakterlere bu formatta izin verilir (arka plan numaralarıyla eşleşmeleri gerekir)
• Bu kod golf , bayt cinsinden en kısa cevap, dil başına kazanç!

Örnekler

Girdi için 2, geçerli bir ascii-art çıktısı, karakteri ∙ile:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙

^{evet dönem sadece sizi şaşırtmak için orada.}
Sayı matrisi olarak geçerli başka bir cevap, 2 arka plan numarası ve 9 ön 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]]

Geçersiz bir çıktı örneği

#  # #


#  # #

#  # #

dikdörtgenler aralarında ayırıcılar olduğu gibi.

için örnek çıktılar :$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 bayt

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

Çevrimiçi deneyin!

Ørjan Johansen'in 0'lı ve 1'lerle 10...00çıktığı ve her bir parçayı 10'luk bir gücün ip temsili olarak üreten akıllıca bir yaklaşım .

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000

Haskell , 49 bayt

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

Çevrimiçi deneyin!

Gibi bir desen oluşturur [1,0,1,0,0,1,0,0,0,...], sonra minçiftleri alarak bir 2D yapar . Noktasız tuhaflık 2 bayttan daha okunabilir:

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

Çevrimiçi deneyin!

R , 56 54 43 36 30 bayt

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

Çevrimiçi deneyin!

Birini üstünde alır ( için 3x3 matrisini döndürür ). Önünde ek bir sıfır / sütunu olan (ön plan) ve (arka plan) matrisini döndürür .$n$$n = 4$$1s$$0s$

-7 baytlık digEmAll için teşekkürler.

JavaScript (ES6),  73 72  69 bayt

1, boşluk ve satır yayınlarından oluşan bir dize döndürür.

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

Çevrimiçi deneyin!

JavaScript (ES7),  87 83  82 bayt

@Dzaima sayesinde 3 bayt kaydedildi

Hücre tarafından hücre tarafından oluşturulan bir ikili matris döndürür.

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

Çevrimiçi deneyin!

Nasıl?

Matrisin genişliği $w$ şöyledir:

(Not: Meydan okuma kurallarının izin verdiği gibi, bunun yerine genişliğinde bir matris çıkarırız.)$w+1$

Benzer şekilde, aşağıdaki karesel veya için bir tamsayı kökü kabul ederse de bulunan hücre boştur :$(X,Y)$$k=X$$k=Y$

kimin belirleyicisi:

MATL, 14 10 bayt

:"@:Fv]g&*

Bu cevap 1bloklar ve 0arka plan için kullanır

MATL Online'da deneyin

açıklama

     % 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

Jöle , 8 bayt

1ẋⱮj0ȧþ`

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Düzenleme: ngn'den -2 bayt. +2 bayt, çünkü önceki cevaplar geçersizdi (ngn ve dzaima sayesinde).

açıklama

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

Çıktı şöyle görünmelidir:

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

Jöle , 7 bayt

‘RÄṬ|þ`

Çevrimiçi deneyin!

$0$$1$

açıklama

‘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ṬGirişte verilen en büyük elemanda durur, bu yüzden sağ ve alt tarafa bir çizgi çizmemiz gerekir.) Üçgen sayılar arasındaki boşluklar ardışık tamsayılardır, bu nedenle satırlar arasındaki boşlukların oluşturduğu dikdörtgen bloklar Sorunun talep ettiği boyutlar kadar; ve bir OR işleminin kullanılması (bu durumda, bit yönünde), çizgilerin birbirini doğru bir şekilde geçmesini sağlar.

05AB1E , 9 bayt

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

05AB1E kodlamasını kullanır . Çevrimiçi deneyin! veya güzel basılmış sürümü kullanın .

Açıklama:

$ # 1 numara ve giriş itin n 
 L # listesi oluşturma [1, 2, 3, ..., n ]
  × # Vectorized dize çarpımı: 1 × [1, 2, 3, ..., n ]
                 Bu, ["1", "11", "111", ..., "1" × n ] ile sonuçlanır.
   0ı # Sonuç listesine '0' ile katılın, "10110111011110111110 ..." ile sonuçlandı.
     S # Tek hanelere bölün: [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, ...]
      Dδ * # Kendisi ile çarpım tablosu

C # (Visual C # Etkileşimli Derleyici) , 96 95 bayt

Cehalet Uygulaması sayesinde -1 bayt

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

Çevrimiçi deneyin!

Python 2,67 bayt

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

Çevrimiçi deneyin!

Yarışmanın izin verdiği boş satırlar için boş satırlar yazdırır.

Aynı uzunluk (yukarıdaki bir girişi ile n):

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 41 bayt

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

Çevrimiçi deneyin!

Kömür , 18 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

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

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

Çevrimiçi deneyin!

Çeşitli yardımcı insanlar sayesinde çok revize edilmiş bir versiyon (yorumlara bakınız).

PowerShell , 42 40 bayt

Mazzy sayesinde -2 bayt .

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

Çevrimiçi deneyin!

Java 11, 109 bayt

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

@ ASCII-yalnızca C # .NET cevabının limanı .

Çevrimiçi deneyin.

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 bayt

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

Açıklama:

(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 

Örnek:

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

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

Çevrimiçi deneyin!

Fare-2002 , 79 bayt

İşlevleri tekrarlamak için Mouse'un makrolarını kötüye kullanma.

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

Çevrimiçi deneyin!

Ruby , 55 bayt

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

Çevrimiçi deneyin!

Nasıl?

İlk önce ilk satırı yaratın, sonra karakterlerini tekrarlayın. Karakter '#' ise tüm satırı yazdır, aksi halde tek karakteri yazdır (boşluk olan)

Brain-Flak , 170 bayt

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

Çevrimiçi deneyin!

Perl 6 , 35 33 bayt

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

Çevrimiçi deneyin!

Bir sayı alır ve çarpım tablosunu *s ile izleyen bir satırsonu ile yazdıran Anonim Callable .

Açıklama:

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

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

Sayı matrisini döndürür.

Çevrimiçi deneyin!

fAynı bayt sayımının varyantları :

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

Stax , 7 bayt

é╫▐§╘←╘

Koş ve hata ayıkla

Seçilen karakter geri tepmedir. (Bunu etiketleme biçiminde nasıl kodlarsınız?)

Bu, yabancı boşluk olduğu anlamına gelir ave bkabul edilir.

MathGolf , 20 bayt

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

Çevrimiçi deneyin!

MathGolf, listeleri bölmek ve 2B listeler oluşturmak için biraz daha işlevselliğe ihtiyaç duyuyor.

açıklama

╒                      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ürekkep , 151 152 151 bayt

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

Çevrimiçi deneyin!

İyi ki kurallar fazla karakterlere izin veriyor.

Düzenleme: +1: Sabit aralık. Ayrıca, # yerine (kaçmayı gerektirmeyen) @ kullanarak göster

Düzenleme: -1: Görünüşe göre bu düzeltme, boş olmayan satırlarda yeni bir çizgiyi zorlamak için artık son bir zamana ihtiyacım olmadığı anlamına geliyordu. Temiz.

C ++, 170 156 bayt

Dzaima için teşekkürler

#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 bayt

Grafik çıktı. Giriş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 bayt

-Jo King'den 5 bayt

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

Çevrimiçi deneyin!

Perl 6, 63 bayt

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

C (gcc) , 108 104 bayt

Ceilingcat sayesinde -4 bayt

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

Çevrimiçi deneyin!