Tôi đã thực hiện điều này bằng Python, nhưng dường như nó có thể rút ngắn rất nhiều:

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

Vì vậy, nếu người dùng gõ:

Hello World

Chương trình in:

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

CJam, 22 20 byte

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

Kiểm tra nó ở đây.

Giải trình

Làm thế nào để bạn bọc một lưới các ký tự 2D trong một lớp khoảng trắng (hoặc bất kỳ ký tự nào khác)? Đúng: bốn lần, bạn nối một khoảng trắng vào mỗi dòng và sau đó xoay lưới 90 độ. Đó chính xác là những gì tôi đang làm ở đây với tám vòng quay: bốn cho không gian, bốn cho #:

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 tổ hợp phím

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

Giả sử đầu vào được cung cấp dưới dạng một dòng văn bản trong tệp hiện đang mở.

Giải trình:

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

Điều này cũng có thể được chạy như một "chương trình" như vậy:

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

Đó là một chút phức tạp, nhưng nó hoạt động.

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

Đây là loại thử thách pb được thực hiện cho! Không phải là nó cạnh tranh cho loại thách thức này hay bất cứ điều gì. Nó vẫn là một ngôn ngữ golf khủng khiếp. Tuy nhiên, những thách thức như thế này là rất ít để giải quyết trong pb so với những người khác. Vì pb coi đầu ra của nó là một khung vẽ 2D và có thể ghi vào bất kỳ hợp đồng nào, nên mọi thứ liên quan đến định vị văn bản / vẽ xung quanh văn bản (tức là thách thức này) được xử lý khá trực quan.

Xem nó chạy:

Hình dung này được tạo ra với phiên bản đang phát triển của pbi, trình thông dịch pb. Đường kẻ với nền màu xanh làY=-1 , nơi đầu vào được lưu trữ khi chương trình bắt đầu. Hình chữ nhật với nền màu đỏ là vị trí hiện tại của bàn chải. Các hình chữ nhật có nền màu vàng là bất cứ nơi nào ký tự ascii 32 (một khoảng trắng) được ghi rõ ràng vào khung vẽ. Bất kỳ khoảng trắng nào không có nền này thực sự có giá trị 0, được chuyển đổi thành khoảng trắng .

Đây là mã với các ý kiến ​​tôi đã sử dụng trong khi viết nó, với một số tiêu đề phần có liên quan theo chủ đề;)

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

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

Đây có lẽ là golf. Có một số nơi tôi không biết nên lưu trữ giá trị ở đâu đó để tái sử dụng hoặc làm lại / lấy nó từ nơi khác trên băng. Thay vì thực hiện công việc để tìm ra nó, tôi đã không làm điều đó. : D

Với nhận xét:

++++++++++>              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(|+" ",)/,

Tranh thủ chuỗi, Thêm khoảng trắng vào tất cả bốn mặt của chuỗi, sau đó thêm octothorpe vào mỗi bên của chuỗi. Trong hành động:

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

Hoạt động trong oK, Kona và k5.

Có khá nhiều biến thể trong một ký tự có độ dài loại bỏ sự dư thừa ở trên, nhưng dường như không có biến thể nào ngay cả khi chúng ta chỉ phải thực hiện thao tác "bọc" hai lần:

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

Bình thường, 31 byte

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

Nhờ những người bình luận đưa ra gợi ý về cách chơi gôn xa hơn, tôi thực sự không biết ngôn ngữ tốt như bạn có thể (có thể) nói.

Python 3, 88 byte

Cảm ơn @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)

Ví dụ I / O:

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

Perl, 43 76 byte

Chuyển đổi từng dòng nhập văn bản theo quy định:

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

Ví dụ:

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

Đây là cách để xem những gì nó thực sự làm:

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

Vì vậy, một cái gì đó như thế này:

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

JavaScript (ES6), 73

Sử dụng chuỗi mẫu mạnh mẽ, 2 dòng mới là đáng kể và được tính.

Kiểm tra chạy đoạn mã dưới đây trong bất kỳ trình duyệt tuân thủ EcmaScript 6 nào (FireFox và Chrome mới nhất, có thể là 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>

Thời gian này khá ngắn so với lần thử đầu tiên của tôi, xuất phát từ thử thách khác này :

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

Con trăn 2, 74

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

Đưa đầu vào trong dấu ngoặc kép như "Hello World".

• Dòng thứ ba là đầu vào được bọc trong # _ #.
• Dòng thứ hai và thứ tư b là# # với số bên phải của không gian, bao quanh với dòng mới để hai bên để chăm sóc tất cả bốn dòng mới.
• Dòng đầu tiên và thứ năm được #nhân với chiều dài của đầu vào

Các dòng được nối và in.

MATLAB, 93 91 byte

Không phải là đẹp nhất, nhưng nó hoàn thành công việc.

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

Giải thích mã

Bước 1

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

Đọc trong một chuỗi từ STDIN và đặt một không gian duy nhất hàng đầu và dấu vết bên trong nó. 32 là mã ASCII cho một khoảng trắng và đọc trong đầu vào dưới dạng kiểu chuỗi kết hợp các chuỗi 32 thành khoảng trắng.

Bước 2

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

Khai báo một mảng ký tự gồm 5 dấu băm trong một vectơ cột.

Bước 3

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

Tạo một ma trận ký tự 2 hàng được điền bởi các dấu băm trước tiên là khoảng trắng sau. Số lượng ký tự là độ dài của chuỗi đầu vào cộng với 2 để chúng ta có thể chứa khoảng trống trước và sau chuỗi.

Bước 4

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

Chúng ta sẽ ghép mọi thứ lại với nhau. Chúng tôi đặt cột đầu tiên gồm 5 băm, tiếp theo là phần trung tâm và tiếp theo là một cột 5 băm khác. Phần trung tâm bao gồm ma trận ký tự 2 hàng được tạo ở Bước # 3, chính chuỗi đầu vào có dấu cách và khoảng trắng ở đầu, theo sau là ma trận ký tự 2 hàng nhưng bị đảo ngược.

Chạy ví dụ

>> 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 cho -lp(nếu đầu vào không kết thúc trong một dòng mới, -lcó thể bỏ đi để lưu một byte).

Chấp nhận đầu vào trên STDIN:

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

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

Cốt lõi của chương trình là một lát danh sách:

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

Điều này cung cấp một cách nhỏ gọn để lưu trữ ba hàng duy nhất của đầu ra (hai hàng đầu tiên của hộp giới hạn giống như hai hàng cuối cùng, chỉ được nhân đôi). Đối với chuỗi đầu vào foo, kết quả của lát sẽ là:

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

Tham gia các giá trị này với #\n#cho chúng tôi hộp của chúng tôi.

Lưu ý rằng Perl 5.14+ được yêu cầu sử dụng công cụ rsửa đổi không phá hủy cho toán tử chuyển ngữ y///.

PHP, 95 93 byte

Không chính xác tuyệt vời hoặc bất cứ điều gì tương tự, nhưng nó thực sự thú vị!

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

Không chính xác đẹp hay bất cứ điều gì, nhưng nó hoạt động rực rỡ!

Cảm ơn @Titus đã lưu 2 byte.

C ++, 198 byte

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

Cú đâm đầu tiên của tôi vào codegolf, và trong khi tôi học C ++ có lẽ không phải là ngôn ngữ tốt nhất để chơi gôn, tôi cảm thấy mình đã quyết định (?) Cho lần thử đầu tiên.

Bị đánh cắp

#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 và t đại diện cho các dòng được băm đầy đủ, đầu vào (có băm ở mỗi đầu) và các dòng giữa đầu vào và các dòng được băm tương ứng.

> <> , 106 104 byte

Tôi có cảm giác rằng> <> có thể không phải là ngôn ngữ tốt nhất cho việc này, nhưng tôi đã đi quá xa để từ bỏ và không đăng bài này. Các *ở phần cuối của dòng 4 được coi là một dấu cách. Bạn không thích cách mã này trông kỳ cục đến mức nào? Hãy thử trực tuyến .

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

Đây là một phiên bản không có gì ngoài những người thay đổi hướng để đưa ra ý tưởng về cách con trỏ di chuyển (lưu ý rằng tôi đã bỏ qua các câu lệnh "dịch chuyển tức thời", tức là . ).

Hướng dòng chảy:

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

Giải trình

Hình dung của tôi về ngăn xếp sẽ được dựa trên đầu vào input. > <> là ngôn ngữ hai chiều, vì vậy hãy chú ý đến nơi con trỏ di chuyển giữa các dòng, vì nó thực thi mã bên dưới nó (trong mã này<>v^ này chủ yếu được sử dụng để thay đổi hướng). Tôi sẽ bắt đầu giải thích từ nơi con trỏ bắt đầu. Lưu ý rằng sẽ có hai dòng lặp lại, vì con trỏ di chuyển ngược sau dòng thứ năm.

Điều tôi luôn thấy thú vị về> <> là khả năng sửa đổi mã nguồn của chính nó và tôi sử dụng nó trong chương trình này. Dòng 3 và 4 được sử dụng lại để in hai dòng cuối cùng thông qua sửa đổi một ký tự trong mỗi dòng.

Dòng 1: Vòng lặp đầu vào

<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

Cây rơm: [-1,t,u,p,n,i]

Dòng 2: Tạo dòng đầu ra thứ ba

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

Cây rơm: [9,9,9,9,#, ,t,u,p,n,i, ,#]

Dòng 3: In dòng đầu ra

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

Cây rơm: [0,9,9,9,#, ,t,u,p,n,i, ,#]

Đầu ra:

#########

Dòng 4: In dòng đầu ra thứ hai

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

Cây rơm: [0,9,9,#, ,t,u,p,n,i, ,#]

Đầu ra ( *đại diện cho không gian):

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

Dòng 5: In dòng đầu ra thứ ba

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

Cây rơm: [9,9,0]

Đầu ra:

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

Dòng 6: Thiết lập để in dòng đầu ra thứ tư và thứ năm

.>";^"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

Cây rơm: [0,9,9,0]

Dòng 4: In dòng thứ tư của đầu ra

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

Cây rơm: [0,9,0]

Đầu ra ( *đại diện cho không gian):

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

Dòng 3: In dòng đầu ra cuối cùng

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

Cây rơm: [0,0]

Đầu ra:

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

PHP, 93 91 byte

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

Lấy đầu vào từ đối số dòng lệnh; không gian thoát hoặc sử dụng dấu ngoặc đơn. Chạy với -r.

Pyke (không cạnh tranh), 6 byte

.X".X#

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

Pyke được viết sau thử thách và do đó không cạnh tranh.

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

.Xlấy một chuỗi và một chuỗi hằng arg và bao quanh một chuỗi với nhóm ký tự đó. Hằng số arg có thể có tối đa 8 ký tự và có các hiệu ứng khác nhau về cách bao quanh chuỗi.

05AB1E, 26 byte , Không cạnh tranh

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

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

EDIT: Ái chà! Không nhận thấy rằng đây là một challange cũ! Lấy làm tiếc!

C # - 142 byte (thân phương thức là 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));}}

Ung dung:

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

Tôi đoán nó có thể được đánh gôn hơn nữa, nhưng vì chưa có câu trả lời của Ruby, nên đây là:

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

Vợt 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)#\#)))))

Ung dung:

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

Kiểm tra:

(f "This is a test" )

Đầu ra:

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

Ung dung:

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

Phiên bản đầu tiên:

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

Chương trình đầy đủ với các trường hợp thử nghiệm:

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

Phiên bản ung dung

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$