Bunu zaten Python'da yaptım, fakat çok kısalmış gibi görünüyor:

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

Yani kullanıcı yazıyorsa:

Hello World

Program yazdırıyor:

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

CJam, 22 20 bayt

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

Burada test et.

açıklama

Bir 2B karakter ızgarasını bir boşluk katmanına (veya başka bir karaktere) nasıl sarın? Doğru: dört kez, her satıra bir boşluk ekler ve sonra ızgarayı 90 derece döndürürsünüz. Bu tam olarak burada sekiz rotasyonla yapıyorum: dört boşluk için, dört için #:

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 tuş vuruşlarını

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

Girişin açık dosyada tek bir metin satırı olarak sağlandığını varsayar.

Açıklama:

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

Bu aynı zamanda böyle bir "program" olarak da çalıştırılabilir:

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

Bu biraz sarsılmış ama işe yarıyor.

pb - 89 bayt

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

Bu, pb'nin yaptığı türden bir mücadele! Bu tür bir meydan okuma ya da başka bir şey için rekabetçi olması değil . Hala korkunç bir golf dili. Ancak, bunun gibi zorluklar, pb'de çözülecek bir acıdan diğerlerine göre çok daha azdır. Pb çıktısını 2B tuval olarak kabul ettiğinden ve herhangi bir kod yazabildiğinden, metin etrafına metin çizmeyi / çizmeyi (yani bu zorluğu) sezgisel olarak ele alır.

Çalıştırılmasını izleyin:

Bu görselleştirme, pb yorumlayıcısı pbi'nin geliştirme sürümü ile oluşturuldu. Mavi arkaplanlı çizgi Y=-1, program başladığında girişin depolandığı yerdir. Kırmızı arka plana sahip olan dikdörtgen, fırçanın geçerli konumudur. Sarı arka plana sahip dikdörtgenler, ascii karakter 32'nin (boşluk) tuvalin üzerine açıkça yazıldığı yerlerdedir. Bu arkaplanı olmayan tüm boşluklar aslında 0bir alana dönüştürülen değere sahiptir.

İşte yazarken kullandığım yorumların kodu, tematik olarak ilgili bölüm başlıklarıyla birlikte;)

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

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

Bu muhtemelen golf oynamaktadır. Yeniden kullanmak için bir yerde bir değeri saklamanın ya da yeniden düzenlemenin / bantın başka bir yerinden almanın daha iyi olacağını bilmediğim bazı yerler var. Bunu çözmek için işi yapmak yerine, yapmadım. : D

Yorumlarla:

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

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

Dizgiyi sıralayın, dizginin dört tarafına da bir boşluk ekleyin, ardından dizginin her tarafına bir sekizgen ekleyin. Eylemde:

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

OK, Kona ve k5'te çalışır.

Uzunluğun bir karakteri içinde yukarıdaki fazlalığı ortadan kaldıran oldukça az sayıda varyasyon vardır, ancak yalnızca "sarma" işlemini iki kez gerçekleştirmemiz gerektiğinde bile hiçbiri kırılmıyor gibi görünmektedir:

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

Pyth, 31 bayt

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

Nasıl daha fazla golf oynamanın ipuçlarını veren yorum yapan insanlar sayesinde, dili (muhtemelen) söyleyebileceğin kadar iyi tanımıyorum.

Python 3, 88 bayt

Teşekkürler @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)

Örnek G / Ç:

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

Perl, 43 76 bayt

Her bir metin giriş satırını belirtilen şekilde dönüştürün:

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

Örneğin:

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

İşte gerçekte ne yaptığını görmenin yolu:

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

Yani böyle bir şey daha:

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

JavaScript (ES6), 73

Ağır dizge kullanarak, 2 yeni satırlar önemli ve sayılır.

Aşağıdaki snippet'i herhangi bir EcmaScript 6 uyumlu tarayıcıda çalıştırmayı test edin (FireFox ve en yeni Chrome, belki 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>

Bu benim ilk denememden çok daha kısa, bu diğer zorluğa dayanıyor :

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

Gibi tırnak içinde girdi alır "Hello World".

• Üçüncü satır, içine alınmış girdidir # _ #.
• İkinci ve dördüncü satırlar b , dört hattın # #tamamının üstesinden gelmek için her iki tarafa da yeni çizgilerle çevrili, doğru sayıda boşluktadır.
• İlk ve beşinci satırlar #girişin uzunluğu ile çarpılır.

Satırlar birleştirilir ve yazdırılır.

MATLAB, 93 91 bayt

Güzel değil, ama işi halleder.

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

Kod Açıklaması

Aşama 1

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

STDIN'den bir dize okuyun ve içine bir satır önde gelen ve sondaki tek bir boşluk koyun. 32, bir boşluk için ASCII kodudur ve girdideki bir dize türü olarak okuma 32'leri boşluklara birleştirir.

Adım 2

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

Bir sütun vektöründe 5 karma işaretli bir karakter dizisi bildirin.

Aşama 3

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

Önce, ardından beyaz boşluktan sonra karma işaretleri ile doldurulmuş 2 satırlık bir karakter matrisi oluşturun. Karakter sayısı, giriş dizgisinin uzunluğu artı 2'dir, böylece dizgiden önceki ve sonraki boşluğa uyum sağlayabiliriz.

4. Adım

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

Her şeyi bir araya getireceğiz. İlk 5 sütunu, ardından orta kısmı ve 5 sütunu takip eden bir sütunu yerleştiririz. Merkez kısım Adım 3'te oluşturulan 2 sıra karakterli matristen oluşur; giriş dizisinin kendisi izleyen ve baştaki bir alana sahiptir, ardından 2 sıra karakterli matris gelir, ancak tersine çevrilir.

Örnek Çalıştırmalar

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

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

54 bayt + 2 bayt -lp(giriş yeni bir satırda bitmezse, -lbir bayttan tasarruf etmek için bırakılabilir).

STDIN'de girişi kabul eder:

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

Nasıl çalışır

Programın özü bir liste dilimidir:

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

Bu, çıkışın üç benzersiz sırasını saklamak için kompakt bir yol sağlar (sınırlama kutusunun ilk iki sırası, yalnızca yansıtılan son iki ile aynıdır). Giriş dizesi fooiçin dilimin sonuçları şöyle olur:

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

Bu değerlerle birleştirmek #\n#bize bizim kutumuzu verir.

Harf çevirici olmayan rdeğiştiriciyi harf çevirisi operatörüne kullanmak için Perl 5.14+ sürümünün gerekli olduğunu unutmayın y///.

PHP, 95 93 bayt

Tam olarak parlak değil ya da benzer bir şey değil, ama aslında eğlenceliydi!

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

Tam olarak değil ya da hiçbir şey, ama zekice çalışıyor!

2 bayt tasarrufu için @Titus'a teşekkürler .

C ++, 198 Bayt

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

Codegolf'taki ilk bıçaklığım ve C ++ 'ın golf oynamak için en iyi dil olmadığını öğrendiğimde, ilk denemem için terbiyeli bir şekilde (?) Yaptığımı hissettim.

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 ve t, tamamen karma çizgileri, girişi (her bir ucunda karma olan) ve sırasıyla girdi ve karma çizgileri arasındaki çizgileri temsil eder.

> <> , 106 104 Bayt

Bunun için <>> en iyi dil olamayacağı hissine kapılıyorum, ancak bunu bırakıp bırakmamak için çok ileri geldim. *4. satırda sonunda bir boşluk olması gerekiyordu. Bu kodun ne kadar garip göründüğünü sevmiyor musun? Çevrimiçi deneyin .

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

İşte işaretçinin nasıl hareket ettiği hakkında bir fikir vermek için yön değiştirici dışında hiçbir şey olmayan bir sürüm ("teleport" ifadelerini, yani bıraktığımı unutmayın .).

Yön akışı:

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

açıklama

Yığının görselleştirilmesi girdiden kaynaklanacaktır input. > <> iki boyutlu bir dildir, bu nedenle işaretçinin altında kod yürütürken işaretçinin satırlar arasında nereye hareket ettiğine dikkat edin (bu kodda <>v^öncelikle yönü değiştirmek için kullanılır). Açıklamalarımı işaretçinin başladığı yerden başlayacağım. İşaretçi beşinci satırdan sonra geriye doğru hareket ettiğinden, iki satırın tekrarlanacağına dikkat edin.

Her zaman harika bulduğum şey> <> kendi kaynak kodunu değiştirebilme yeteneğidir ve bu programda bunu kullanıyorum. Satır 3 ve 4, her biri bir karakterin modifikasyonu yoluyla son iki satırı yazdırmak için yeniden kullanılır.

Satır 1: Giriş döngüsü

<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

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

Satır 2: Üçüncü satır çıktı üretir

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

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

Satır 3: İlk çıktı satırını yazdırır

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

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

Çıktı:

#########

Satır 4: İkinci çıktı satırını yazdırır

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

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

Çıktı ( *boşluğu temsil eder):

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

Satır 5: Üçüncü çıktı satırını yazdırır

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

Stack: [9,9,0]

Çıktı:

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

Satır 6: Dördüncü ve beşinci çıktı satırlarını yazdırmak için kendini ayarlar

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

Stack: [0,9,9,0]

Satır 4: Dördüncü çıktı satırını yazdır

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

Stack: [0,9,0]

Çıktı ( *boşluğu temsil eder):

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

Satır 3: Çıktının son satırını yazdır

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

Stack: [0,0]

Çıktı:

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

PHP, 93 91 bayt

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

Komut satırı argümanından girdi alır; boşluklardan kaçın veya tek tırnak kullanın. İle koş -r.

Pyke (rekabetçi olmayan), 6 bayt

.X".X#

Burada dene!

Pyke mücadeleden sonra yazılmıştı ve bu yüzden rekabetçi değil.

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

.Xbir dize ve bir sabit argüman alır ve o karakter grubuyla bir dize çevreler. Sabit argüman 8 karaktere kadar olabilir ve dizenin çevrelenme şekli üzerinde farklı etkiler yapabilir.

05AB1E, 26 bayt , Rekabet etmiyor

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

Çevrimiçi deneyin!

EDIT: Vay canına! Bunun eski bir meydan okuma olduğunu fark etmedim! Üzgünüm!

142 bayt (yöntem gövdesi 104'tür)

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 bayt

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

Lua, 90 bayt

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 bayt

Sanırım daha fazla golf oynayabilirdi, ama henüz Ruby cevabı olmadığından, işte burada:

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

Raket 172 bayt

(λ(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 yapmak:

(f "This is a test" )

Çıktı:

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

C #, 116 110 bayt

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

İlk versiyon:

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

Test vakaları ile tam program:

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 bayt

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 versiyonu

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 bayt

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