Zrobiłem to już w Pythonie, ale wydaje się, że można to znacznie skrócić:

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

Więc jeśli użytkownik wpisze:

Hello World

Program drukuje:

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

CJam, 22 20 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

Jak owinąć siatkę znaków 2D w jedną warstwę spacji (lub dowolną inną postać)? Prawidłowo: czterokrotnie dodajesz spację do każdej linii, a następnie obracasz siatkę o 90 stopni. Właśnie to robię tutaj z ośmioma rotacjami: cztery dla spacji, cztery dla #:

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 naciśnięć klawiszy

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

Zakłada, że ​​dane wejściowe są podawane jako pojedynczy wiersz tekstu w aktualnie otwartym pliku.

Wyjaśnienie:

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

Można to również uruchomić jako „program”:

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

Co jest nieco skomplikowane, ale działa.

pb - 89 bajtów

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

Jest to rodzaj wyzwania, dla którego stworzono pb! Nie dlatego, że jest konkurencyjny dla tego rodzaju wyzwań lub czegokolwiek. To wciąż okropny język golfa. Jednak takie wyzwania są o wiele mniej uciążliwe do rozwiązania w PB niż inne. Ponieważ pb traktuje swoje dane wyjściowe jako płótno 2D i jest w stanie pisać na dowolnych współrzędnych, wszystko, co obejmuje pozycjonowanie tekstu / rysowanie wokół tekstu (tj. To wyzwanie) jest obsługiwane dość intuicyjnie.

Zobacz, jak działa:

ta wizualizacja została stworzona przy użyciu opracowanej wersji pbi, interpretera pb. Linia z niebieskim tłem to miejsce Y=-1, w którym dane wejściowe są zapisywane po uruchomieniu programu. Prostokąt z czerwonym tłem to bieżąca lokalizacja pędzla. Prostokąty z żółtym tłem są wszędzie tam, gdzie znak ascii 32 (spacja) jest wyraźnie zapisany na płótnie. Wszelkie puste spacje bez tego tła faktycznie mają wartość 0, która jest konwertowana na spację.

Oto kod z komentarzami, których użyłem podczas pisania, z niektórymi tematycznie nagłówkami sekcji;)

################################
#                              #
# 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 bajtów

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

Jest to prawdopodobnie gra w golfa. Jest kilka miejsc, w których nie wiedziałem, czy lepiej byłoby przechowywać gdzieś wartość do ponownego użycia lub ją przerobić / zdobyć ją z innego miejsca na taśmie. Zamiast tego, żeby to rozgryźć, nie zrobiłem tego. :RE

Z komentarzami:

++++++++++>              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 bajtów

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

Zapisz łańcuch, dodaj spację do wszystkich czterech boków łańcucha, a następnie dodaj oktorę do każdej strony łańcucha. W akcji:

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

Działa w ok, Kona i k5.

Istnieje kilka odmian w obrębie jednego znaku długości, które usuwają nadmiarowość w powyższym, ale wydaje się, że żadna z nich nie ulega przerwaniu, nawet jeśli musimy tylko dwukrotnie wykonać operację „zawijania”:

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

Pyth, 31 bajtów

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

Dzięki ludziom w komentarzach, którzy udzielają wskazówek, jak dalej grać w golfa, tak naprawdę nie znam dobrze języka, jak można (prawdopodobnie) powiedzieć.

Python 3, 88 bajtów

Dzięki @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)

Przykład I / O:

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

Perl, 43 76 bajtów

Przekształć każdy wiersz wprowadzania tekstu, jak określono:

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

Na przykład:

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

Oto jak zobaczyć, co tak naprawdę robi:

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

Coś więcej takiego:

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

JavaScript (ES6), 73

Mocno przy użyciu ciągu szablonu, 2 znaki nowej linii są znaczące i są liczone.

Przetestuj poniższy fragment kodu w dowolnej przeglądarce zgodnej z EcmaScript 6 (FireFox i najnowszy Chrome, może 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>

Jest to o wiele krótsza niż moja pierwsza próba, wywodząca się z tego innego wyzwania :

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

Pobiera dane wejściowe w cudzysłowie jak "Hello World" .

• Trzeci wiersz to wejście zamknięte w # _ #.
• Druga i czwarta linia b mają # #odpowiednią liczbę spacji, otoczoną znakami nowej linii po obu stronach, aby zająć się wszystkimi czterema liniami.
• Pierwsza i piąta linia to # mnożone przez długość wejścia

Linie są łączone i drukowane.

MATLAB, 93 91 bajtów

Nie najładniejszy, ale wykonuje zadanie.

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

Objaśnienie kodu

Krok 1

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

Przeczytaj ciąg STDIN i umieść w nim wiodącą i końcową pojedynczą spację. 32 jest kodem ASCII dla spacji, a odczyt na wejściu, gdy ciąg znaków łączy 32s w spacje.

Krok 2

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

Zadeklaruj tablicę znaków zawierającą 5 znaków skrótu w wektorze kolumny.

Krok 3

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

Utwórz 2-wierszową matrycę znaków, która będzie najpierw wypełniona znakami skrótu, a następnie spacją. Liczba znaków to długość ciągu wejściowego plus 2, dzięki czemu możemy uwzględnić miejsce przed i po ciągu.

Krok 4

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

Wszystko poskładamy. Umieszczamy pierwszą kolumnę z 5 skrótami, następnie środkową część, a następnie kolejną kolumnę z 5 skrótami. Część środkowa składa się z 2-wierszowej matrycy znaków utworzonej w kroku # 3, samego łańcucha wejściowego, który ma spację końcową i wiodącą, a następnie 2-wierszowej matrycy znaków, ale odwróconej.

Przykład działa

>> 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 bajtów

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

54 bajty + 2 bajty na -lp(jeśli dane wejściowe nie kończą się nowym wierszem, -lmożna je upuścić, aby zapisać jeden bajt).

Akceptuje dane wejściowe STDIN:

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

Jak to działa

Trzon programu stanowi wycinek listy:

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

Zapewnia to kompaktowy sposób przechowywania trzech unikalnych wierszy danych wyjściowych (pierwsze dwa wiersze ramki granicznej są takie same jak dwa ostatnie, tylko dublowane). W przypadku ciągu wejściowego foowyniki wycinka będą następujące:

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

Połączenie tych wartości #\n#daje nam nasze pudełko.

Zauważ, że Perl 5.14+ jest wymagany, aby użyć nieniszczącego rmodyfikatora operatora transliteracji y///.

PHP, 95 93 bajtów

Niezupełnie genialne lub coś podobnego, ale tak naprawdę było fajnie!

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

Niezupełnie ładne czy coś, ale działa świetnie!

Dzięki @Titus za zapisanie 2 bajtów.

C ++, 198 bajtów

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

Moje pierwsze dźgnięcie w codegolf i chociaż nauczyłem się C ++ prawdopodobnie nie jest najlepszym językiem do gry w golfa, poczułem, że zrobiłem to przyzwoicie (?) Podczas mojej pierwszej próby.

Bez golfa

#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 i t reprezentują odpowiednio linie w pełni zaszyfrowane, dane wejściowe (z skrótami na każdym końcu) i linie między liniami wejściowymi i hashowanymi.

> <> , 106 104 bajtów

Mam wrażenie, że> <> może nie być najlepszym językiem do tego, ale zaszedłem za daleko, aby się poddać i nie opublikować tego. *Na koniec linii 4 ma być przestrzenią. Nie podoba ci się, jak niesamowicie groteskowy jest ten kod? Wypróbuj online .

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

Oto wersja bez zmieniaczy kierunku, aby dać wyobrażenie o tym, jak porusza się wskaźnik (zwróć uwagę, że pominąłem instrukcje „teleportacji” .).

Kierunek przepływu:

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

Wyjaśnienie

Moja wizualizacja stosu będzie oparta na danych wejściowych input. > <> jest językiem dwuwymiarowym, więc zwróć uwagę na to, gdzie wskaźnik przesuwa się między liniami, ponieważ wykonuje kod pod nim (w tym kodzie <>v^służą głównie do zmiany kierunku). Zacznę wyjaśnienia od miejsca, w którym zaczyna się wskaźnik. Zauważ, że powtórzą się dwie linie, gdy wskaźnik przesunie się do tyłu po piątej linii.

To, co zawsze uważam za fajne w> <>, to możliwość modyfikowania własnego kodu źródłowego i korzystam z niego w tym programie. Linie 3 i 4 są ponownie używane do drukowania ostatnich dwóch wierszy poprzez modyfikację znaku w każdym z nich.

Wiersz 1: Pętla wejściowa

<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

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

Wiersz 2: generuje trzeci wiersz wyniku

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

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

Wiersz 3: drukuje pierwszy wiersz wyniku

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

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

Wydajność:

#########

Wiersz 4: drukuje drugi wiersz wyniku

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

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

Dane wyjściowe ( *reprezentuje spację):

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

Wiersz 5: drukuje trzeci wiersz wyniku

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

Stos: [9,9,0]

Wydajność:

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

Wiersz 6: Ustawia się do drukowania czwartego i piątego wiersza wydruku

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

Stos: [0,9,9,0]

Wiersz 4: wydrukuj czwarty wiersz wyniku

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

Stos: [0,9,0]

Dane wyjściowe ( *reprezentuje spację):

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

Wiersz 3: wydrukuj ostatni wiersz wyniku

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

Stos: [0,0]

Wydajność:

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

PHP, 93 91 bajtów

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

Pobiera dane wejściowe z argumentu wiersza poleceń; użyj spacji lub użyj pojedynczych cudzysłowów. Uruchom z -r.

Pyke (niekonkurencyjny), 6 bajtów

.X".X#

Wypróbuj tutaj!

Pyke został napisany po konkursie i dlatego jest niekonkurencyjny.

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

.Xpobiera ciąg znaków i stały ciąg znaków arg i otacza ciąg znaków tą grupą znaków. Stały argument może mieć do 8 znaków i mieć różny wpływ na otoczenie łańcucha.

05AB1E, 26 bajtów , nie konkuruje

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

Wypróbuj online!

EDYCJA: Woah! Nie zauważyłem, że to stare wyzwanie! Przepraszam!

C # - 142 bajty (treść metody to 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));}}

Nie golfowany:

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 bajtów

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

Lua, 90 bajtów

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

Rubinowy, 83 bajty

Myślę, że można by dalej grać w golfa, ale ponieważ nie ma jeszcze odpowiedzi Ruby, oto ona:

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

Rakieta 172 bajtów

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

Nie golfowany:

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

Testowanie:

(f "This is a test" )

Wydajność:

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

C #, 116 110 bajtów

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

Nie golfowany:

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

Początkowa wersja:

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

Pełny program z przypadkami testowymi:

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 bajtów

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

Wersja bez golfa

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 bajty

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