Saya sudah membuat ini dengan Python, tetapi tampaknya itu bisa dipersingkat banyak:

txt = input("Type something.. ")
c = "#"
b = " "
print(c * (len(txt) + 4))
print(c, b * len(txt), c)
print(c, txt, c)
print(c, b * len(txt), c)
print(c * (len(txt) + 4))

Jadi jika tipe pengguna:

Hello World

Program mencetak:

###############
#             #
# Hello World #
#             #
###############

CJam, 22 20 byte

qa{4/3*' +f+W%z}8/N*

Uji di sini.

Penjelasan

Bagaimana Anda membungkus kisi-kisi karakter 2D dalam satu lapisan spasi (atau karakter lain)? Benar: empat kali, Anda menambahkan spasi untuk setiap baris dan kemudian memutar grid dengan 90 derajat. Itulah yang saya lakukan di sini dengan delapan rotasi: empat untuk spasi, empat untuk #:

qa      e# Read the input and wrap it in an array, to make it a 2D grid.
{       e# Execute this block for each value from 0 to 7.
  4/3*  e#   Divide by 4, multiply by 3. Gives 0 for the first four iterations and
        e#   and 3 for the other four.
  ' +   e#   Add the result to a space character (space + 3 == #).
  f+    e#   Append this to each line of the grid.
  W%z   e#   Reverse the lines, then transpose the grid - together these rotate it.
}8/
N*      e# Join the lines of the grid by newlines.

vim, 28 27 penekanan tombol

I# <esc>A #<esc>Y4PVr#G.kwv$3hr kk.

Asumsikan input disediakan sebagai satu baris teks dalam file yang sedang terbuka.

Penjelasan:

I# <esc>        put a "#" and space at the beginning of the line
A #<esc>        put a space and "#" at the end of the line
Y4P             copy the line 4 times
Vr#             replace the entirety of the first line with "#"s
G.              do the same for the last line
kwv$3hr<space>  replace middle of the fourth line with spaces
kk.             do the same for the second line

Ini juga dapat dijalankan sebagai "program" seperti:

echo 'Hello World' | vim - '+exe "norm I# \<esc>A #\<esc>Y4PVr#G.kwv$3hr kk."'

Yang agak berbelit-belit, tetapi berhasil.

pb - 89 byte

v[4]w[Y!-1]{b[35]^}w[B!0]{t[B]vvv>>b[T]^^^<}v>>>w[Y!4]{b[35]v}w[X!0]{b[35]^[Y]b[35]v[4]<}

Ini adalah jenis tantangan yang dibuat pb! Bukannya itu kompetitif untuk tantangan semacam ini atau apa pun. Ini masih merupakan bahasa golf yang mengerikan. Namun, tantangan seperti ini jauh lebih sulit untuk diselesaikan di pb daripada yang lain. Karena pb memperlakukan outputnya sebagai kanvas 2D dan mampu menulis ke semua koordinat, apa pun yang melibatkan penempatan teks / gambar di sekitar teks (yaitu tantangan ini) ditangani agak secara intuitif.

Lihat saja:

Visualisasi ini dibuat dengan versi pbi, pb interpreter yang sedang dikembangkan. Garis dengan latar belakang biru adalah Y=-1, di mana input disimpan ketika program dimulai. Kotak dengan latar belakang merah adalah lokasi saat ini dari kuas. Persegi panjang dengan latar belakang kuning adalah di mana saja karakter ascii 32 (spasi) secara eksplisit ditulis ke kanvas. Setiap ruang kosong tanpa latar belakang ini sebenarnya memiliki nilai 0, yang dikonversi menjadi spasi.

Berikut kode dengan komentar yang saya gunakan saat menulisnya, dengan beberapa tajuk bagian yang relevan secara tematik;)

################################
#                              #
# Handle first column oddities #
#                              #
################################
v[4]           # Start from Y=4 and go up (so we land on input afterwords)
w[Y!-1]{       # While we're on the visible part of the canvas
    b[35]^         # Write "#", then go up
}

#########################
#                       #
# Insert text of output #
#                       #
#########################

w[B!0]{        # For each character of input
    t[B]           # Save input char in T
    vvv>>          # Down 3 + right 2 = where text part of output goes
    b[T]^^^<       # Write T and go to next char
}

###############################
#                             #
# Handle last column oddities #
#                             #
###############################

v>>>           # Go to Y=0, X=(X of last text output's location + 2)
w[Y!4]{        # Until we reach the last line of output
    b[35]v         # Draw "#", then go down
}

###########################
#                         #
# Loop to finish Y=0, Y=4 #
#                         #
###########################

w[X!0]{        # Until we've gone all the way left
    b[35]^[Y]      # Print "#" at Y=4, go to Y=0
    b[35]v[4]      # Print "#" at Y=0, go to Y=4
    <              # Move left, printing until output is complete
}

brainfuck - 156 byte

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

Ini mungkin golf. Ada beberapa tempat di mana saya tidak tahu apakah akan lebih baik untuk menyimpan nilai di suatu tempat untuk digunakan kembali atau untuk memperbaikinya / pergi mendapatkannya dari tempat lain di kaset. Alih-alih melakukan pekerjaan untuk mencari tahu, saya tidak melakukan itu. : D

Dengan komentar:

++++++++++>              Place a 10 (\n) at the beginning of the tape

,[>>+++++[<+++++++>-],]  Place a byte of input; place a 35 (#); repeat until end of input

<....                    Print the last cell (35; #) 4 times

[.---<<]                 Print every noninput cell on the tape in reverse (one # for each byte of input; then \n)
                         After printing each cell; decrease it by 32

>>+++                    Increase the 7 back up to 10

>>+++.---.               Increase a 32 (space) back up to 35 (#); print it; put it back to 32 and print again

[.>>]                    Print every 32 on the tape (one for each byte of input)

<<.+++.                  Print the last space again; increase it by 3 and print the resulting #

[<]>.                    Go to the beginning of the tape and print the \n

>>+++.---.               Increase a 32 (space) back up to 35 (#); print it; put it back to 32 and print again

<[.>>]                   Print every byte of input

<<<.>>.---               Print a space; then print a 35 (#} that was left behind earlier; Set it back to 32 after

[<]>.---                 Go to the beginning of the tape and print the \n; decrease by 3

>>+++.---                Set a space to #; print it; set it back to space

[.>>]                    Print all spaces

<<..+++.---              Print a space twice more; set it to #; print it again; set it back to space

[<]>                     Go to the "newline" (currently a 7 instead of 10)

[+++.>>]                 Increase by 3; print; do the same for all spaces (to set them to # before printing)

<<....                   Print the last # 4 more times

K, 21 byte

4(|+"#",)/4(|+" ",)/,

Daftarkan string, Tambahkan spasi ke keempat sisi string, lalu tambahkan octothorpe ke setiap sisi string. Beraksi:

  4(|+"#",)/4(|+" ",)/,"Hello."
("##########"
 "#        #"
 "# Hello. #"
 "#        #"
 "##########")

Bekerja di oK, Kona dan k5.

Ada beberapa variasi dalam satu karakter panjang yang menghilangkan redundansi di atas, tetapi tidak ada yang nampak impas ketika kita hanya perlu melakukan operasi "wrap" dua kali:

{x{|+x," #"y}/&4 4},:
{x{|+x,y}/,/4#'" #"},:
{x{|+x,y}/" #"@&4 4},:
{|+x,y}/[;" #"@&4 4],:

Pyth, 31 byte

Js[K\#*d+2lzKb*K+4lz)_Jjd[KzK)J

Terima kasih kepada orang-orang di komentar yang memberikan petunjuk tentang cara bermain golf lebih lanjut, saya benar-benar tidak tahu bahasa dengan sebaik yang Anda bisa (mungkin) katakan.

Python 3, 88 byte

Terima kasih @WorldSEnder

s=" ";n=s+input()+s
b=len(n)
h="#";x=h*(b+2);y=h+s*b+h;z="\n"
print(x+z+y+z+h+n+h+z+y+z+x)

Contoh I / O:

This is a test
##################
#                #
# This is a test #
#                #
##################

Perl, 43 76 byte

Ubah setiap baris input teks seperti yang ditentukan:

s/.*/($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x"/e

Sebagai contoh:

echo surround a long string with pounds | 
perl -ple's/.*/($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x"/e' 
######################################
#                                    #
# surround a long string with pounds #
#                                    #
######################################

Inilah cara melihat apa yang sebenarnya dilakukannya:

perl -MO=Deparse,-p,-q,-x9 -ple '($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x";'
BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined(($_ = <ARGV>))) {
    chomp($_);
    (((($x = ('#' x (4 + ($z = length($_))))) . "\n") . ($y = (('#' . (' ' x (2 + $z))) . "#\n"))) . (((('# ' . $&) . " #\n") . $y) . $x));
}
continue {
    (print($_) or die((('-p destination: ' . $!) . "\n")));
}
-e syntax OK

Jadi sesuatu yang lebih seperti ini:

((  
      (($x =  ('#' x (4 + ($z = length($_))))) . "\n")
    .  ($y = (('#' . (' ' x (2 + $z))) . "#\n"))
  )  
    .  (((('# ' . $&) . " #\n") . $y) . $x)
)   

JavaScript (ES6), 73

Sangat menggunakan string template, 2 baris baru signifikan dan dihitung.

Tes menjalankan cuplikan di bawah ini di peramban apa pun yang mendukung EcmaScript 6 (FireFox dan Chrome terbaru, mungkin Safari).

f=s=>(z=c=>`*${c[0].repeat(s.length+2)}*
`)`*`+z` `+`* ${s} *
`+z` `+z`*`

// Less golfed

U=s=>(
  z=c=>'*' + c.repeat(s.length+2) + '*\n',
  z('*') + z(' ') + '* ' + s + ' *\n' + z(' ') + z('*')
)

// TEST

O.innerHTML=f('Hello world!')

<pre id=O></pre>

Ini cukup pendek dari percobaan pertama saya, yang berasal dari tantangan lain ini :

f=s=>(q=(c,b,z=c.repeat(b[0].length))=>[z,...b,z].map(r=>c+r+c))('*',q(' ',[s])).join`\n`

Python 2, 74

s='# %s #'%input()
n=len(s)
b='\n#'+' '*(n-2)+'#\n'
print'#'*n+b+s+b+'#'*n

Mengambil input dalam tanda kutip like "Hello World".

• Baris ketiga adalah input yang dimasukkan # _ #.
• Garis kedua dan keempat b adalah # #dengan jumlah yang tepat ruang, dikelilingi dengan baris baru untuk kedua sisi untuk mengurus semua empat baris.
• Baris pertama dan kelima #dikalikan dengan panjang input

Garis-garis digabungkan dan dicetak.

MATLAB, 93 91 byte

Bukan yang tercantik, tapi itu menyelesaikan pekerjaan.

t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])

Penjelasan Kode

Langkah 1

t=[32 input('','s') 32];

Baca dalam string dari STDIN dan letakkan spasi tunggal yang memimpin dan tertinggal di dalamnya. 32 adalah kode ASCII untuk spasi dan bacaan di input sebagai tipe string menyatukan 32-an ke dalam spasi.

Langkah 2

m='#####'.';

Nyatakan larik karakter 5 tanda hash dalam vektor kolom.

Langkah # 3

n=repmat('# ',numel(t),1)'

Buat matriks karakter 2 baris yang diisi oleh tanda hash pertama diikuti oleh spasi setelah. Jumlah karakter adalah panjang dari string input ditambah 2 sehingga kita dapat mengakomodasi ruang sebelum dan sesudah string.

Langkah # 4

disp([m [n;t;flipud(n)] m])

Kita akan menyatukan semuanya. Kami menempatkan kolom pertama dari 5 hash, diikuti oleh bagian tengah dan diikuti oleh kolom lain dari 5 hash. Bagian tengah terdiri dari matriks karakter 2 baris yang dibuat pada Langkah # 3, string input itu sendiri yang memiliki ruang trailing dan terdepan, diikuti oleh matriks karakter 2 baris tetapi dibalik.

Contoh Berjalan

>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
This is something special for you
#####################################
#                                   #
# This is something special for you #
#                                   #
#####################################
>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
Hello World
###############
#             #
# Hello World #
#             #
###############
>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
I <3 Code Golf StackExchange!
#################################
#                               #
# I <3 Code Golf StackExchange! #
#                               #
#################################

Perl 5.14+, 57 56 byte

perl -lpe '$_=join"#
#",($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'

54 byte + 2 byte untuk -lp(jika input tidak berakhir pada baris baru, -ldapat dijatuhkan untuk menghemat satu byte).

Menerima input pada STDIN:

$ echo Hello World | perl -lpe '$_=join"#
#",($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'
###############
#             #
# Hello World #
#             #
###############

Bagaimana itu bekerja

Inti dari program ini adalah daftar slice:

($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'

Ini memberikan cara yang ringkas untuk menyimpan tiga baris unik dari output (dua baris pertama dari kotak pembatas adalah sama dengan dua baris terakhir, hanya dicerminkan). Untuk string input foo, hasil dari slice adalah:

index   value
--------------
  2    "######"
  1    "     "
  0    " foo "
  1    "     "
  2    "######"

Menggabungkan nilai-nilai ini dengan #\n#memberi kami kotak kami.

Perhatikan bahwa Perl 5.14+ diperlukan untuk menggunakan rpengubah non-destruktif untuk operator transliterasi y///.

PHP, 95 93 byte

Tidak persis brilian atau yang serupa, tapi itu sebenarnya menyenangkan!

$l=strlen($s=" $argv[1] ");printf("#%'#{$l}s#
#%1\${$l}s#
#$s#
#%1\${$l}s#
#%1\$'#{$l}s#",'');

Tidak persis cantik atau apa pun, tetapi itu bekerja dengan cemerlang!

Terima kasih kepada @Titus karena telah menghemat 2 byte.

C ++, 198 Bytes

#include <iostream>
#include <string>
int i;int main(){std::string t,n,o;std::getline(std::cin,o);t="\n#";o="# "+o+" #";for(;i<o.size();i++){n+="#";if(i>1)t+=" ";}t+="#\n";std::cout<<n+t+o+t+n;}

Penusukan pertama saya pada codegolf, dan sementara saya belajar C ++ mungkin bukan bahasa terbaik untuk bermain golf, saya merasa saya telah melakukan dengan sopan (?) Untuk percobaan pertama saya.

Tidak disatukan

#include <iostream>
#include <string>

int i;                              //globals default to a value of 0

int main()
{
    std::string t, n, o;
    std::getline(std::cin, o);

    t = "\n#";                      // t needs hashes at start and end, places hash at start here
    o = "# " + o + " #";            // put hash at each end of input

    for(; i < o.size(); i++) {
        n += "#";                   // fills n with hashes
        if(i > 1) {
            t += " ";               // fill t with spaces between hashes, has two fewer spaces than n has hashes
        }
    }
    t += "#\n";                     // puts final hash at end of t

    std::cout << n + t + o + t + n; // final output
}

n, o dan t mewakili garis hash sepenuhnya, input (dengan hash di masing-masing ujung) dan garis antara input dan garis hash masing-masing.

> <> , 106 104 Bytes

Saya merasa bahwa> <> mungkin bukan bahasa terbaik untuk ini, tapi saya sudah terlalu jauh untuk menyerah dan tidak memposting ini. Di *akhir baris 4 seharusnya spasi. Tidakkah Anda suka tampilan kode ini yang sangat aneh? Cobalah online .

<v?(0:i
v>~" ## "}}l:::
>"#"o1-:?!v02.>~a"#"oo
"-2ooa"#"~<.31v!?:-1o" 
7v?=3loroo"#"a<.4
.>";^"e3pa2p093

Berikut adalah versi tanpa perubahan arah kecuali untuk memberikan gambaran tentang bagaimana pointer bergerak (perhatikan bahwa saya telah meninggalkan pernyataan "teleport", yaitu . ).

Arah aliran:

<v
v>
>         v   >
          <   v 
 v            <
 >           

Penjelasan

Visualisasi stack saya akan didasarkan pada input input. > <> adalah bahasa dua dimensi, jadi perhatikan di mana pointer bergerak di antara garis, karena mengeksekusi kode di bawahnya (dalam kode ini<>v^ ini terutama digunakan untuk mengubah arah). Saya akan memulai penjelasan saya dari tempat penunjuk dimulai. Perhatikan bahwa akan ada dua garis yang diulang, saat penunjuk bergerak mundur setelah garis kelima.

Apa yang selalu saya temukan keren tentang> <> adalah kemampuannya untuk memodifikasi kode sumbernya sendiri, dan saya memanfaatkannya dalam program ini. Baris 3 dan 4 digunakan kembali untuk mencetak dua baris terakhir melalui modifikasi karakter di masing-masing.

Baris 1: Input loop

<v?(0:i
<        change direction to left
   (0:i  checks if input is less than 0 (no input defaults to -1)
 v?      change direction to down if so

Tumpukan: [-1,t,u,p,n,i]

Baris 2: Menghasilkan garis output ketiga

v>~" ## "}}l:::  
 >~" ## "}}      remove -1 (default input value) from stack and pads with # and spaces
           l:::  push 4 lengths of padded input

Tumpukan: [9,9,9,9,#, ,t,u,p,n,i, ,#]

Baris 3: Mencetak baris pertama keluaran

>"#"o1-:?!v02.>~a"#"oo
>"#"o                   print "#"
     1-                 subtract 1 from length (it's at the top of the stack)
       :?!v             move down if top of stack is 0

Tumpukan: [0,9,9,9,#, ,t,u,p,n,i, ,#]

Keluaran:

#########

Baris 4: Mencetak baris kedua dari output

"-2ooa"#"~<.31v!?:-1o"*
 -2ooa"#"~<              pops 0, prints newline, "#", then decrements length by 2
"                   o"*  prints space (* is supposed to be space char)
                  -1     decrements top of stack
           .31v!?:       changes direction to down if top of stack is 0, else jumps back to "

Tumpukan: [0,9,9,#, ,t,u,p,n,i, ,#]

Output ( *mewakili ruang):

#########
#*******

Baris 5: Mencetak baris ketiga dari hasil

7v?=3loroo"#"a<.4
        oo"#"a<    prints "#",newline
       r           reverses stack
7v?=3lo        .4  outputs until stack has 3 values, then changes direction to down

Tumpukan: [9,9,0]

Keluaran:

#########
#       #
# input #

Baris 6: Mengatur dirinya untuk mencetak garis keluaran keempat dan kelima

.>";^"e3pa2p093
 >";^"           push ";",then "^"
      e3p        place "^" as the fifteenth character on line 4
         a2p     place ";" as the eleventh character on line 3
            0    push a value (value doesn't matter -- it will be deleted)
.            93  jump to the tenth character on line 4

Tumpukan: [0,9,9,0]

Baris 4: Cetak baris keluaran keempat

"-2ooa"#"~<.31^!?:-1o"*
   ooa"#"~<              delete 0 (unnecessary value pushed), then print newline,"#"
 -2                      subtract two from value on top of stack (length)
"          .31^!?:-1o"*  print space until top of stack is 0, then change direction to up

Tumpukan: [0,9,0]

Output ( *mewakili ruang):

#########
#       #
# input #
#*******

Baris 3: Cetak baris keluaran terakhir

"#"o1-:?!;02.>~a"#"oo
             >~a"#"oo  pop top of stack, print "#", newline
"#"o1-:?!;02.          print "#" until top of stack is 0, then terminate

Tumpukan: [0,0]

Keluaran:

#########
#       #
# input #
#       #
#########

PHP, 93 91 byte

$b=str_pad("",$e=strlen($s=" $argv[1] "));echo$h=str_pad("",2+$e,"#"),"
#$b#
#$s#
#$b#
$h";

Mengambil input dari argumen baris perintah; keluar dari spasi atau gunakan tanda kutip tunggal. Jalankan dengan -r.

Pyke (tidak kompetitif), 6 byte

.X".X#

Coba di sini!

Pyke ditulis setelah tantangan dan karenanya tidak kompetitif.

.X"    - surround string in spaces
   .X# - surround string in hashes

.Xmengambil string dan string konstan arg dan mengelilingi string dengan grup karakter tersebut. Arg konstan dapat hingga 8 karakter dan memiliki efek berbeda pada bagaimana string dikelilingi.

05AB1E, 26 byte , Tidak bersaing

g4+'#ש,¹' .ø'#.ø,®,

Cobalah online!

EDIT: Woah! Tidak menyadari bahwa ini adalah tantangan lama! Maaf!

C # - 142 byte (tubuh metode adalah 104)

class P{static void Main(string[]a){for(int i=0;++i<6;)System.Console.Write("#{0}#\n",i==3?$" {a[0]} ":new string(" #"[i%2],a[0].Length+2));}}

Tidak Disatukan:

class P
{
    static void Main(string[] a)
    {
        for (int i = 0; ++i < 6;)
            System.Console.Write("#{0}#\n", i == 3 ? $" {a[0]} " : new string(" #"[i%2], a[0].Length + 2));
    }
}

PowerShell, 84 82 byte

$l=$input.length+4;$p='#'*$l;$s=' '*$l;$p,$s,"  $input  ",$s,$p-replace'^ | $','#'

Lua, 90 byte

a=arg[1]h="#"s=" "t="\n"..h c=h:rep(#a+4)..t..s:rep(#a+2)..h..t..s print(c..a..c:reverse())

Ruby, 83 byte

Saya kira itu bisa golf lebih lanjut, tetapi karena belum ada jawaban Ruby, ini dia:

s=ARGV[0]
n=s.size
r="#"*(n+4)
t="\n#"+" "*(n+2)+"#\n"
puts r+t+"\n# "+s+" #\n"+t+r

Racket 172 byte

(λ(s)(let((n(string-length s))(p #\space)(g(λ(l c)(make-string l c))))(display(string-append
(g(+ 4 n)#\#)"\n#"(g(+ 2 n)p)"#\n# "s" #\n#"(g(+ 2 n)p)"#\n"(g(+ 4 n)#\#)))))

Tidak Disatukan:

(define (f s)
  (let ((n (string-length s))
        (p #\space)
        (g (λ (l c) (make-string l c))))
    (display (string-append (g (+ 4 n) #\#)
                            "\n#"
                            (g (+ 2 n) p)
                            "#\n# "
                            s
                            " #\n#"
                            (g (+ 2 n) p)
                            "#\n"
                            (g (+ 4 n) #\#)
                            ))))

Pengujian:

(f "This is a test" )

Keluaran:

##################
#                #
# This is a test #
#                #
##################

C #, 116 110 byte

s=>{string r="\n".PadLeft(s.Length+5,'#'),p="#".PadRight(s.Length+3,' ')+"#\n";return r+p+"# "+s+" #\n"+p+r;};

Tidak Disatukan:

s=>
{
    string r = "\n".PadLeft(s.Length + 5, '#'),         //the first line, made of '#'s
        p = "#".PadRight(s.Length + 3, ' ') + "#\n";    //the second line
    return r + p + "# " + s + " #\n" + p + r;           //output is simmetrical
};

Versi awal:

s=>{int l=s.Length;string r=new string('#',l+4)+"\n",p="#"+new string(' ',l+2)+"#\n";return r+p+"# "+s+" #\n"+p+r;};

Program lengkap dengan uji kasus:

using System;

namespace SurroundStringWithHashes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,string>f= s=>{int l=s.Length;string r=new string('#',l+4)+"\n",p="#"+new string(' ',l+2)+"#\n";return r+p+"# "+s+" #\n"+p+r;};

            Console.WriteLine(f("Hello World"));
            Console.WriteLine(f("Programming Puzzles & Code Golf"));
        }
    }
}

C (gcc) 165 byte

f(*s){i,j;c='#';for(j=0;j<5;j++){if(j==0||j==4){for(i=0;i<strlen(s)+2;i++)printf("#");}else if(j==2) printf("#%s#",s);else printf("#%*c",(strlen(s)+1),c);puts("");

Versi tidak disatukan

void  f(char *s)
{
    int i,j;
    char c='#';

    for(j=0;j<5;j++)
    { 
       if(j==0||j==4)
       { 
         for(i=0;i<strlen(s)+2;i++)
           printf("#");
       }
       else
        if(j==2)
         printf("#%s#",s);
      else
        printf("#%*c",(int)(strlen(s)+1),c);

   puts("");
}

SmileBASIC, 73 byte

LINPUT S$L=LEN(S$)+2O$="#"+" "*L+"#
T$="#"*(L+2)?T$?O$?"# ";S$;" #
?O$?T$