Một Octothorpe, (còn được gọi là ký hiệu số, hàm băm hoặc hashtag hoặc dấu thăng) là ký tự ASCII sau:

#

Đó không phải là một hình dạng vui vẻ? Hãy làm cho phiên bản lớn hơn của nó! Vì vậy, đây là thách thức của bạn:

Cho một số nguyên dương N , sản lượng một hashtag ASCII kích thước N .

Ví dụ: hashtag ASCII có kích thước 1 trông như thế này:

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

Trailing khoảng trắng trên mỗi dòng được cho phép, nhưng không bắt buộc.

Đầu vào sẽ luôn là số nguyên dương hợp lệ, do đó bạn không phải xử lý các số không, âm hoặc 0. Đầu ra của bạn có thể ở bất kỳ định dạng hợp lý nào, do đó, xuất ra STDOUT, trả về danh sách các chuỗi hoặc chuỗi với dòng mới, ma trận 2D của các ký tự, ghi vào tệp, v.v ... đều ổn.

Các trường hợp thử nghiệm

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

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

4:
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    

5:
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     

Vì đây là môn đánh gôn, hãy cố gắng viết giải pháp ngắn nhất có thể, và trên hết, hãy vui vẻ!

MATL , 20 16 12 11 byte

3 byte nhờ DJMcMayhem.

1 byte nhờ Luis Mendo.

21BwY"&*~Zc

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

Giải trình

    % stack starts with input e.g. 2
21  % push 21 to stack             2 21
B   % convert to binary            2 [1 0 1 0 1]
w   % swap                         [1 0 1 0 1] 2
Y"  % repeat                       [1 1 0 0 1 1 0 0 1 1]
&*  % one-input multiplication    [[1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]]
~   % complement                  [[0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]]
Zc  % convert 0 to spaces            ##  ##  
      1 to octothorpes               ##  ##  
      and join by newline          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  

Brain-Flak , 420 byte

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

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

Không, điểm số 420 không cố ý. Tôi hứa. Phiên bản dễ đọc:

# 3 Times...
(()()())
{
({}<

    #Duplicate the input
    (({}))

    #Input times...
    {
        ({}<

        #Switch to the main stack
        <>

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back to the alternate stack
        <>

        #Decrement the (second) loop counter
        >[()])

    #Endwhile
    }

    #Pop the now zeroed loop counter
    {}

    #Turn [a] into [a, a*5, a]
    ((({}))<(({})(({}){}){})>)

    #A times....
    {
        ({}<

        #Toggle back over
        <>

        #Grab a*5
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back
        <>

        #Decrement the (second) loop counter
        >[()])

    }

    #Pop the loop counter and the a*5
    {}{}

#Decrement the outer loop counter
>[()])
}

#Pop the zeroed loop counter
{}

#Pop a over
({}<>)

#Pushes (a**2) * 5 + a
(({})((({({})({}[()])}{})){}){}{})

#That many times...
{({}<

    #Pop a character off the output stack
    {}

>[()])}

Mã máy 6502 (C64), 59 56 byte

00 C0 20 9B B7 A9 06 85 FC 86 FE A6 FE 86 FD A9 03 4D 1F C0 8D 1F C0 C6 FC D0
01 60 A9 23 A0 05 49 00 20 D2 FF CA D0 FA A6 FE 88 D0 F3 A9 0D 20 D2 FF C6 FD
D0 E6 F0 D3

Bản demo trực tuyến

Cách sử dụng: SYS49152,Ntrong đó N là một số từ 1 đến 255.

_{(giá trị lớn hơn 4 sẽ quá lớn đối với màn hình C64, bắt đầu từ 8, đầu ra thậm chí quá rộng)}

Giải thích :

         00 C0       .WORD $C000    ; load address

.C:c000  20 9B B7    JSR $B79B      ; read N into X
.C:c003  A9 06       LDA #$06       ; number of "logical" lines plus 1 for hash
.C:c005  85 FC       STA $FC        ; store in counter variable for lines
.C:c007  86 FE       STX $FE        ; store N in counter variable for char repetitions
.C:c009  A6 FE       LDX $FE        ; load repetition counter
.C:c00b  86 FD       STX $FD        ; store in counter variable for line repetitions
.C:c00d  A9 03       LDA #$03       ; value to toggle the character toggle
.C:c00f  4D 1F C0    EOR $C01F      ; xor character bit toggle
.C:c012  8D 1F C0    STA $C01F      ; store character bit toggle
.C:c015  C6 FC       DEC $FC        ; decrement "logical" lines
.C:c017  D0 01       BNE $C01A      ; not 0 -> continue
.C:c019  60          RTS            ; program done
.C:c01a  A9 23       LDA #$23       ; load hash character
.C:c01c  A0 05       LDY #$05       ; load "logical" columns for hash
.C:c01e  49 00       EOR #$00       ; in each odd "logical" line, toggle character
.C:c020  20 D2 FF    JSR $FFD2      ; output one character
.C:c023  CA          DEX            ; decrement character repetition
.C:c024  D0 FA       BNE $C020      ; not 0 -> back to output
.C:c026  A6 FE       LDX $FE        ; reload character repetition
.C:c028  88          DEY            ; decrement "logical" columns
.C:c029  D0 F3       BNE $C01E      ; not 0 -> back to character toggle
.C:c02b  A9 0D       LDA #$0D       ; line done, load newline character
.C:c02d  20 D2 FF    JSR $FFD2      ; and output
.C:c030  C6 FD       DEC $FD        ; decrement line repetitions
.C:c032  D0 E6       BNE $C01A      ; not 0 -> back to character init
.C:c034  F0 D3       BEQ $C009      ; else back to main loop (toggle char toggling)

Haskell , 43 byte

l%n=l!!1:l++l<*[1..n]
f n=["##"%n,"# "%n]%n

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

Xuất ra một danh sách các chuỗi.

Python 2 , 55 byte

def f(n):p=[(" "*n+"#"*n)*2]*n;print(p+["#"*n*5]*n)*2+p

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

Điều này trả về một danh sách 2D của các nhân vật.

Python 2 , 65 byte

def f(n):p=((" "*n+"#"*n)*2+"\n")*n;print(p+("#"*n*5+"\n")*n)*2+p

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

Python 2 , 66 byte

def f(n):p=[(" "*n+"#"*n)*2]*n;print'\n'.join((p+["#"*n*5]*n)*2+p)

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

Than , 21 byte

ＮθＵＯײθ#ＵＯθ Ｆ²⟲ＯＯ²⁴⁶θ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Ban đầu tôi đã thử một cách tiếp cận bitmap dễ thương:

Ｆ⁵Ｆ⁵Ｆ＆｜ικ¹«Ｊ×ιＩθ×κＩθＵＯθ#

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 thích: Hoạt động bằng cách xem xét #như một mảng các hình vuông 5 × 5. Các hình vuông nằm trong các hàng hoặc cột lẻ cần được điền vào.

J, 22 byte

#('# '{~#:5$21,0)#~"1]

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

Rất nhiều điểm tương đồng với câu trả lời J khác, mặc dù tôi không hiểu rõ về các chuyến tàu có nhiều danh từ, vì vậy câu trả lời của tôi có ba byte tiềm năng để cắt bỏ (hai parens và một phản xạ- ~).

Giải trình

Tạo octothorpe

Các octothorpe được thực hiện bởi tất cả mọi thứ trong ngoặc đơn, được sao chép dưới đây để thuận tiện.

'# '{~#:5$21,0

Rất nhiều cách tôi tạo ra octothorpe là lạm dụng cách J đệm các mảng của nó khi chúng không đủ dài.

21,0chỉ đơn giản là tạo ra các mảng 21 0.

5$định hình lại mảng đó thành mảng 5 nguyên tử : 21 0 21 0 21.

#:chuyển đổi mỗi nguyên tử thành một số nhị phân. Vì #:hoạt động trên mỗi nguyên tử, đầu ra là một ma trận. Mỗi cái 21được thay thế bằng 1 0 1 0 1như mong đợi, nhưng mỗi cái 0được thay thế bởi 0 0 0 0 0! Điều này là do các mảng đệm J không đủ dài để khớp với hình dạng của mảng 2D kết quả bị buộc là 5 5do các 1 0 1 0 1hàng. May mắn thay, với số lượng nó đệm 0, vì vậy chúng ta có được ma trận kết quả

1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1

'# '{~chuyển đổi từng 1đến một không gian và 0đến #. {có nghĩa là "lấy" và ~có nghĩa là "chuyển đổi các đối số dyadic, vì vậy J xem từng phần tử trong ma trận như các chỉ số cho chuỗi '# 'có nghĩa là mỗi 0phần tử trở thành phần tử zeroth #và mỗi 1phần tử trở thành phần tử đầu tiên, một khoảng trắng. Điều này mang lại kích thước một octothorpe.

Thay đổi kích thước octothorpe

Đây chỉ đơn giản là vấn đề sao chép nthời gian dọc theo mỗi trục, được thực hiện bằng cách sử dụng

đầu tiên #(là một phần của một cái móc) và #~"1]. #bản sao dọc trục ngang và #"1bản sao dọc trục dọc.

CJam, 27 26 25 byte

{_[{S3*'#*'#5*}3*;]fe*e*}

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

Sự thật thú vị: Điều này ban đầu bắt đầu ở 29 byte và byte đã được loại bỏ từng cái một kể từ đó, xen kẽ giữa chế độ khối và chương trình đầy đủ.

Giải trình:

{                          e# Stack:               | 2
 _                         e# Duplicate:           | 2 2
  [                        e# Begin array:         | 2 2 [
   {                       e# Do the following 3 times:
    S                      e#   Push a space       | 2 2 [" "
     3*                    e#   Repeat it 3 times: | 2 2 ["   "
       '#*                 e#   Join with '#':     | 2 2 [" # # "
          '#               e#   Push '#':          | 2 2 [" # # " '#
            5*             e#   Repeat it 5 times: | 2 2 [" # # " "#####"
              }3*          e# End:                 | 2 2 [" # # " "#####" " # # " "#####" " # # " "#####"
                 ;         e# Delete top of stack: | 2 2 [" # # " "#####" " # # " "#####" " # # "
                  ]        e# End array:           | 2 2 [" # # " "#####" " # # " "#####" " # # "]
                   fe*     e# Repeat characters:   | 2 ["  ##  ##  " "##########" "  ##  ##  " "##########" "  ##  ##  "]
                      e*   e# Repeat strings:      | ["  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  "]
                        }  e# End
e# Result:
e# ["  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "]

Husk , 12 10 byte

´Ṫ▲Ṙ" # # 

Hãy thử trực tuyến! Lưu ý không gian dấu.

Giải trình

´Ṫ▲Ṙ" # #   Implicit input, e.g. n=2.
   Ṙ" # #   Repeat each character of the string n times: "  ##  ##  "
´Ṫ          Outer product with itself by
  ▲         maximum: ["  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  "]
            Print implicitly, separated by newlines.

J , 23 19 byte

' #'{~1=]+./~@#i:@2

Đã lưu 4 byte nhờ @LeakyNun.

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

Giải trình

' #'{~1=]+./~@#i:@2  Input: integer n
                  2  The constant 2
               i:@   Range [-2, -1, 0, 1, 2]
        ]            Get n
              #      Copy each n times
         +./~@       GCD table
      1=             Equals 1, forms the hashtag for input 1
' #'{~               Index and select the char

Thạch , 14 13 11 byte

Đã lưu 2 byte nhờ @Jonathan ALLen

5ẋ€Ẏ&þ`ị⁾ #

Một liên kết đơn âm trả về một danh sách các dòng. Lưu ý không gian dấu.

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

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

5ẋ€Ẏ&þ`ị⁾ #    Main link. Arguments: n (integer)            1
5              Yield 5.
 ẋ€            Create a range and repeat each item n times. [[1], [2], [3], [4], [5]]
   Ẏ           Tighten; dump all sublists into the main list.
                                                            [1, 2, 3, 4, 5]
     þ         Create a table of                            [[1, 0, 1, 0, 1],
    &          bitwise ANDs,                                 [0, 2, 2, 0, 0],
      `        reusing this list.                            [1, 2, 3, 0, 1],
                                                             [0, 0, 0, 4, 4],
                                                             [1, 0, 1, 4, 5]]
       ị⁾ #    Index into the string " #".                   [" # # ",
               0 -> "#", 1 -> " ", 2 -> "#", etc.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

Ngôn ngữ nhà sản xuất trò chơi, 138 108 byte

n=argument0 s=''for(j=0;j<5*n;j+=1){for(l=0;l<5*n;l+=1)if(j div n|l div n)&1s+='#'else s+=' 's+='
'}return s

Dự định là một tập lệnh (tên của Game Maker cho các hàm do người dùng xác định), do đó, n=argument0và return s. 20 byte có thể được cạo bằng cách lấy ntrực tiếp từ thể hiện hiện tại và sử dụngs làm kết quả. (Ví dụ nhận được các biến này vì chúng không được khai báo var).

Tất nhiên coi chừng #được sử dụng bởi công cụ đồ họa của Game Maker như một nhân vật dòng mới thay thế, vì vậy bạn có thể muốn thêm tiền tố vào nó\ nếu bạn muốn xuất ra màn hình;)

Cũng lưu ý rằng tôi đang sử dụng phiên bản GML của Game Maker 8.0 tại đây; các phiên bản GML hiện đại có thể có các tính năng có thể lưu thêm byte.

Một số ý tưởng lịch sự của bạn bè wareya và hợp âm.

Perl 5 , 49 + 1 (-p) = 50 byte

$_=' # # 
'=~s/./$&x$_/gre x$_;$_.=(y/ /#/r.$_)x2

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

Làm sao?

Hoàn toàn lưu trữ đầu vào bằng $ _ thông qua -pcờ. Bắt đầu với dòng trên cùng cơ bản nhất có thể " # # "với dòng mới của nó. Sao chép từng ký tự đó bằng số đầu vào. Sau đó sao chép số đó bằng số đầu vào để tạo thành phần trên cùng của octothorpe, lưu trữ tất cả số đó trở lại bằng $ . Sau đó nối dòng với tất cả các ký tự được thay thế bằng '#' lần số đầu vào. Sau đó nối phần trên cùng. Làm hai câu cuối cùng tổng cộng hai lần. Đầu ra của $ được ẩn trong -pcờ.

05AB1E , 25 22 21 byte

•LQ•bûε×}5ôεS„# èJ¹F=

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

-1 vì Emigna ghét phiên âm và, may mắn thay, nhắc nhở tôi rằng tôi cũng nên: P.

Phải là một cách tốt hơn so với bitmap nó ... Vẫn hoạt động.

JavaScript (ES6), 79 byte

f=
n=>[...Array(n*5)].map((_,i,a)=>a.map((_,j)=>` #`[(i/n|j/n)&1]).join``).join`
`

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

Cổng của phương pháp bitmap mà tôi đã sử dụng cho nỗ lực Than ban đầu của mình.

Trăn 2 , 124 , 116 , 113 , 112 , 98 , 96 66 byte

Mới (Tín dụng: HyperNeutrino):

def f(a):i='print(" "*a+"#"*a)*2;'*a;exec(i+'print"#"*a*5;'*a)*2+i

Cũ:

a=input();b,c="# "
for i in"012":
	exec'print c*a+b*a+c*a+b*a;'*a
	if i<"2":exec'print b*a*5;'*a

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

Rõ ràng không phải là giải pháp ngắn nhất, nhưng tôi nghĩ nó là tốt. Bất kỳ thông tin phản hồi sẽ được đánh giá cao!

Brain-Flak , 338 332 byte

6 byte nhờ Riley.

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

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

Phiên bản "dễ đọc" hơn

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

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

SOGL (SOGLOnline cam kết 2940dbe) , 15 byte

ø─Ζ┘Χ⁴‘5n{.∙.*T

Để chạy cái này, tải cái này xuống và chạy mã trong index.htmltập tin.

Sử dụng tại cam kết đó (và trước đó) * lặp lại từng ký tự, không phải toàn bộ chuỗi.

Giải trình:

ø─Ζ┘Χ⁴‘          push " # # ##### # # ##### # # "
       5n        split into lines of length 5
         {       for each line do
          .∙       multiply vertically input times
            .*     multiply horizontally input times
              T    output in a new line

Phần thưởng: thêm 2 đầu vào cho chiều dài X và Y riêng biệt!

Brainfuck , 224 byte

,[->+>>>>+<<<<<]>>>+>+++++[-<<<[->+>>>>>+>+++++[-<<<[->+<<<[->>>>>>+<<[->>>+>---<<<<]<<<<]>>>>>>[-<<<<<<+>>>>>>]>[-<<<+>>>]+++++[->+++++++<]>.[-]<<<<<<]>[-<+>]>[-<->]<+[->+<]>>]<<++++++++++.[-]<<<<<]>[-<+>]>[-<->]<+[->+<]>>]

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

Tạo nên

Tôi đã cố gắng xây dựng mã này bằng tay và mất khá nhiều giờ, vì vậy tôi quyết định tạo một bộ chuyển mã bằng Python.

Đây là mã tôi đã nhập để tạo mã này:

read(0)
copy(0,(1,1),(5,1))
add(3,1)
add(4,5)
loop(4)
loop(1)
add(2,1)

add(7,1)
add(8,5)
loop(8)
loop(5)
add(6,1)

loop(3)
add(9,1)
loop(7)
add(10,1)
add(11,-3)
end(7)
end(3)
copy(9,(3,1))
copy(10,(7,1))
add(10,5)
copy(10,(11,7))
write(11)
clear(11)

end(5)
copy(6,(5,1))
copy(7,(6,-1))
add(6,1)
copy(6,(7,1))
end(8)
add(6,10)
write(6)
clear(6)

end(1)
copy(2,(1,1))
copy(3,(2,-1))
add(2,1)
copy(2,(3,1))
end(4)

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

C (gcc) , 98 93 byte

5 byte nhờ có Felix Palmen.

i,j;main(a){for(scanf("%d",&a);j<a*5||(j=!puts(""),++i<a*5);)putchar(i/a+1&j++/a+1&1?32:35);}

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

Gaia , 9 byte

 # ”ṫ&:Ṁ‡

Khá nhiều câu trả lời tuyệt vời của Zgarb

Hãy thử trực tuyến!(chân trang chỉ để in đẹp, chương trình tự trả về danh sách các ký tự 2D)

Giải trình

 # ”       Push the string " # "
    ṫ      Bounce, giving " # # "
     &     Repeat each character by input
      :    Copy
       Ṁ‡  Tabled maximum with itself

Befunge , 105 103 byte

p9p&5*08p>08g-   v
>,g1+:00p^v0:/5g8_p9g1+:09p08g-#v_@
gvg90\/\g0< # # ##### 0:/5g8,+55<
^>\/2%5*+92++2

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

Python, 88 84 77 byte

lambda x:[[(' #'[i//x%2]+'#')[j//x%2]for j in range(5*x)]for i in range(5*x)]

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

Trả về danh sách 2D của các ký tự.

PowerShell , 72 68 63 60 byte

param($a)(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x

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

Đưa đầu vào $a. Sau đó, chúng tôi thực hiện một loạt các phép thuật chuỗi và thao tác mảng.

(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x
         ' '*$a+"#"*$a                              # Construct a string of spaces and #
        (             )*2                           # Repeat it twice
      ,(                 )*$a                       # Repeat that $a times to get the top as an array
  ($x=                       )                      # Store that into $x and immediately output it
 ,                            +                     # Array concatenate that with ...
                               ,("#"*5*$a)          # another string, the middle bar ...
                                          *$a       # repeated $a times.
(                                            )*2;   # Do that twice
                                                 $x # Output $x again

Bạn có thể bóc ra các phần của lời giải thích bắt đầu từ phía dưới để xem đầu ra được xây dựng như thế nào, vì vậy hy vọng lời giải thích của tôi có ý nghĩa.

Haskell, 72 byte

a#b=a++b++a++b++a
c%l=((c<$l)#('#'<$l))<$l
f n=(' '%[1..n])#('#'%[1..n])

Trả về một danh sách các chuỗi. Hãy thử trực tuyến!

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

a#b=a++b++a++b++a          -- concatenate the strings a and b in the given pattern
c%l=                       -- take a char c and a list l (we only use the length
                           -- of l, the actual content doesn't matter)
    c<$l                   -- make length l copies of c
         '#'<$l            -- make length l copies of '#'
        #                  -- combine them via function #
               <$l         -- and make length l copies of that string
f n=                       -- main function
              #            -- make the "a b a b a" pattern with the strings
                           -- returned by the calls to function %                                
    ' '%[1..n]             --   one time with a space 
               '#'%[1..n]  --   one time with a '#'

Toán học, 63 byte

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&

Giải trình

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&  (* input N *)

                   x=#                                           (* Set x to N *)
                                                      &          (* A function that takes two inputs: *)
                             If[OddQ@-##," ","#"]                (* if both inputs are odd (1), " ". "#" otherwise *)
                       Table[                    ,x,x]           (* Make N x N array of that string *)
             Array[                                     ,{5,5}]  (* Make a 5 x 5 array, applying that function to each index *)
ArrayFlatten@                                                    (* Flatten into 2D array *)

_{(1) -##phân tích thànhTimes[-1, ##]}

Python 2, 113 byte

Là một chuỗi các chuỗi:

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
print[''.join(' #'[r[k]+r[j]>0]for k in range(len(r)))for j in range(n*5)]

Như nghệ thuật ASCII:

Python 3, 115 byte

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
for j in range(n*5):print(*(' #'[r[k]+r[j]>0]for k in range(len(r))),sep='')

Python 3, 117 byte

p=range(5*n)
for i,e in enumerate([j%(2*n)>=n for j in p]for k in p):print(*[' #'[i%(2*n)>=n or k]for k in e],sep='')

Là một mảng của booleans

p=range(5*n)
f=lambda o:o%(2*n)>=n
print[[f(j)or f(i)for j in p]for i in p]

Java 8, 103 byte

Lambda chấp nhận Integervà in octothorpe theo tiêu chuẩn. Đúc để Consumer<Integer>.

n->{for(int s=5*n,x=0,y;x<s;x++)for(y=0;y<s;)System.out.print((x/n%2+y++/n%2>0?'#':32)+(y<s?"":"\n"));}

Dùng thử trực tuyến

Lambda

n -> {
    for (
        int
            s = 5 * n,
            x = 0,
            y
        ;
        x < s;
        x++
    )
        for (y = 0; y < s; )
            System.out.print(
                (x / n % 2 + y++ / n % 2 > 0 ? '#' : 32)
                + (y < s ? "" : "\n")
            );
}

Quan sát chính ở đây là, trên một lưới 5 x 5 của n bởi n tế bào, octothorpes xuất hiện bất cứ nơi nào hàng hoặc cột số (dựa trên 0) là số lẻ. Tôi khá chắc chắn rằng đây là cách tiếp cận chung rẻ nhất, nhưng có vẻ như chơi gôn hơn.

Lời cảm ơn

• -1 byte nhờ Kevin Cruijssen

Bình thường , 28 22 byte

-6 byte nhờ @LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

Phòng thử nghiệm.

R , 87 85 62 byte

m=matrix(" ",x<-scan()*5,x);m[s,]=m[,s<-rep(!1:0,e=x/5)]="#";m

2 byte được lưu bằng cách biểu thị c (F, T) là! 1: 0, nhờ LeakyNun

23 byte được lưu nhờ Giuseppe

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

Giải thích (vô danh):

x=scan()*5              # Multiply input by 5 to get the required width/height of the matrix
m=matrix(" ",x,x)       # Create a matrix of the required dimensions
s=rep(!1:0,each=x/5)    # The sequence s consists of F repeated n times, followed by T repeated n times
m[s,]="#"               # Use s as logical indices to set those rows as "#" characters.
                        # R recycles the sequence to the height of the matrix.
m[,s]="#"               # Same, with columns
write(m,"",x,,"")       # Print out across the required number of columns