Thử thách

Cho một kích thước s, in một mạng hình khối có kích thước đó được làm bằng các ký hiệu băm ( #) và dấu cách ( ).

Ví dụ:

1:
  #
# # #    
  #
  #

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

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

Mạng thực sự có thể là bất kỳ mạng khối hợp lệ nào có thể gấp lại thành một khối, ví dụ:

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

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

Quy tắc

• Mạng kết quả phải có giá trị hình học (có thể gập lại thành một khối)
• Sơ hở tiêu chuẩn bị cấm
• Đọc kỹ các quy tắc
• Đây là môn đánh gôn , câu trả lời ngắn nhất sẽ thắng, nhưng sẽ không được chọn

Python 2, 47 byte

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

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

In mạng này, được chọn để được chứng minh trái:

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

Các dòng có nhoặc 4*nbản sao của '# '. Đối với mỗi 1,4,1, chúng tôi in nthời gian nhiều bản sao, nthời gian thực hiện cho ncác dòng. Có một execvòng lặp bên trong một forvòng lặp có vẻ lãng phí, nhưng tôi đã không nhìn rõ hơn.

Các lựa chọn thay thế tôi đã thử nghiệm:

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

( defTất cả các chức năng có thể ngắn hơn một chương trình.)

Octave, 58 44 42 32 byte

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

một phần lấy cảm hứng từ câu trả lời trăn của @xnor.

z=repmat('# ',n);

tạo một mẫu hình vuông của '#' cho đầu vào 2 kết quả mẫu sau:

# #             
# # 

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

bốn zs được nối theo chiều ngang:

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

[z;y;z]

zvà yvà zđược nối theo chiều dọc

Dùng thử trực tuyến!

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

Câu trả lời trước:

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

Dùng thử trực tuyến!

Tạo một hình chữ T

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

Toán học, 77 60 52 byte

Cảm ơn Martin Ender đã chơi golf 8 byte!

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

Hàm không tên lấy một đối số nguyên dương #và trả về một chuỗi có dòng mới (bao gồm cả dòng mới); mỗi dòng có một không gian dấu là tốt. Đầu tiên chúng ta định nghĩa ±là một hàm lặp lại #thời gian đầu vào của nó ; sau đó ađược định nghĩa là ±"# "(đây #là một ký tự, không phải đầu vào!) và từ đó bđược định nghĩa là tập hợp các #dòng ngắn, trong khi đó ±{a,a,a,a}<>nlà tập hợp các #dòng dài. (Trong cả hai trường hợp, có một dòng cấp bằng chữ giữa các dấu ngoặc kép phù hợp.) Cuối cùng kết <>bhợp danh sách các chuỗi kết quả với bản sao thứ hai của tập hợp các dòng ngắn. Ví dụ đầu ra khi #=2( câu trả lời của xnor đã dạy tôi rằng định hướng này là golfier):

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

Phiên bản trước của việc thực hiện này:

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

Trình gốc:

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

Xây dựng một chuỗi ra khỏi 4*(3#+1)mảnh, mỗi trong số đó là một trong hai "# ", " "hoặc "\n"; chỉ cần tính toán những phần sẽ sử dụng dựa trên chỉ số n. Ví dụ đầu ra khi #=2:

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

JavaScript (ES6), 59 byte

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

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

Đầu ra bao gồm một khoảng trắng ở cuối mỗi dòng và một dòng mới.

Ruby, 36 byte

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

Sử dụng:

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

Ruby, 38 byte

Hình dạng này dài hơn trong Ruby nhưng tôi hy vọng có một số ngôn ngữ mà nó ngắn hơn.

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

Sử dụng:

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

Cả hai câu trả lời có thể ngắn hơn nếu được phép trả về (tốt nhất) một chuỗi các chuỗi hoặc (ít nhất là tốt hơn) một chuỗi thay vì in.

Scala, 56 byte

(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)

Kiểm tra

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 byte

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 byte

Ài# ddÀpLyGïp3PGïp

Với tất cả các ký tự ẩn được hiển thị

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

^[là 0x1b(thoát ký tự theo nghĩa đen) và^V là 0x16( C-v)

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

Tôi đã phải tăng bytecount vì Älệnh đã bị lỗi trong lần kéo V mới này

Đầu ra ở định dạng này:

# 
# # # # 
# 

với một dòng mới

Hexdump:

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

Giải trình

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

Bây giờ một mặt của mạng đã được hoàn thành, chúng ta phải tạo lưới

^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

Giải pháp thay thế nếu chúng ta không xuất ra khoảng trắng:

21 20 18 16 18 byte

Àé#ddÀpLyGïp3pGïp

(vì lý do tương tự như giải pháp hàng đầu, liên kết TIO này được sửa đổi)

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

V , 14 byte (không cạnh tranh)

Ài# 5Ù4JjòÀÄk

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

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

Vì lý do nào, thách thức này đã phát hiện ra nhiều lỗi. Bây giờ tất cả đều đã được sửa, phiên bản này không may không cạnh tranh, nhưng thật tuyệt khi thấy câu trả lời V cho thử thách này sẽ như thế nào khi không phải thêm hàng tấn byte để theo kịp mã hóa cẩu thả của tôi.

Giải trình:

À                   " 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

Thạch , 20 19 byte

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

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

-1 nhờ có 44874 (steenbergh).

^{TÔI KHÔNG THỂ GIÚP ĐƯỢC MUDDYFISH!}

Đây có phải là golf? 20 19 byte có vẻ như quá nhiều , nhìn thấy Liên kết 1.

Giải trình:

”#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.

Than , 20 byte

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

Mã kết thúc với một khoảng trắng. Hãy thử trực tuyến!

Giải trình

Than là một ngôn ngữ chuyên về nghệ thuật ASCII. Nó cũng không đầy đủ, lỗi, và tài liệu dưới. Chỉ cần nói rằng, điều này đã mất một số lượng lớn thử nghiệm và lỗi trước khi nó làm những gì nó được cho là.

• Ｎλnhập một số vào λ.
• Ｇlà lệnh đa giác, chúng ta sẽ sử dụng ở đây để vẽ một hình chữ nhật. ↑λ←×⁶λ↓λchỉ định đường viền của đa giác: λbước lên , bước trái 6 lần λvà λbước xuống . (Đó là ba λcủa λkhối side-by-side.) Cạnh đáy của hình chữ nhật được suy ra. Đa giác sau đó được lấp đầy bằng chuỗi # .
• Ｄ bỏ khung vẽ hiện tại vào thiết bị xuất chuẩn, dẫn đến kết quả như sau:

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

• Sau Ｇlệnh, con trỏ nằm ở góc dưới bên trái của khung vẽ. Ｍ×⁴λ←di chuyển nó về phía trái bằng 4 lần λbước (tương đương với hai λbằng λkhối).
• xuất ra một khoảng trống ở đó, mở rộng khung vẽ bên trái theo số lượng chính xác.
• Vào cuối chương trình, khung vẽ được (một lần nữa) được gửi đến thiết bị xuất chuẩn:

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

Đặt chúng lại với nhau và bạn đã có một mạng lưới hình khối.

Tiện ích Bash / Unix, 72 69 68 66 byte

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

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

Điều này hoạt động bằng cách sử dụng thực tế là [4 ^ k / 3], khi được viết trong cơ sở 2, là 10101010 ... 01, với k 1's. (Dấu ngoặc vuông ở đây biểu thị chức năng sàn.)

Pyke, 16 byte

uAD,sXF**"# 

Hãy thử nó ở đây!

Tương đương với

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

Vì không thể in

Điều này sử dụng một vài thủ thuật để giảm số lượng byte:

• Nó sử dụng một số unprintables để đại diện cho danh sách [1, 4, 1]
• XF tự động chuyển đầu ra vào ngăn xếp
• Chuỗi "#ở cuối được hoán đổi với cuối cùng *, có nghĩa "là không cần phải đóng. Điều này xảy ra ngầm khi mã thông báo cuối cùng là một chuỗi.

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

Python 2 , 68 71 65 byte

-6 cảm ơn @sagiksp

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

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

Trong trường hợp không tìm được cách đánh bại @xnor, tôi sẽ đăng chức năng đệ quy của mình đơn giản như một cách tiếp cận khác. Đối với bản in f (5)

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

Mẫu này được chọn đơn giản vì nó có thể được chia thành hai phần không giống như tất cả các phần khác.

PHP, 64 62 byte

Đã lưu 2 byte nhờ Christoph .

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

In một mạng như thế này:

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

(với một dòng mới hàng đầu)

Mẻ, 111 byte

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

In lưới lập phương trái. Thật khó để chơi gôn ...

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

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

Võng mạc , 39 37 byte

Đây là lần đầu tiên tôi sử dụng Retina, tôi vẫn đang cố gắng hiểu cách làm.

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

(có hai dấu cách sau dòng thứ 4 và thứ 5)

Cảm ơn Martin Ender đã chơi golf 2 byte!

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

QBIC , 52 67 40 byte

Hoàn thành viết lại:

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

Bây giờ sử dụng mô hình này:

###--
--###

Nơi -chứa đầy không gian.

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

15 byte mã, +1 cho -ncờ.

"# "Xa*_RLaM141

Lấy kích thước làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

                 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)

Dưới đây không chính xác là cách dữ liệu được sửa đổi, nhưng nó đưa ra ý tưởng cơ bản (cho a=2):

141

[1;4;1]

[2;8;2]

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

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

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

05AB1E , 13 byte

D141S×S*„# ×»

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

Giải trình

Ví dụ đầu vào 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 byte

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 byte

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

Giải thích:

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

Sau lần in đầu tiên (size = 2, @ là vị trí con trỏ):

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

@ 

Sau SCROLL:

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

Sau lần in thứ hai:

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

Lisp thường gặp, 83 81 79 byte

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

Sử dụng:

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

Đầu ra:

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

Làm thế nào nó hoạt động?

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

Ý tưởng để cải thiện được hoan nghênh.