ท้าทาย

เมื่อกำหนดขนาด s ให้พิมพ์ลูกบาศก์สุทธิของขนาดนั้นที่ทำจากสัญลักษณ์แฮช ( #) และช่องว่าง ( )

ตัวอย่าง:

1:
  #
# # #    
  #
  #

2:
    # #
    # #
# # # # # #
# # # # # #
    # #
    # #
    # #
    # #

3:
      # # #
      # # #
      # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #
      # # #
      # # #
      # # #
      # # #
      # # #

เน็ตสามารถเป็นคิวบ์สุทธิที่ถูกต้องใด ๆ ที่สามารถพับเป็นคิวบ์ตัวอย่างเช่น:

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

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

กฎระเบียบ

• ตาข่ายที่ได้นั้นจะต้องถูกต้องทางเรขาคณิต (สามารถพับเก็บได้ในคิวบ์)
• ช่องโหว่มาตรฐานต้องห้าม
• อ่านกฎอย่างระมัดระวัง
• นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดชนะ แต่จะไม่ถูกเลือก

Python 2, 47 ไบต์

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

ลองออนไลน์!

พิมพ์เครือข่ายนี้เลือกให้เป็นผู้ชอบธรรม

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

เส้นมีnหรือสำเนาของ4*n '# 'ในแต่ละครั้ง1,4,1เราพิมพ์nเวลาที่สำเนาจำนวนมากทำnเวลาให้กับnบรรทัด มีexecห่วงอยู่ภายในforวงดูเหมือนว่าสิ้นเปลือง แต่ผมไม่ได้เห็นดีกว่า

ทางเลือกที่ฉันทดสอบ:

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

( defฟังก์ชั่นสามารถสั้นลงหนึ่งโปรแกรมได้)

คู่, 58 44 42 32 ไบต์

@(n)[z=repmat('# ',n);z,z,z,z;z]

ได้รับแรงบันดาลใจส่วนหนึ่งจากคำตอบหลามของ @xnor

z=repmat('# ',n);

สร้างรูปแบบสแควร์ของ '#' สำหรับผลลัพธ์ 2 อินพุทรูปแบบต่อไปนี้:

# #             
# # 

y=[z,z,z,z];

สี่zs เรียงต่อกันเป็นแนวนอน:

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

[z;y;z]

zและyและzเรียงต่อกันในแนวตั้ง

ลองออนไลน์!

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

คำตอบก่อนหน้า:

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

ลองออนไลน์!

สร้างรูปตัว T

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

Mathematica, 77 60 52 ไบต์

ขอบคุณ Martin Ender สำหรับการเล่นกอล์ฟ 8 ไบต์!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

ฟังก์ชั่นที่ไม่มีชื่อการโต้แย้งจำนวนเต็มบวก#และส่งกลับสตริงที่มีการขึ้นบรรทัดใหม่ (รวมถึงการขึ้นบรรทัดใหม่) แต่ละบรรทัดมีพื้นที่ต่อท้ายเช่นกัน ก่อนอื่นเรานิยาม±ให้เป็นฟังก์ชั่นที่ซ้ำ#เวลาของอินพุต จากนั้นaจะถูกกำหนดเป็น±"# "(นี่#คือตัวละครไม่ใช่อินพุต!) และจากนั้นbจะถูกกำหนดให้เป็นชุดของ#เส้นสั้น ๆ ในขณะที่±{a,a,a,a}<>nเป็นชุดของ#สายยาว (ในทั้งสองกรณีจะมีการป้อนบรรทัดตามตัวอักษรระหว่างเครื่องหมายคำพูดที่ตรงกัน) สุดท้าย<>bเชื่อมต่อรายการผลลัพธ์ของสตริงพร้อมสำเนาที่สองของชุดของบรรทัดสั้น ๆ ตัวอย่างผลลัพธ์เมื่อ#=2( คำตอบของ xnorสอนให้ฉันรู้ว่าการวางแนวนี้เป็นนักกอล์ฟ):

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

เวอร์ชันก่อนหน้าของการใช้งานนี้:

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

ส่งต้นฉบับ:

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

สร้างออกสตริงของ4*(3#+1)ชิ้นซึ่งแต่ละอย่างใดอย่างหนึ่ง"# ", " "หรือ"\n"; nเพียงแค่คำนวณซึ่งชิ้นเพื่อใช้ขึ้นอยู่กับดัชนี ตัวอย่างผลลัพธ์เมื่อ#=2:

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

JavaScript (ES6), 59 ไบต์

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

เอาท์พุทรวมถึงพื้นที่ต่อท้ายในตอนท้ายของแต่ละบรรทัดและขึ้นบรรทัดใหม่

Ruby, 36 ไบต์

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

การใช้งาน:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

ทับทิมขนาด 38 ไบต์

รูปร่างนี้ยาวกว่าใน Ruby แต่ฉันคาดว่าจะมีบางภาษาที่สั้นกว่า

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

การใช้งาน:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

ทั้งสองคำตอบอาจสั้นลงหากได้รับอนุญาตให้ส่งกลับอาร์เรย์ (ควร) เป็นชุดของสตริงหรือ (ควรมีน้อยกว่า) สายเดี่ยวแทนที่จะพิมพ์

สกาลา 56 ไบต์

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""

JavaScript (ES6), 71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

ทดสอบ

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()

<input id=I type=number value=3 oninput='update()'><pre id=O></pre>

Java 8, 99 ไบต์

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}

V , 24 23 20 18 20 ไบต์

Ài# ddÀpLyGïp3PGïp

พร้อมแสดงตัวอักษรที่ซ่อนอยู่ทั้งหมด

Ài# ^[ddÀp^VLyGïp3PGoïp

^[คือ0x1b(ยกเว้นตัวอักษรตามตัวอักษร) และ^Vคือ0x16( C-v)

ลองออนไลน์!

ฉันต้องเพิ่มจำนวนไบต์เนื่องจากÄคำสั่งถูกบั๊กกี้ใน V pull ใหม่

ผลลัพธ์ในรูปแบบนี้:

# 
# # # # 
# 

ด้วย newline ชั้นนำ

hexdump:

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

คำอธิบาย

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

ตอนนี้ใบหน้าของเน็ตเสร็จสมบูรณ์เราต้องสร้างเน็ต

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

โซลูชันสำรองหากเราไม่ส่งออกช่องว่าง:

21 20 18 16 18 ไบต์

Àé#ddÀpLyGïp3pGïp

(ด้วยเหตุผลเดียวกับโซลูชันอันดับต้น ๆ ลิงก์ TIO นี้จะได้รับการแก้ไข)

ลองออนไลน์!

V , 14 ไบต์ (ไม่ใช่การแข่งขัน)

Ài# 5Ù4JjòÀÄk

ลองออนไลน์!

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

ไม่ว่าจะด้วยเหตุผลใดก็ตามความท้าทายนี้ได้เปิดเผยข้อบกพร่องมากมาย ตอนนี้พวกเขาได้รับการแก้ไขแล้วรุ่นนี้น่าเสียดายที่ไม่ใช่การแข่งขัน แต่มันก็ดีที่เห็นว่าคำตอบ V สำหรับความท้าทายนี้ควรมีลักษณะอย่างไรเมื่อมันไม่จำเป็นต้องเพิ่มจำนวนไบต์จำนวนมากเพื่อติดตามการเข้ารหัสที่เลอะเทอะของฉัน

คำอธิบาย:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line

เยลลี่ , 20 19 ไบต์

”#xẋ³Wẋ³K€Y
141DÇ€Y

ลองออนไลน์!

-1 ขอบคุณ 44874 (steenbergh)

^{ฉันไม่สามารถช่วยเหลือเจ้าพ่อ MUDDYFISH ได้!}

นี้เป็นสนามกอล์ฟหรือไม่? 20 19 ไบต์ดูเหมือนว่าจะมากเกินไปเมื่อได้เห็นลิงก์ 1

คำอธิบาย:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.

ถ่าน 20 ไบต์

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ← 

รหัสลงท้ายด้วยช่องว่าง ลองออนไลน์!

คำอธิบาย

Charcoal เป็นภาษาที่เชี่ยวชาญในศิลปะ ASCII มันยังไม่สมบูรณ์บั๊กกี้และเอกสารไม่ครบ พอจะพูดได้ว่านี่ใช้เวลาในการลองผิดลองถูกก่อนที่จะทำตามที่ควรจะเป็น

• Ｎλλปัจจัยการผลิตเป็นจำนวนมากเข้ามา
• Ｇคือคำสั่งรูปหลายเหลี่ยมซึ่งเราจะใช้ที่นี่เพื่อวาดรูปสี่เหลี่ยมผืนผ้า ↑λ←×⁶λ↓λระบุเส้นขอบของรูปหลายเหลี่ยม: λขั้นตอนขึ้น, 6 ครั้งทางซ้ายλและλขั้นตอนลง (ที่สามλจากλบล็อกด้านข้าง.) ขอบด้านล่างของรูปสี่เหลี่ยมผืนผ้าที่มีการอ้างถึง # รูปหลายเหลี่ยมเต็มไปแล้วกับสตริง
• Ｄ ดัมพ์ผืนผ้าใบปัจจุบันไปที่ stdout ทำให้มีลักษณะดังนี้:

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

• หลังจากＧคำสั่งเคอร์เซอร์จะอยู่ที่มุมซ้ายล่างของผืนผ้าใบ Ｍ×⁴λ←ย้ายมันไปทางซ้ายโดยครั้งที่ 4 λขั้นตอน (เทียบเท่าสองλโดยλบล็อก)
• ออกพื้นที่ที่นั่นขยายผืนผ้าใบไปทางซ้ายด้วยจำนวนที่ถูกต้อง
• ในตอนท้ายของโปรแกรมผ้าใบจะถูกส่งไปยัง stdout (อีกครั้ง):

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

รวมพวกมันเข้าด้วยกันแล้วคุณจะได้ลูกบาศก์สุทธิ

ยูทิลิตีBash / Unix, 72 69 68 66 ไบต์

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

ลองออนไลน์!

สิ่งนี้ทำงานโดยใช้ความจริงที่ว่า [4 ^ k / 3] เมื่อเขียนในฐาน 2 คือ 10101010 ... 01 โดยมี k 1 (เครื่องหมายวงเล็บเหลี่ยมที่นี่แสดงถึงการทำงานของพื้น)

Pyke ขนาด 16 ไบต์

uAD,sXF**"# 

ลองที่นี่!

เทียบเท่ากับ

1 4 1]3AD,sXF**"# 

เพราะ unprintables

ใช้สองเทคนิคเพื่อลดจำนวนไบต์:

• มันใช้ unprintables บางอย่างเพื่อแสดงรายการ [1, 4, 1]
• XF ดัมพ์โดยอัตโนมัติไปที่สแต็ก
• สตริง"#ที่ท้ายได้รับการสลับกับสุดท้าย*หมายความว่า"ไม่จำเป็นต้องปิด สิ่งนี้จะเกิดขึ้นโดยปริยายเมื่อโทเค็นสุดท้ายเป็นสตริง

u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)

Python 2 , 68 71 65 ไบต์

-6 ด้วยขอบคุณ @sagiksp

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

ลองออนไลน์!

ในกรณีที่ไม่มีการหาวิธีเอาชนะ @xnor ฉันจะโพสต์ฟังก์ชันการเรียกซ้ำของฉันอย่างง่ายๆเป็นวิธีการทางเลือก สำหรับการพิมพ์ f (5)

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

รูปแบบนี้ถูกเลือกเพียงเพราะสามารถแบ่งออกเป็นสองส่วนซึ่งแตกต่างจากส่วนอื่น ๆ ทั้งหมด

PHP, 64 62 ไบต์

ที่บันทึกไว้ 2 ไบต์ขอบคุณที่คริสโต

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

พิมพ์เน็ตเช่นนี้:

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

(ขึ้นบรรทัดใหม่ด้วย)

แบตช์ 111 ไบต์

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%

Pushy , 32 29 28 ไบต์

พิมพ์ cube net left-justified นี่ยากที่จะตีกอล์ฟ ...

&V:`# `;{:";N^:4:";T'.;TD^:"

ลองออนไลน์!

เรติน่า39 39ไบต์

นี่เป็นครั้งแรกที่ฉันใช้ Retina ฉันยังคงพยายามเข้าใจวิธีการทำสิ่งต่าง ๆ

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(ที่มีช่องว่างต่อท้ายสองหลังบรรทัดที่ 4 และ 5)

ขอบคุณ Martin Ender สำหรับการเล่นกอล์ฟ 2 ไบท์!

ลองออนไลน์!

QBIC , 52 67 40 ไบต์

เสร็จสิ้นการเขียนใหม่:

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

ตอนนี้ใช้รูปแบบนี้:

###--
--###

ที่ที่-เต็มไปด้วยช่องว่าง

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)

Pip , 28 17 16 ไบต์

โค้ด 15 ไบต์, +1 สำหรับการ-nตั้งค่าสถานะ

"# "Xa*_RLaM141

ใช้ขนาดเป็นอาร์กิวเมนต์บรรทัดคำสั่ง ลองออนไลน์!

คำอธิบาย

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

ต่อไปนี้ไม่ได้เป็นวิธีที่ข้อมูลได้รับการแก้ไข แต่ให้แนวคิดพื้นฐาน (สำหรับa=2):

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

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

05AB1E , 13 ไบต์

D141S×S*„# ×»

ลองออนไลน์!

คำอธิบาย

ตัวอย่างอินพุต n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # # 

C #, 152 ไบต์

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};

SmileBASIC, 57 50 ไบต์

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

อธิบาย:

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

หลังจาก PRINT แรก (size = 2, @ คือตำแหน่งเคอร์เซอร์):

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

@ 

หลังจากเลื่อน:

    ######
    ######
@

หลังจากพิมพ์ครั้งที่สอง:

    ######
    ######
######
######
@

เสียงกระเพื่อมสามัญ83 81 79 ไบต์

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

การใช้งาน:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

เอาท์พุท:

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

มันทำงานยังไง?

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

ยินดีต้อนรับแนวคิดสำหรับการปรับปรุง