J'ai déjà fait cela en Python, mais il semble que cela pourrait être beaucoup raccourci:

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

Donc, si l'utilisateur tape:

Hello World

Le programme imprime:

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

CJam, 22 20 octets

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

Testez-le ici.

Explication

Comment encapsuler une grille 2D de caractères dans une couche d'espaces (ou tout autre caractère)? Correct: quatre fois, vous ajoutez un espace à chaque ligne, puis faites pivoter la grille de 90 degrés. C'est exactement ce que je fais ici avec huit rotations: quatre pour les espaces, quatre pour #:

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 frappes

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

Suppose que l'entrée est fournie sous la forme d'une seule ligne de texte dans le fichier actuellement ouvert.

Explication:

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

Cela peut également être exécuté comme un "programme" comme ceci:

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

Ce qui est un peu compliqué, mais ça marche.

pb - 89 octets

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

C'est le genre de défi pour lequel pb était fait! Non pas qu'il soit compétitif pour ce genre de défi ou quoi que ce soit. C'est toujours un langage de golf horrible. Cependant, des défis comme celui-ci sont beaucoup moins pénibles à résoudre en pb que d'autres. Étant donné que pb traite sa sortie comme un canevas 2D et est capable d'écrire dans tous les accords, tout ce qui implique le positionnement du texte / dessin autour du texte (c'est-à-dire ce défi) est géré de manière plutôt intuitive.

Regardez-le fonctionner:

Cette visualisation a été créée avec une version en développement de pbi, l'interpréteur pb. La ligne avec le fond bleu est Y=-1, où l'entrée est stockée au démarrage du programme. Le rectangle avec le fond rouge est l'emplacement actuel du pinceau. Les rectangles avec des arrière-plans jaunes sont partout où le caractère ascii 32 (un espace) est explicitement écrit sur la toile. Tous les espaces vides sans ce fond ont en fait la valeur0 , qui est convertie en espace.

Voici le code avec les commentaires que j'ai utilisés lors de son écriture, avec quelques en-têtes de section pertinents sur le plan thématique;)

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

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

C'est probablement golfable. Il y a des endroits où je ne savais pas s'il valait mieux stocker une valeur quelque part pour la réutiliser ou la refaire / aller la chercher ailleurs sur la bande. Au lieu de faire le travail pour le comprendre, je ne l'ai pas fait. :RÉ

Avec commentaires:

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

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

Inscrire la chaîne, ajouter un espace aux quatre côtés d'une chaîne, puis ajouter un octothorpe de chaque côté de la chaîne. En action:

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

Fonctionne en oK, Kona et k5.

Il y a pas mal de variations à l'intérieur d'un caractère de longueur qui suppriment la redondance ci-dessus, mais aucune ne semble briser même lorsque nous n'avons qu'à effectuer deux fois l'opération de "bouclage":

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

Pyth, 31 octets

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

Merci aux gens dans les commentaires qui donnent des conseils sur la façon de jouer au golf, je ne connais vraiment pas bien la langue comme vous pouvez (probablement) le dire.

Python 3, 88 octets

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

Exemple d'E / S:

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

Perl, 43 76 octets

Transformez chaque ligne de saisie de texte comme spécifié:

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

Par exemple:

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

Voici comment voir ce qu'il fait vraiment:

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

Donc quelque chose de plus comme ça:

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

JavaScript (ES6), 73

Utilisant fortement la chaîne de modèle, les 2 nouvelles lignes sont significatives et comptées.

Testez l'exécution de l'extrait ci-dessous dans n'importe quel navigateur compatible EcmaScript 6 (FireFox et dernière version de Chrome, peut-être 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>

C'est beaucoup plus court que mon premier essai, dérivé de cet autre défi :

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

Prend entrée entre guillemets comme "Hello World".

• La troisième ligne est l'entrée encastrée # _ #.
• Les deuxième et quatrième lignes b sont# # avec le bon nombre d'espaces, entourées de nouvelles lignes de chaque côté pour prendre soin des quatre nouvelles lignes.
• Les première et cinquième lignes sont #multipliées par la longueur de l'entrée

Les lignes sont concaténées et imprimées.

MATLAB, 93 91 octets

Pas le plus joli, mais ça fait le travail.

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

Explication du code

Étape 1

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

Lisez une chaîne de STDIN et placez-y un seul espace de début et de fin. 32 est le code ASCII d'un espace et la lecture de l'entrée comme un type de chaîne fusionne les 32 en espaces.

Étape 2

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

Déclarez un tableau de caractères de 5 signes de hachage dans un vecteur de colonne.

Étape 3

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

Créez une matrice de caractères à 2 lignes remplie de signes de hachage en premier, suivie d'un espace blanc après. Le nombre de caractères est la longueur de la chaîne d'entrée plus 2 afin que nous puissions tenir compte de l'espace avant et après la chaîne.

Étape 4

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

Nous allons tout assembler. Nous plaçons la première colonne de 5 hachages, suivie de la partie centrale et suivie d'une autre colonne de 5 hachages. La partie centrale se compose de la matrice de caractères à 2 lignes créée à l'étape # 3, la chaîne d'entrée elle-même qui a un espace de fin et de début, suivie de la matrice de caractères à 2 lignes mais inversée.

Exemples d'exécutions

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

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

54 octets + 2 octets pour -lp(si l'entrée ne se termine pas par une nouvelle ligne, -lpeut être supprimée pour enregistrer un octet).

Accepte les entrées sur STDIN:

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

Comment ça marche

Le cœur du programme est une tranche de liste:

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

Cela fournit un moyen compact de stocker les trois lignes uniques de la sortie (les deux premières lignes du cadre de sélection sont les mêmes que les deux dernières, uniquement en miroir). Pour la chaîne d'entrée foo, les résultats de la tranche seraient:

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

Rejoindre ces valeurs avec #\n#nous donne notre box.

Notez que Perl 5.14+ est requis pour utiliser le rmodificateur non destructif de l'opérateur de translittération y///.

PHP, 95 93 octets

Pas exactement brillant ou quelque chose de similaire, mais c'était vraiment amusant!

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

Pas exactement joli ou quoi que ce soit, mais cela fonctionne à merveille!

Merci à @Titus pour avoir économisé 2 octets.

C ++, 198 octets

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

Mon premier coup de couteau au codegolf, et bien que j'aie appris le C ++ n'est probablement pas le meilleur langage pour le golf, j'ai senti que j'avais fait décemment (?) Pour mon premier essai.

Non golfé

#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 t représentent les lignes entièrement hachées, l'entrée (avec des hachages à chaque extrémité) et les lignes entre l'entrée et les lignes hachées respectivement.

> <> , 106 104 octets

J'ai l'impression que> <> n'est peut-être pas la meilleure langue pour cela, mais je suis allé trop loin pour abandonner et ne pas poster ceci. Le *à la fin de la ligne 4 est censé être un espace. N'aimez-vous pas à quel point ce code est incroyablement grotesque? Essayez-le en ligne .

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

Voici une version sans autre chose que des changeurs de direction pour donner une idée de la façon dont le pointeur se déplace (notez que j'ai omis les instructions "teleport", c'est-à-dire .).

Flux directionnel:

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

Explication

Ma visualisation de la pile sera basée sur l'entrée input. > <> est un langage à deux dimensions, alors faites attention à l'endroit où le pointeur se déplace entre les lignes, car il exécute du code en dessous (dans ce code, il <>v^est principalement utilisé pour changer de direction). Je vais commencer mes explications à partir du point de départ du pointeur. Notez qu'il y aura deux lignes répétées, car le pointeur recule après la cinquième ligne.

Ce que je trouve toujours cool à propos de> <>, c'est sa capacité à modifier son propre code source, et je l'utilise dans ce programme. Les lignes 3 et 4 sont réutilisées pour imprimer les deux dernières lignes via une modification d'un caractère dans chacune.

Ligne 1: boucle d'entrée

<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

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

Ligne 2: génère la troisième ligne de sortie

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

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

Ligne 3: imprime la première ligne de sortie

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

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

Sortie:

#########

Ligne 4: imprime la deuxième ligne de sortie

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

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

Sortie ( *représente l'espace):

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

Ligne 5: imprime la troisième ligne de sortie

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

Empiler: [9,9,0]

Sortie:

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

Ligne 6: se configure pour imprimer les quatrième et cinquième lignes de sortie

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

Empiler: [0,9,9,0]

Ligne 4: imprimer la quatrième ligne de sortie

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

Empiler: [0,9,0]

Sortie ( *représente l'espace):

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

Ligne 3: imprimer la dernière ligne de sortie

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

Empiler: [0,0]

Sortie:

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

PHP, 93 91 octets

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

Prend l'entrée de l'argument de ligne de commande; échapper aux espaces ou utiliser des guillemets simples. Courez avec -r.

Pyke (non compétitif), 6 octets

.X".X#

Essayez-le ici!

Pyke a été écrit après le challenge et n'est donc pas compétitif.

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

.Xprend une chaîne et une chaîne constante arg et entoure une chaîne avec ce groupe de caractères. L'argument constant peut contenir jusqu'à 8 caractères et avoir différents effets sur la façon dont la chaîne est entourée.

05AB1E, 26 octets , pas en compétition

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

Essayez-le en ligne!

EDIT: Woah! Je n'ai pas remarqué qu'il s'agit d'un vieux défi! Désolé!

C # - 142 octets (le corps de la méthode est 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));}}

Non golfé:

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 octets

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

Lua, 90 octets

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

Rubis, 83 octets

Je suppose que cela pourrait être joué plus loin, mais comme il n'y a pas encore de réponse Ruby, la voici:

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

Raquette 172 octets

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

Non golfé:

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

Essai:

(f "This is a test" )

Sortie:

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

C #, 116 110 octets

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

Non golfé:

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

Version initiale:

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

Programme complet avec cas de 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 octets

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

Version non golfée

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 octets

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