#OctothorpeAsciiArt


35

Sebuah octothorpe, (juga disebut tanda nomor, hash atau hashtag, atau tanda pound) adalah karakter ASCII berikut:

#

Bukankah itu bentuk yang menyenangkan? Mari kita buat versi yang lebih besar! Jadi inilah tantangan Anda:

Mengingat positif bilangan bulat N , keluaran sebuah hashtag ASCII ukuran N .

Misalnya, tagar ASCII ukuran 1 terlihat seperti ini:

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

Trailing whitespace pada setiap baris diperbolehkan, tetapi tidak diperlukan.

Input akan selalu berupa bilangan bulat positif yang valid, sehingga Anda tidak harus menangani non-angka, negatif, atau 0. Output Anda dapat dalam format yang masuk akal, jadi mengeluarkan ke STDOUT, mengembalikan daftar string, atau string dengan baris baru, matriks 2D karakter, menulis ke file, dll. semuanya baik-baik saja.

Uji kasus

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

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

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

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

Karena ini adalah kode-golf, cobalah menulis solusi sesingkat mungkin yang Anda bisa, dan yang terpenting, bersenang-senang!


Jawaban:


21

MATL , 20 16 12 11 byte

3 byte berkat DJMcMayhem.

Terima kasih 1 byte untuk Luis Mendo.

21BwY"&*~Zc

Cobalah online!

Penjelasan

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

1
Anda dapat menggunakan Zcsebagai gantinya 35*cdan ~(TIDAK logis) alih-alih0=
DJMcMayhem

1
@DJMcMayhem @ _ @ mengapa itu built-in
Leaky Nun

1
Sebenarnya, alasan itu adalah builtin sangat menarik. Saya bisa saja salah, tetapi saya pikir Conor menyarankannya, dan Suever menulis sebuah skrip yang melihat semua jawaban MATL untuk melihat fungsi apa yang lebih umum untuk perbaikan di masa depan. Zc baru saja ditambahkan
DJMcMayhem

Juga, karena masing-masing sel harus bukan nol, Anda dapat melakukan Qalih - alih2<
DJMcMayhem

1
@ LeakyNun Anda dapat mengubah !t*ke &*. Yang terakhir berarti "perkalian satu-input", yang mengalikan (unsur-bijaksana) input dengan transposnya
Luis Mendo

14

Brain-Flak , 420 byte

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

Cobalah online!

Tidak, skor 420 tidak disengaja. Saya berjanji. Versi yang dapat dibaca:

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

>[()])}

13

6502 kode mesin (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

Demo online

Penggunaan: dengan SYS49152,NN adalah angka antara 1 dan 255.

(nilai lebih besar dari 4 sudah akan terlalu besar untuk layar C64, mulai dari 8, hasilnya bahkan terlalu lebar)

Penjelasan :

         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)

Tangkapan layar


5
+1 untuk nostalgia (6502 perakitan pada c64 adalah pengalaman pemrograman pertama saya ...)
Olivier Dulac


8

Python 2 , 55 byte

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

Cobalah online!

Ini mengembalikan daftar karakter 2D.

Python 2 , 65 byte

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

Cobalah online!

Python 2 , 66 byte

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

Cobalah online!


Witchkraft adalah catatan kaki Anda
Leaky Nun

@ LeakyNun A for loop :)
Mr. Xcoder

Tidak, saya sedang berbicara tentang f(i);menyimpan hasilnya dalam temp sementara dan printmengaksesnya.
Leaky Nun

1
@LeakyNun Ya disalahpahami: f(i)cetakan dan printdalam Python 2 menambahkan baris baru: P
Mr. Xcoder

Oh, betapa bodohnya aku.
Leaky Nun

6

Arang , 21 byte

NθUOײθ#UOθ F²⟲OO²⁴⁶θ

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Saya awalnya mencoba pendekatan bitmap yang lucu:

F⁵F⁵F&|ικ¹«J×ιIθ×κIθUOθ#

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: Bekerja dengan mempertimbangkan #sebagai array 5 × 5 kotak. Kotak yang berada di baris atau kolom ganjil perlu diisi.


apakah arang benar-benar tidak memiliki bentuk tanda pagar?
dzaima

Apakah saya mengikat arang O_O?
Magic Gurita Guci

yay (hmm sepertinya saya harus memperbaikinya sedikit)
ASCII-only

@ Khusus ASCII Apa yang perlu diperbaiki?
Neil

Oblong tidak boleh mencetak langkah-langkah untuk poligon yang digunakan secara internal lol
ASCII-only

6

J, 22 byte

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

Cobalah online!

Banyak kemiripan dengan jawaban J yang lain, meskipun saya tidak mengerti kereta dengan banyak kata benda, jadi jawaban saya memiliki tiga byte potensial untuk dipotong (dua paren dan refleksif- ~).

Penjelasan

Menghasilkan octothorpe

Octothorpe dibuat oleh segala sesuatu dalam tanda kurung, direproduksi di bawah ini untuk kenyamanan.

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

Banyak cara saya membuat octothorpe menyalahgunakan cara yang dipakai J array ketika mereka tidak cukup lama.

21,0cukup menciptakan array 21 0.

5$membentuk ulang bahwa array ke array 5-atom: 21 0 21 0 21.

#:mengubah setiap atom menjadi angka biner. Karena #:beroperasi pada setiap atom, outputnya adalah sebuah matriks. Masing 21- masing digantikan oleh 1 0 1 0 1seperti yang diharapkan, tetapi masing 0- masing digantikan oleh 0 0 0 0 0! Ini karena J pads array tidak cukup panjang untuk mencocokkan bentuk 2D array yang dihasilkan yang terpaksa 5 5karena 1 0 1 0 1baris. Untungnya, untuk angka-angka itu cocok dengan 0, jadi kami mendapatkan matriks yang dihasilkan

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

'# '{~mengkonversi masing 1- masing ke spasi dan 0ke #. {berarti "mengambil" dan ~berarti "mengganti argumen diad, jadi J melihat ke setiap elemen dalam matriks sebagai indeks untuk string yang '# 'berarti masing-masing 0menjadi elemen nol, #dan masing-masing 1menjadi elemen pertama, spasi. Ini menghasilkan ukuran satu octothorpe.

Mengubah ukuran octothorpe

Ini hanyalah masalah nwaktu menyalin sepanjang setiap sumbu, selesai menggunakan

yang pertama #(yang merupakan bagian dari kail) dan #~"1]. #salinan di sepanjang sumbu horizontal dan #"1salinan di sepanjang sumbu vertikal.


1
##"1&('# '{~#:5$21,0)menghemat satu byte.
Zgarb

6

CJam, 27 26 25 byte

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

Cobalah online!

Fakta menyenangkan: Ini awalnya dimulai pada 29 byte, dan byte telah dihapus satu per satu sejak itu, bergantian antara mode blok dan program penuh.

Penjelasan:

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

Seseorang disiapkan untuk tantangan ini: P
ETHproduksi

@ETHproductions Itu adalah CMC dan pindah ke main ...
Esolanging Fruit

@ ETHproductions Tidak bisa menyalahkannya untuk itu ...
Leaky Nun

6

Sekam , 12 10 byte

´Ṫ▲Ṙ" # # 

Cobalah online! Perhatikan ruang trailing.

Penjelasan

´Ṫ▲Ṙ" # #   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.

6

J , 23 19 byte

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

Disimpan 4 byte berkat @LeakyNun.

Cobalah online!

Penjelasan

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

Tikus! Baru saja akan memposting solusi (4 byte lebih lama) saya sendiri. Saya benar-benar terkesan dengan bagaimana Anda dapat menyusun fungsi-fungsi ini tanpa tutup dan dengan beberapa konjungsi.
cole

@cole Terima kasih. Terkadang topi bisa dihindari dengan menggunakan kata benda dan angka dua. Misalnya, [:|:fbisa0|:f
mil

' # '{~]#"1]#+./~@i:@2menghemat satu byte
Conor O'Brien

ulangi sebelum perkalian memberi Anda 19 byte:f=:' #'{~1=]+./~@#i:@2
Leaky Nun

1
@hoosierEE Ini adalah fitur baru yang datang dalam J 8.06. Anda dapat mencoba beta jsoftware.com/download/j806/install
miles

5

Jelly , 14 13 11 byte

Disimpan 2 byte berkat @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

Tautan monadik mengembalikan daftar garis. Perhatikan ruang trailing.

Cobalah online!

Bagaimana itu bekerja

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

Pengamatan yang bagus tentang bitwise atau - simpan dua byte dengan beralih dari atau ke dan - menghapus kebutuhan untuk menurunkan, memungkinkan rentang implisit dan menghapus kebutuhan untuk µ(atau Anda bisa memiliki di sana sebagai gantinya) ...5ẋ€Ẏ&þ`ị⁾ #
Jonathan Allan

@ Jonathan Allan Menarik - mengapa 5Ḷẋ€harus µ, tetapi tidak 5ẋ€?
ETHproduksi

Saya pikir kebutuhan itu hanya untuk berhenti bertindak ndan kemudian menyerahkannya ke kanan ẋ€, karena dengan rantai terkemuka angka dua-angka yang disebut monadically itu tidak perlu. Saya tidak begitu yakin, bagaimana `bisa menempatkan 5 (atau mungkin daftar panjang itu) di sebelah kanan tabel &.
Jonathan Allan

4

Bahasa Game Maker, 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

Dimaksudkan sebagai skrip (nama Pembuat Game untuk fungsi yang ditentukan pengguna), dengan demikian n=argument0dan return s. 20 byte dapat dicukur dengan mengambil nlangsung dari instance saat ini dan menggunakan shasilnya. (Contohnya mendapatkan variabel-variabel ini karena mereka tidak dideklarasikan dengan var).

Waspadalah tentu saja yang #digunakan oleh hal-hal grafis Game Maker sebagai karakter baris baru alternatif, jadi Anda mungkin ingin awalan dengan \jika Anda ingin menampilkan ke layar;)

Perhatikan juga bahwa saya menggunakan GML versi Game Maker 8.0 di sini; versi GML modern mungkin memiliki fitur yang dapat menghemat byte tambahan.

Beberapa ide milik teman wareya dan chordbug.


Saya pikir ini adalah jawaban GML pertama yang pernah saya lihat
Timothy Groote

@TimothyGroote Sayang sekali tidak digunakan lagi, tanda kurung opsional dan titik komanya bagus untuk bermain golf :)
Andrea

4

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

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

Cobalah online!

Bagaimana?

Secara implisit menyimpan input dalam $ _ melalui -pflag. Mulailah dengan garis paling atas yang mungkin paling mendasar " # # "dengan garis belakangnya yang baru. Gandakan setiap karakter tersebut dengan nomor input. Kemudian ulangi dengan nomor input untuk membentuk bagian atas octothorpe, simpan semua itu kembali dalam $ . Kemudian tambahkan baris dengan semua karakter diganti dengan '#' kali jumlah input. Kemudian tambahkan bagian atas. Lakukan dua kalimat terakhir total dua kali. Output $ adalah tersirat dalam -pflag.


Saya suka bagaimana jawaban Anda sama mudahnya dengan jawaban saya.
AdmBorkBork

Mereka selalu mengatakan bahwa Perl adalah bahasa tulis-saja.
Xcali

3

05AB1E , 25 22 21 byte

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

Cobalah online!


-1 karena Emigna membenci transliterate dan, untungnya, mengingatkan saya bahwa saya juga harus: P.


Harus menjadi cara yang lebih baik daripada menggigitnya ... Masih berfungsi.


Refleksi ... bukanlah jawaban di 05AB1E, meskipun sepertinya itu mungkin ...
Magic Octopus Mm

5ôεS„# èJ¹F=menghemat satu byte.
Emigna

@ Emigna akan kanvas baik untuk ini?
Magic Gurita Guci

Mungkin. Saya belum mencoba kanvas, jadi saya tidak begitu yakin dengan kemampuannya. Sepertinya ini dibuat untuk sesuatu.
Emigna

3

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>

Port pendekatan bitmap yang saya gunakan untuk upaya Charcoal asli saya.


3

Python 2 , 124 , 116 , 113 , 112 , 98 , 96 66 byte

Baru (Kredit: HyperNeutrino):

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

Tua:

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

Cobalah online!

Jelas bukan solusi terpendek, tapi saya pikir itu layak. Umpan balik apa pun akan dihargai!


1
a,b,c=input()," #"harus menyimpan beberapa byte.
DJMcMayhem

@DJMcMayhem Itu memberi saya kesalahan. Apakah maksud Anda a,b,c=input(),"#"," "? Yang tidak lebih pendek ... Saya menghargai bantuannya!
Braeden Smith

Oh maaf. Saya berasumsi itu berhasil karena a,b="# "berhasil.
DJMcMayhem

a=input();b,c="# "akan bekerja dan menyimpan byte
Wheat Wizard

Anda juga dapat menyingkirkan parens (i==2)dan menambahkan spasi di awal.
Wheat Wizard

3

Brain-Flak , 338 332 byte

6 byte terima kasih kepada Riley.

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

Cobalah online!

Lebih banyak versi "dapat dibaca"

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

Cobalah online!


(({})<>)(())<>({}<>)di awal bisa diganti dengan(({}<>)<(())>)
Riley

2

SOGL (SOGLOnline commit 2940dbe) , 15 byte

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

Untuk menjalankan ini, unduh ini dan jalankan kode dalam index.htmlfile.

Menggunakan bahwa pada saat itu komit (dan sebelum itu) *mengulangi setiap karakter, bukan seluruh string.

Penjelasan:

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

Bonus: tambahkan 2 input untuk panjang X dan Y yang terpisah!


"commit 2940dbe" - Saya suka gagasan itu. Bisakah Anda menjelaskan mengapa ø─Ζ┘Χ⁴‘mendorong itu?
Magic Gurita Guci

1
@MagicOctopusUrn Itulah kompresi SOGL, yang di sini menyimpan kamus "" dan #dan data dasar-2 yang diperlukan untuk string itu.
dzaima

Rapi , apakah cukup stabil bagi saya untuk mulai menggunakan :)?
Magic Octopus Mm

1
@MagicOctopusUrn Yah itu cukup stabil karena tidak ada perubahan jawaban sejak SOGLOnline, tetapi apakah Anda dapat menggunakannya (seperti dalam memahaminya) adalah pertanyaan lain. Anda dapat mencoba dan mengajukan pertanyaan di TNB
dzaima

Haha ... Saya akan menunggu dokumentasi lalu. Saya perlu sedikit dimanjakan.
Magic Gurita Guci

2

brainfuck , 224 byte

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

Cobalah online!

Pembuatan

Saya mencoba membuat kode ini dengan tangan dan menghabiskan beberapa jam, jadi saya memutuskan untuk membuat transpiler dengan Python.

Berikut adalah kode yang saya masukkan untuk membuat kode ini:

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)

Cobalah online!





1

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

Cobalah online!

Mengembalikan daftar karakter 2D.


1

PowerShell , 72 68 63 60 byte

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

Cobalah online!

Mengambil input $a. Kemudian, kami melakukan banyak string sihir dan manipulasi array.

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

Anda dapat mengupas bagian-bagian dari penjelasan mulai dari bawah untuk melihat bagaimana output dibangun, jadi semoga penjelasan saya masuk akal.


1

Haskell, 72 byte

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

Mengembalikan daftar string. Cobalah online!

Bagaimana itu bekerja:

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

1

Mathematica, 63 byte

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

Penjelasan

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) -##mem-parsing keTimes[-1, ##]


ArrayFlattensangat baik.
Mark S.

1

Python 2, 113 byte

Sebagai array string:

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

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

Sebagai array booleans

Python 2, 75 byte

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]


1
Lama tidak bertemu :-)
ETHproduksi

Ya, sudah! @ETHproductions
Zach Gates

1

Java 8, 103 byte

Lambda menerima Integerdan mencetak octothorpe dengan standar keluar. Diputar ke 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"));}

Cobalah secara Online

Lambda yang tidak tersentuh

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

Pengamatan kunci di sini adalah bahwa, pada 5 oleh 5 grid n oleh n sel, octothorpes muncul di mana pun baris atau kolom nomor (0-based) aneh. Saya cukup yakin ini adalah pendekatan umum termurah, tetapi tampaknya golf lebih lanjut.

Ucapan Terima Kasih

  • -1 byte terima kasih kepada Kevin Cruijssen

1
Anda dapat menempatkan int s=5*n,x=0,yfor-loop sebagai gantinya untuk menyimpan byte pada titik koma.
Kevin Cruijssen


1

R , 87 85 62 byte

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

2 byte disimpan dengan mewakili c (F, T) sebagai! 1: 0, terima kasih kepada LeakyNun

23 byte disimpan berkat Giuseppe

Cobalah online!

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

Ini tidak berfungsi pada TIO karena memindai baris berikutnya, yang merupakan kode.
Leaky Nun




Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.