Octothorpe (เรียกว่าสัญญาณจำนวนกัญชาหรือแฮชแท็กหรือเครื่องหมายปอนด์)เป็นอักขระ ASCII ต่อไปนี้:

#

นั่นไม่ใช่เรื่องสนุกหรอกเหรอ? ช่วยสร้างเวอร์ชั่นที่ใหญ่กว่า! นี่คือความท้าทายของคุณ:

กำหนดจำนวนเต็มบวกN , เอาท์พุท hashtag ASCII ขนาดN

ตัวอย่างเช่นแฮชแท็ก ASCII ขนาด1มีลักษณะดังนี้:

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

อนุญาตให้ใช้ช่องว่างต่อท้ายในแต่ละบรรทัดได้ แต่ไม่จำเป็น

อินพุตจะเป็นจำนวนเต็มบวกที่ถูกต้องเสมอดังนั้นคุณไม่จำเป็นต้องจัดการกับตัวเลขที่ไม่ใช่เชิงลบหรือ 0 เอาต์พุตของคุณอาจอยู่ในรูปแบบที่เหมาะสมดังนั้นจึงส่งออกไปยัง STDOUT ส่งคืนรายการสตริงหรือสตริงด้วย การขึ้นบรรทัดใหม่, เมทริกซ์ 2 มิติของตัวอักษร, การเขียนไปยังไฟล์, ฯลฯ นั้นใช้ได้

กรณีทดสอบ

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

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

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

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

ตั้งแต่นี้เป็นรหัสกอล์ฟลองเขียนทางออกที่สั้นที่สุดเท่าที่จะทำได้และเหนือสิ่งอื่นใดขอให้สนุก

MATL , 20 16 12 11 ไบต์

3 ไบต์ขอบคุณ DJMcMayhem

ขอบคุณ 1 ไบต์สำหรับ Luis Mendo

21BwY"&*~Zc

ลองออนไลน์!

คำอธิบาย

    % 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 ไบต์

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

ลองออนไลน์!

ไม่ได้คะแนน 420 ไม่ได้ตั้งใจ ฉันสัญญา. รุ่นที่อ่านได้:

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

>[()])}

รหัสเครื่อง 6502 (C64), 59 56 ไบต์

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

การสาธิตออนไลน์

การใช้งาน: SYS49152,Nโดยที่ N คือตัวเลขระหว่าง 1 ถึง 255

_{(ค่าที่มากกว่า 4 จะใหญ่เกินไปสำหรับหน้าจอ C64 โดยเริ่มต้นจาก 8 เอาต์พุตจะกว้างเกินไป)}

คำอธิบาย :

         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 ไบต์

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

ลองออนไลน์!

ส่งออกรายการของสตริง

Python 2 , 55 ไบต์

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

ลองออนไลน์!

ส่งคืนรายการอักขระ 2 มิติ

Python 2 , 65 ไบต์

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

ลองออนไลน์!

Python 2 , 66 ไบต์

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

ลองออนไลน์!

ถ่าน 21 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ฉันเคยลองวิธีบิตแมปที่น่ารัก:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย: ทำงานโดยพิจารณา#อาร์เรย์เป็นขนาด 5 × 5 กำลังสอง สี่เหลี่ยมที่อยู่ในแถวคี่หรือคอลัมน์จะต้องกรอก

J, 22 ไบต์

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

ลองออนไลน์!

ความคล้ายคลึงกันมากกับคำตอบ J อื่น ๆ แต่ฉันไม่เข้าใจคำศัพท์ที่มีคำนามมากมายดังนั้นคำตอบของฉันมีสามไบต์ที่เป็นไปได้ที่จะตัด (สอง parens และ reflexive- ~)

คำอธิบาย

การสร้าง octothorpe

Octothorpe ผลิตโดยทุกอย่างในแบบที่คัดลอกด้านล่างเพื่อความสะดวก

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

หลายวิธีที่ฉันสร้าง octothorpe นั้นเป็นการละเมิดวิธีที่ J วางแผงอาร์เรย์ไว้เมื่อไม่นานพอ

21,021 0เพียงแค่สร้างอาร์เรย์

5$reshapes อาร์เรย์ที่เป็นอาร์เรย์ที่ 5 21 0 21 0 21อะตอม:

#:แปลงแต่ละอะตอมเป็นเลขฐานสอง เนื่องจาก#:ทำงานกับแต่ละอะตอมเอาต์พุตจึงเป็นเมทริกซ์ แต่ละอัน21ถูกแทนที่ด้วย1 0 1 0 1อย่างที่คาดไว้ แต่0ถูกแทนที่ด้วย0 0 0 0 0! นี่เป็นเพราะว่าแผ่นอิเล็กโทรด J นั้นมีความยาวไม่เพียงพอที่จะจับคู่กับรูปร่างของอาเรย์ 2D ที่เกิดขึ้นซึ่งถูกบังคับให้เป็น5 5เพราะ1 0 1 0 1แถว โชคดีที่ตัวเลขนั้นมีอยู่ด้วย0ดังนั้นเราจึงได้เมทริกซ์ที่ได้มา

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

'# '{~แปลงแต่ละ1พื้นที่และการ0 หมายถึง "ใช้" และหมายถึง "สลับอาร์กิวเมนต์ dyadic ดังนั้น J ดูแต่ละองค์ประกอบในเมทริกซ์เป็นดัชนีสำหรับสตริงหมายถึงแต่ละกลายเป็นองค์ประกอบซีโรทและแต่ละกลายเป็นองค์ประกอบแรกที่ว่างนี้ขนาดหนึ่ง octothorpe#{~'# '0#1

การปรับขนาด octothorpe

นี่เป็นเพียงเรื่องของการคัดลอกnเวลาตามแต่ละแกนโดยใช้

ครั้งแรก#(ซึ่งเป็นส่วนหนึ่งของเบ็ด) #~"1]และ #คัดลอกไปตามแกนนอนและ#"1คัดลอกไปตามแกนตั้ง

CJam, 27 26 25 bytes

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

ลองออนไลน์!

ความจริงแล้วสนุก: สิ่งนี้เริ่มต้นที่ 29 ไบต์และไบต์ถูกลบทีละตัวนับตั้งแต่สลับระหว่างโหมดบล็อกและโหมดเต็มโปรแกรม

คำอธิบาย:

{                          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#  "  ##  ##  "]

แกลบ , 12 10 ไบต์

´Ṫ▲Ṙ" # # 

ลองออนไลน์! สังเกตพื้นที่ต่อท้าย

คำอธิบาย

´Ṫ▲Ṙ" # #   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 ไบต์

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

บันทึกแล้ว 4 ไบต์ขอบคุณ @LeakyNun

ลองออนไลน์!

คำอธิบาย

' #'{~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

เยลลี่ , 14 13 11 ไบต์

บันทึก 2 ไบต์ขอบคุณ @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

ลิงก์ monadic ส่งคืนรายการของบรรทัด สังเกตพื้นที่ต่อท้าย

ลองออนไลน์!

มันทำงานอย่างไร

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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

ภาษาของผู้สร้างเกม, 138 108 ไบต์

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

ตั้งใจจะให้เป็น (ชื่อชงเกมสำหรับฟังก์ชั่นที่ผู้ใช้กำหนด) สคริปต์จึงและn=argument0 return s20 ไบต์สามารถโกนได้โดยการดึงnโดยตรงจากอินสแตนซ์ปัจจุบันและใช้sเป็นผลลัพธ์ (อินสแตนซ์รับตัวแปรเหล่านี้อยู่แล้วเพราะไม่ได้ประกาศไว้var)

ระวังของ#กราฟิกที่ใช้โดยสิ่งกราฟิกของ Game Maker เป็นอักขระบรรทัดใหม่ทางเลือกดังนั้นคุณอาจต้องการนำหน้าด้วย\หากคุณต้องการส่งออกไปยังหน้าจอ;)

โปรดทราบด้วยว่าฉันใช้ GML เวอร์ชัน Game Maker 8.0 ที่นี่; เวอร์ชัน GML ที่ทันสมัยอาจมีคุณสมบัติที่สามารถบันทึกไบต์เพิ่มเติมได้

ความคิดบางอย่างได้รับความอนุเคราะห์จากเพื่อน wareya และ chordbug

Perl 5 , 49 + 1 (-p) = 50 ไบต์

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

ลองออนไลน์!

อย่างไร?

เก็บอินพุตโดยปริยายใน $ _ ผ่าน-pแฟล็ก เริ่มต้นด้วยบรรทัดบนสุดที่เป็นไปได้พื้นฐานที่สุด" # # "ด้วยการขึ้นบรรทัดใหม่ ทำซ้ำแต่ละอักขระเหล่านั้นด้วยหมายเลขอินพุต จากนั้นทำซ้ำว่าจากจำนวนการป้อนข้อมูลในรูปแบบส่วนบนของ octothorpe จัดเก็บทั้งหมดของกลับมาอยู่ในที่ $ จากนั้นจึงต่อท้ายบรรทัดด้วยอักขระทั้งหมดที่แทนที่ด้วย '#' คูณด้วยหมายเลขอินพุต จากนั้นผนวกส่วนบนสุด ทำสองประโยคสุดท้ายเหล่านั้นทั้งหมดสองครั้ง เอาท์พุทของ $เป็นนัยใน-pธง

05AB1E , 25 22 21 ไบต์

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

ลองออนไลน์!

-1 เนื่องจาก Emigna เกลียดนักแปลและขอบคุณฉันเตือนฉันด้วย: P.

ต้องเป็นวิธีที่ดีกว่าการแมปบิตแมป ... ยังทำงานอยู่

JavaScript (ES6), 79 ไบต์

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>

พอร์ตของวิธีบิตแมปที่ฉันใช้สำหรับความพยายามแบบ Charcoal ดั้งเดิมของฉัน

Python 2 , 124 , 116 , 113 , 112 , 98 , 96 66 ไบต์

ใหม่ (เครดิต: HyperNeutrino):

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

เก่า:

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

ลองออนไลน์!

เห็นได้ชัดว่าไม่ใช่ทางออกที่สั้นที่สุด แต่ฉันคิดว่ามันดี ข้อเสนอแนะใด ๆ ที่จะได้รับการชื่นชม!

Brain-Flak , 338 332 ไบต์

6 ไบต์ขอบคุณ Riley

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

ลองออนไลน์!

รุ่น "อ่านได้" เพิ่มเติม

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

ลองออนไลน์!

SOGL (SOGLOnline ส่ง 2940dbe) , 15 ไบต์

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

ทำงานนี้ให้ดาวน์โหลดนี้และเรียกใช้รหัสในindex.htmlไฟล์

ใช้ว่าเมื่อกระทำ (และก่อนหน้านั้น) *ทำซ้ำแต่ละอักขระไม่ใช่ทั้งสตริง

คำอธิบาย:

ø─Ζ┘Χ⁴‘          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

โบนัส: เพิ่ม 2 อินพุตสำหรับความยาว X และ Y แยก!

brainfuck , 224 ไบต์

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

ลองออนไลน์!

ทำของ

ฉันพยายามสร้างรหัสนี้ด้วยมือและใช้เวลาไม่กี่ชั่วโมงดังนั้นฉันจึงตัดสินใจทำ transpiler ใน Python

นี่คือรหัสที่ฉันป้อนเพื่อสร้างรหัสนี้:

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)

ลองออนไลน์!

C (gcc) , 98 93 ไบต์

5 ไบต์ขอบคุณ 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);}

ลองออนไลน์!

Gaiaขนาด 9 ไบต์

 # ”ṫ&:Ṁ‡

ค่อนข้างพอร์ตของคำตอบที่ดีของ Zgarb

ลองออนไลน์! (ส่วนท้ายเป็นเพียงการพิมพ์สวยโปรแกรมตัวเองกลับรายการของตัวละคร 2D)

คำอธิบาย

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

Befunge , 105 103 ไบต์

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

ลองออนไลน์!

Python, 88 84 77 ไบต์

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

ลองออนไลน์!

ส่งคืนรายการอักขระ 2 มิติ

PowerShell , 72 68 63 60 ไบต์

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

ลองออนไลน์!

$aจะเข้า จากนั้นเราก็ทำสตริงมายากลและการจัดการอาร์เรย์

(,($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

คุณสามารถลอกส่วนต่าง ๆ ของคำอธิบายที่เริ่มต้นจากด้านล่างเพื่อดูวิธีการสร้างผลลัพธ์ดังนั้นหวังว่าคำอธิบายของฉันจะสมเหตุสมผล

Haskell, 72 ไบต์

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

ส่งคืนรายการของสตริง ลองออนไลน์!

มันทำงานอย่างไร:

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

Mathematica, 63 ไบต์

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

คำอธิบาย

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) -##แยกวิเคราะห์Times[-1, ##]}

Python 2, 113 ไบต์

เป็นอาร์เรย์ของสตริง:

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

ในฐานะที่เป็นศิลปะ ASCII:

Python 3, 115 ไบต์

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 ไบต์

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='')

ในฐานะที่เป็นอาร์เรย์ของบูลีน

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 ไบต์

แลมบ์ดายอมรับIntegerและพิมพ์ octothorpe ให้เป็นมาตรฐาน 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"));}

ลองใช้ออนไลน์

แลมบ์ดา

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

การสังเกตที่สำคัญที่นี่คือบนตาราง 5 โดย 5 ของnโดยnเซลล์ octothorpes จะปรากฏขึ้นทุกที่ที่หมายเลขแถวหรือคอลัมน์ (ตาม 0) เป็นเลขคี่ ฉันค่อนข้างแน่ใจว่านี่เป็นวิธีการทั่วไปที่ถูกที่สุด แต่ดูเหมือนว่าจะสามารถเล่นกอล์ฟได้ต่อไป

กิตติกรรมประกาศ

• -1 ไบต์ต้องขอบคุณKevin Cruijssen

Pyth , 28 22 ไบต์

-6 ไบต์ขอบคุณ@LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

ชุดทดสอบ

R , 87 85 62 ไบต์

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

บันทึก 2 ไบต์โดยใช้แทน c (F, T) เป็น! 1: 0 ขอบคุณ LeakyNun

บันทึก 23 ไบต์ด้วย Giuseppe

ลองออนไลน์!

คำอธิบาย (ungolfed):

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