L'ho già fatto in Python, ma sembra che potrebbe essere abbreviato molto:

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

Quindi se l'utente digita:

Hello World

Il programma stampa:

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

CJam, 22 20 byte

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

Provalo qui.

Spiegazione

Come avvolgere una griglia 2D di caratteri in uno strato di spazi (o in qualsiasi altro personaggio)? Corretto: quattro volte, aggiungi uno spazio a ciascuna linea e quindi ruota la griglia di 90 gradi. Questo è esattamente quello che sto facendo qui con otto rotazioni: quattro per gli spazi, quattro per #:

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 sequenze di tasti

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

Presuppone che l'input sia fornito come una singola riga di testo nel file attualmente aperto.

Spiegazione:

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

Questo può anche essere eseguito come un "programma" in questo modo:

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

Che è un po 'contorto, ma funziona.

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

Questo è il tipo di sfida che pb è stata creata! Non che sia competitivo per questo tipo di sfida o altro. È ancora un orribile linguaggio da golf. Tuttavia, sfide come questa sono molto meno dolorose da risolvere in pb rispetto ad altre. Poiché pb tratta il suo output come una tela 2D ed è in grado di scrivere su qualsiasi coord, tutto ciò che comporta il posizionamento di testo / disegno attorno al testo (cioè questa sfida) viene gestito in modo piuttosto intuitivo.

Guarda come funziona:

questa visualizzazione è stata creata con una versione in sviluppo di pbi, l'interprete pb. La linea con lo sfondo blu è Y=-1, dove viene memorizzato l'input all'avvio del programma. Il rettangolo con lo sfondo rosso è la posizione corrente del pennello. I rettangoli con sfondi gialli sono ovunque il carattere ascii 32 (uno spazio) è esplicitamente scritto sulla tela. Tutti gli spazi vuoti senza questo sfondo hanno effettivamente il valore 0, che viene convertito in uno spazio.

Ecco il codice con i commenti che ho usato durante la scrittura, con alcune intestazioni di sezione tematicamente rilevanti;)

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

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

Questo è probabilmente golfable. Ci sono alcuni posti in cui non sapevo se sarebbe meglio conservare un valore da qualche parte per riutilizzarlo o rifarlo / andare a prenderlo da qualche altra parte sul nastro. Invece di fare il lavoro per capirlo, non l'ho fatto. : D

Con commenti:

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

Elenca la stringa, aggiungi uno spazio su tutti e quattro i lati di una stringa, quindi aggiungi un ottotorpe a ciascun lato della stringa. In azione:

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

Funziona in OK, Kona e K5.

Esistono alcune varianti all'interno di un carattere di lunghezza che rimuovono la ridondanza in precedenza, ma nessuna sembra spezzarsi anche quando dobbiamo solo eseguire l'operazione di "avvolgimento" due volte:

{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

Grazie alle persone nei commenti che danno suggerimenti su come giocare ulteriormente a golf, davvero non conosco bene la lingua come si può (probabilmente) dire.

Python 3, 88 byte

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

Esempio I / O:

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

Perl, 43 76 byte

Trasforma ogni riga di input di testo come specificato:

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

Per esempio:

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

Ecco come vedere cosa sta realmente facendo:

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

Quindi qualcosa di più simile a questo:

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

JavaScript (ES6), 73

Usando pesantemente la stringa del modello, le 2 nuove linee sono significative e contate.

Prova a eseguire lo snippet di seguito in qualsiasi browser compatibile con EcmaScript 6 (FireFox e l'ultimo Chrome, forse 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>

Questo è piuttosto più breve del mio primo tentativo, derivato da questa altra sfida :

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

Accetta input tra virgolette "Hello World".

• La terza riga è l'ingresso racchiuso # _ #.
• La seconda e la quarta linea b sono # #con il giusto numero di spazi, circondate da nuove linee su entrambi i lati per occuparsi di tutte e quattro le nuove linee.
• La prima e la quinta riga vengono #moltiplicate per la lunghezza dell'input

Le linee sono concatenate e stampate.

MATLAB, 93 91 byte

Non il più bello, ma fa il lavoro.

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

Spiegazione del codice

Passo 1

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

Leggere in una stringa da STDIN e inserire al suo interno uno spazio singolo iniziale e finale. 32 è il codice ASCII per uno spazio e lettura nell'input mentre un tipo di stringa unisce i 32 in spazi.

Passo 2

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

Dichiarare una matrice di caratteri di 5 segni hash in un vettore di colonna.

Passaggio n. 3

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

Crea una matrice di caratteri a 2 righe che viene riempita prima con i segni di hash seguiti da uno spazio bianco. Il numero di caratteri è la lunghezza della stringa di input più 2 in modo che possiamo accomodare per lo spazio prima e dopo la stringa.

Passaggio 4

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

Metteremo tutto insieme. Posizioniamo la prima colonna di 5 hash, seguita dalla parte centrale e seguita da un'altra colonna di 5 hash. La parte centrale è costituita dalla matrice di caratteri a 2 righe creata nel passaggio n. 3, la stringa di input stessa che ha uno spazio di trascinamento e iniziale, seguita dalla matrice di caratteri a 2 righe ma invertita.

Esecuzioni di esempio

>> 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 per -lp(se l'input non termina in una nuova riga, -lpuò essere eliminato per salvare un byte).

Accetta input su STDIN:

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

Come funziona

Il nucleo del programma è una fetta di elenco:

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

Ciò fornisce un modo compatto per memorizzare le tre righe univoche dell'output (le prime due righe del rettangolo di selezione sono le stesse delle ultime due, solo speculari). Per la stringa di input foo, i risultati della sezione sarebbero:

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

Unire questi valori con #\n#ci dà la nostra scatola.

Si noti che Perl 5.14+ è necessario per utilizzare il rmodificatore non distruttivo per l'operatore di traslitterazione y///.

PHP, 95 93 byte

Non esattamente geniale o qualcosa di simile, ma in realtà è stato divertente!

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

Non esattamente carino o niente, ma funziona alla grande!

Grazie a @Titus per aver salvato 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;}

Il mio primo colpo al codegolf, e mentre ho imparato il C ++ non è probabilmente il miglior linguaggio per giocare a golf, mi sono sentito decentemente (?) Per il mio primo tentativo.

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 et rappresentano rispettivamente le linee con hash, l'input (con gli hash su ciascuna estremità) e le linee tra l'input e le linee con hash rispettivamente.

> <> , 106 104 byte

Ho la sensazione che> <> potrebbe non essere la lingua migliore per questo, ma sono arrivato troppo lontano per arrendermi e non pubblicarlo. La *fine della riga 4 dovrebbe essere uno spazio. Non ti piace quanto sia incredibilmente grottesco questo codice? Provalo online .

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

Ecco una versione senza altro che cambia direzione per dare un'idea di come si sposta il puntatore (nota che ho lasciato fuori le istruzioni "teletrasporto", cioè .).

Flusso di direzione:

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

Spiegazione

La mia visualizzazione dello stack si baserà sull'input input. > <> è un linguaggio bidimensionale, quindi presta attenzione a dove si sposta il puntatore tra le righe, poiché esegue il codice sottostante (in questo codice <>v^viene utilizzato principalmente per cambiare direzione). Inizierò le mie spiegazioni da dove inizia il puntatore. Si noti che verranno ripetute due righe, poiché il puntatore si sposta all'indietro dopo la quinta riga.

Quello che trovo sempre interessante su> <> è la sua capacità di modificare il proprio codice sorgente, e lo uso in questo programma. Le righe 3 e 4 vengono riutilizzate per stampare le ultime due righe attraverso una modifica di un carattere in ciascuna.

Riga 1: loop di input

<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

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

Riga 2: genera la terza riga di output

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

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

Riga 3: stampa la prima riga dell'output

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

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

Produzione:

#########

Riga 4: stampa la seconda riga dell'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 "

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

Output ( *rappresenta lo spazio):

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

Riga 5: stampa la terza riga dell'output

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

Pila: [9,9,0]

Produzione:

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

Riga 6: si imposta per stampare la quarta e la quinta riga di output

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

Pila: [0,9,9,0]

Riga 4: stampa la quarta riga dell'output

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

Pila: [0,9,0]

Output ( *rappresenta lo spazio):

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

Riga 3: stampa l'ultima riga dell'output

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

Pila: [0,0]

Produzione:

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

PHP, 93 91 byte

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

Prende input dall'argomento della riga di comando; sfuggire agli spazi o utilizzare virgolette singole. Corri con -r.

Pyke (non competitivo), 6 byte

.X".X#

Provalo qui!

Pyke è stato scritto dopo la sfida ed è quindi non competitivo.

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

.Xprende una stringa e una stringa costante arg e circonda una stringa con quel gruppo di caratteri. L'arg costante può contenere fino a 8 caratteri e avere effetti diversi su come è circondata la stringa.

05AB1E, 26 byte , Non in competizione

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

Provalo online!

EDIT: Woah! Non ho notato che questa è una vecchia sfida! Scusate!

C # - 142 byte (il corpo del metodo è 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 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())

Rubino, 83 byte

Immagino che potrebbe essere ulteriormente giocato a golf, ma dal momento che non c'è ancora una risposta di Ruby, eccolo qui:

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

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

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

test:

(f "This is a test" )

Produzione:

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

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

Versione iniziale:

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

Programma completo con casi di test:

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

Versione Ungolfed

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$