Ich habe das bereits in Python gemacht, aber es scheint, dass es viel gekürzt werden könnte:

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

Also, wenn der Benutzer Folgendes eingibt:

Hello World

Das Programm druckt:

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

CJam, 22 20 Bytes

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

Teste es hier.

Erläuterung

Wie wird ein 2D-Zeichenraster in eine Ebene mit Leerzeichen (oder in ein beliebiges anderes Zeichen) gewickelt? Richtig: Sie fügen vier Mal ein Leerzeichen an jede Linie an und drehen das Raster dann um 90 Grad. Genau das mache ich hier mit acht Umdrehungen: vier für Leerzeichen, vier für #:

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 Tastenanschläge

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

Angenommen, die Eingabe wird als einzelne Textzeile in der aktuell geöffneten Datei bereitgestellt.

Erläuterung:

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

Dies kann auch als "Programm" wie folgt ausgeführt werden:

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

Welches ist ein bisschen gewunden, aber es funktioniert.

pb - 89 Bytes

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

Dies ist die Art von Herausforderung, für die pb gemacht wurde! Nicht, dass es für diese Art von Herausforderung oder irgendetwas konkurrenzfähig wäre . Es ist immer noch eine schreckliche Golfsprache. Herausforderungen wie diese sind jedoch in pb weitaus weniger schmerzhaft als andere. Da pb seine Ausgabe als 2D-Zeichenfläche behandelt und in der Lage ist, in beliebige Koordinaten zu schreiben, wird alles, was das Positionieren von Text / Zeichnen um Text (dh diese Herausforderung) betrifft, eher intuitiv gehandhabt.

Sehen Sie es sich an:

Diese Visualisierung wurde mit einer in der Entwicklung befindlichen Version von pbi, dem pb-Interpreter, erstellt. In der blau hinterlegten Zeile wird die Y=-1Eingabe beim Programmstart gespeichert. Das Rechteck mit dem roten Hintergrund ist die aktuelle Position des Pinsels. Die Rechtecke mit gelbem Hintergrund befinden sich überall dort, wo das ASCII-Zeichen 32 (ein Leerzeichen) explizit auf die Zeichenfläche geschrieben wird. Leerzeichen ohne diesen Hintergrund haben tatsächlich den Wert 0, der in ein Leerzeichen umgewandelt wird.

Hier ist der Code mit den Kommentaren, die ich beim Schreiben verwendet habe, mit einigen thematisch relevanten Abschnittsüberschriften;)

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

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

Das ist wahrscheinlich golfen. Es gibt einige Stellen, an denen ich nicht wusste, ob es besser ist, einen Wert irgendwo für die Wiederverwendung zu speichern oder ihn neu zu erstellen / von einer anderen Stelle auf dem Band abzurufen. Anstatt die Arbeit zu erledigen, um es herauszufinden, habe ich das nicht getan. : D

Mit Kommentaren:

++++++++++>              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 Bytes

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

Tragen Sie die Zeichenfolge ein, fügen Sie allen vier Seiten einer Zeichenfolge ein Leerzeichen hinzu, und fügen Sie dann jeder Seite der Zeichenfolge ein Oktothorpe hinzu. In Aktion:

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

Arbeitet in OK, Kona und K5.

Es gibt einige Variationen innerhalb eines Zeichen der Länge, die die Redundanz in der obigen Beschreibung beseitigen, aber keine scheint zu brechen, selbst wenn wir die "Umbruch" -Operation nur zweimal ausführen müssen:

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

Pyth, 31 Bytes

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

Dank der Kommentare von Leuten, die Hinweise zum weiteren Golfspielen geben, kenne ich die Sprache wirklich nicht so gut, wie Sie (wahrscheinlich) sagen können.

Python 3, 88 Bytes

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

Beispiel I / O:

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

Perl, 43 76 Bytes

Transformieren Sie jede Texteingabezeile wie angegeben:

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

Beispielsweise:

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

So können Sie sehen, was es wirklich tut:

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

So etwas ähnliches:

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

JavaScript (ES6), 73

Die 2 Zeilenumbrüche, die häufig Template-Strings verwenden, sind signifikant und werden gezählt.

Testen Sie das folgende Snippet in einem EcmaScript 6-kompatiblen Browser (FireFox und das neueste Chrome, möglicherweise 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>

Dies ist ziemlich kürzer als mein erster Versuch, abgeleitet von dieser anderen Herausforderung :

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

Nimmt Eingaben in Anführungszeichen wie "Hello World".

• Die dritte Zeile ist die Eingabe in # _ # .
• Die zweite und vierte Zeile b sind# # die richtige Anzahl von Leerzeichen und sind zu beiden Seiten mit Zeilenumbrüchen umgeben, um alle vier Zeilenumbrüche zu bearbeiten.
• Die erste und fünfte Zeile werden #mit der Länge der Eingabe multipliziert

Die Zeilen werden verkettet und gedruckt.

MATLAB, 93 91 Bytes

Nicht das schönste, aber es erledigt die Arbeit.

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

Code-Erklärung

Schritt 1

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

Lesen Sie einen String aus STDIN ein und platzieren Sie ein einzelnes Leerzeichen in diesem. 32 ist der ASCII-Code für ein Leerzeichen, und beim Einlesen der Eingabe als Zeichenfolgentyp werden die 32er in Leerzeichen zusammengefasst.

Schritt 2

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

Deklarieren Sie ein Zeichenarray mit 5 Hash-Zeichen in einem Spaltenvektor.

Schritt 3

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

Erstellen Sie eine 2-zeilige Zeichenmatrix, die zuerst mit Rautezeichen und anschließend mit Leerzeichen gefüllt wird. Die Anzahl der Zeichen entspricht der Länge der Eingabezeichenfolge plus 2, so dass der Abstand vor und nach der Zeichenfolge berücksichtigt werden kann.

Schritt 4

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

Wir werden alles zusammenfügen. Wir platzieren die erste Spalte mit 5 Hashes, gefolgt vom Mittelteil und gefolgt von einer weiteren Spalte mit 5 Hashes. Der mittlere Teil besteht aus der in Schritt 3 erstellten 2-Zeilen-Zeichenmatrix, der Eingabezeichenfolge selbst mit einem nachgestellten und führenden Leerzeichen, gefolgt von der 2-Zeilen-Zeichenmatrix, jedoch in umgekehrter Reihenfolge.

Beispielläufe

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

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

54 Bytes + 2 Bytes für -lp(wenn die Eingabe nicht in einer neuen Zeile endet,-l kann ein Byte gespart werden).

Akzeptiert Eingaben über STDIN:

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

Wie es funktioniert

Der Kern des Programms ist ein Listenausschnitt:

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

Dies bietet eine kompakte Möglichkeit zum Speichern der drei eindeutigen Zeilen der Ausgabe (die ersten beiden Zeilen des Begrenzungsrahmens sind dieselben wie die letzten beiden, nur gespiegelt). Für die Eingabezeichenfolge foowären die Ergebnisse des Slice:

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

Wenn Sie diese Werte mit verbinden #\n#, erhalten Sie unsere Box.

Beachten Sie, dass Perl 5.14+ erforderlich ist, um den zerstörungsfreien rModifikator für den Transliterationsoperator zu verwenden y///.

PHP, 95 93 Bytes

Nicht gerade genial oder ähnliches, aber es hat Spaß gemacht!

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

Nicht gerade hübsch oder so, aber es funktioniert hervorragend!

Vielen Dank an @Titus für das Speichern von 2 Bytes.

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

Mein erster Versuch mit Codegolf, und obwohl ich C ++ gelernt habe, ist es wahrscheinlich nicht die beste Sprache zum Golfen, hatte ich das Gefühl, dass ich es für meinen ersten Versuch anständig (?) Gemacht habe.

Ungolfed

#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 und t repräsentieren die vollständig gehashten Linien, die Eingabe (mit Hashes an jedem Ende) und die Linien zwischen der Eingabe- und der gehashten Linie.

> <> , 106 104 Bytes

Ich habe das Gefühl, dass> <> nicht die beste Sprache dafür ist, aber ich bin zu weit gekommen, um aufzugeben und dies nicht zu posten. Das *am Ende der Zeile 4 soll ein Leerzeichen sein. Liebst du nicht, wie unglaublich grotesk dieser Code aussieht? Probieren Sie es online aus .

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

Hier ist eine Version ohne Richtungswechsler, die eine Vorstellung davon gibt, wie sich der Zeiger bewegt (beachte, dass ich die "Teleport" -Anweisungen weggelassen habe, dh .).

Richtung fluss:

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

Erläuterung

Meine Visualisierung des Stapels basiert auf der Eingabe input. > <> ist eine zweidimensionale Sprache, achten Sie also darauf, wo sich der Zeiger zwischen den Zeilen bewegt, während er darunterliegenden Code ausführt (in diesem Code <>v^werden hauptsächlich Richtungsänderungen verwendet). Ich beginne meine Erklärungen dort, wo der Zeiger beginnt. Beachten Sie, dass zwei Zeilen wiederholt werden, wenn sich der Zeiger nach der fünften Zeile rückwärts bewegt.

Was ich an> <> immer cool finde, ist die Möglichkeit, seinen eigenen Quellcode zu ändern, und ich benutze ihn in diesem Programm. Die Zeilen 3 und 4 werden wiederverwendet, um die letzten beiden Zeilen durch eine Änderung eines Zeichens in jedem zu drucken.

Zeile 1: Eingangsschleife

<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

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

Zeile 2: Erzeugt die dritte Ausgabezeile

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

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

Zeile 3: Druckt die erste Ausgabezeile

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

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

Ausgabe:

#########

Zeile 4: Gibt die zweite Ausgabezeile aus

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

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

Ausgabe (steht *für Leerzeichen):

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

Zeile 5: Gibt die dritte Ausgabezeile aus

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

Stapel: [9,9,0]

Ausgabe:

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

Zeile 6: Legt fest, dass die vierte und fünfte Ausgabezeile gedruckt wird

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

Stapel: [0,9,9,0]

Zeile 4: Gibt die vierte Ausgabezeile aus

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

Stapel: [0,9,0]

Ausgabe (steht *für Leerzeichen):

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

Zeile 3: Letzte Ausgabezeile drucken

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

Stapel: [0,0]

Ausgabe:

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

PHP, 93 91 Bytes

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

Übernimmt Eingaben vom Kommandozeilenargument; Leerzeichen oder einfache Anführungszeichen verwenden. Laufen Sie mit -r.

Pyke (nicht konkurrenzfähig), 6 Bytes

.X".X#

Probieren Sie es hier aus!

Pyke wurde nach der Herausforderung geschrieben und ist daher nicht wettbewerbsfähig.

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

.XNimmt einen String und eine String-Konstante arg und umgibt einen String mit dieser Zeichengruppe. Das konstante Argument kann aus bis zu 8 Zeichen bestehen und hat unterschiedliche Auswirkungen auf die Umrandung der Zeichenfolge.

05AB1E, 26 Byte , nicht konkurrierend

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

Probieren Sie es online!

EDIT: Woah! Ich habe nicht bemerkt, dass dies eine alte Herausforderung ist! Es tut uns leid!

142 Bytes (Methodentext ist 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));}}

Ungolfed:

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 Bytes

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

Lua, 90 Bytes

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 Bytes

Ich vermute, es könnte weiter golfen werden, aber da es noch keine Ruby-Antwort gibt, ist es hier:

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

Schläger 172 Bytes

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

Ungolfed:

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

Testen:

(f "This is a test" )

Ausgabe:

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

C # 116 110 Bytes

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

Ungolfed:

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

Erste Version:

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

Volles Programm mit Testfällen:

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 Bytes

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

Ungolfed-Version

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 Bytes

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