나는 이미 이것을 파이썬으로 만들었지 만 많이 단축 될 수있는 것 같습니다.

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

사용자가 다음을 입력하면

Hello World

이 프로그램은 다음을 인쇄합니다.

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

CJam, 22 20 바이트

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

여기에서 테스트하십시오.

설명

한 레이어의 공백 (또는 다른 문자)으로 2D 문자 격자를 어떻게 감쌀 수 있습니까? 올바른 : 네 번, 각 줄에 공백을 추가 한 다음 격자를 90도 회전시킵니다. 그것이 내가 여덟 번의 회전으로 정확하게하고있는 일입니다 #.

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 번의 키 스트로크

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

입력이 현재 열려있는 파일에서 한 줄의 텍스트로 제공된다고 가정합니다.

설명:

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

다음과 같이 "프로그램"으로 실행할 수도 있습니다.

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

조금 복잡하지만 작동합니다.

pb -89 바이트

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

이것은 pb가 도전 한 종류입니다! 그것이 이런 종류의 도전이나 다른 것에 경쟁적이지 는 않습니다 . 여전히 끔찍한 골프 언어입니다. 그러나 이와 같은 도전은 다른 사람들보다 pb에서 해결해야 할 고통이 훨씬 적습니다. pb는 출력을 2D 캔버스로 취급하고 모든 좌표에 쓸 수 있기 때문에 텍스트 주위에 텍스트 배치 / 그리기 (즉,이 문제)가 직관적으로 처리됩니다.

실행보기 :

이 시각화는 pb 인터프리터 인 pbi의 개발 버전으로 만들어졌습니다. 파란색 배경의 줄 Y=-1은입니다. 프로그램이 시작될 때 입력이 저장됩니다. 빨간색 배경의 사각형은 브러시의 현재 위치입니다. 배경이 노란색 인 사각형은 ASCII 문자 32 (공백)가 캔버스에 명시 적으로 쓰여지는 곳입니다. 이 배경이없는 빈 공간에는 실제로 값이 0있으며 이는 공백으로 변환됩니다.

다음은 주제별로 관련된 섹션 헤더와 함께 작성하는 동안 사용한 주석이있는 코드입니다.)

################################
#                              #
# 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 바이트

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

이것은 아마도 골프입니다. 재사용을 위해 어딘가에 값을 저장하거나 테이프의 다른 곳에서 가져 오는 것이 더 좋은지 알 수없는 곳이 있습니다. 알아 내기 위해 노력하는 대신 나는 그렇게하지 않았습니다. :디

의견으로 :

++++++++++>              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 바이트

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

현을 입대하고, 현의 사면 모두에 공간을 추가 한 다음, 현의 각면에 옥토 프를 추가하십시오. 실제로 :

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

ok, kona 및 k5에서 작동합니다.

위의 중복성을 제거하는 길이의 한 문자 내에서 약간의 변형이 있지만 "랩"조작을 두 번만 수행해도 파손되지 않는 것 같습니다.

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

Pyth, 31 바이트

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

골프를 치는 방법에 대한 힌트를주는 의견을 가진 사람들 덕분에 나는 당신이 (아마도) 말할 수있는 언어를 잘 모릅니다.

파이썬 3, 88 바이트

감사합니다 @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)

예제 I / O :

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

펄, 43 76 바이트

지정된대로 각 텍스트 입력 행을 변환하십시오.

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

예를 들면 다음과 같습니다.

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

실제로 수행중인 작업을 확인하는 방법은 다음과 같습니다.

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

따라서 이와 같은 것이 더 있습니다 :

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

자바 스크립트 (ES6), 73

템플릿 문자열을 많이 사용하면 두 줄 바꿈이 중요하고 계산됩니다.

EcmaScript 6 호환 브라우저 (FireFox 및 최신 Chrome, 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>

이것은 다른 도전 에서 파생 된 첫 번째 시도보다 상당히 짧습니다 .

f=s=>(q=(c,b,z=c.repeat(b[0].length))=>[z,...b,z].map(r=>c+r+c))('*',q(' ',[s])).join`\n`

파이썬 2, 74

s='# %s #'%input()
n=len(s)
b='\n#'+' '*(n-2)+'#\n'
print'#'*n+b+s+b+'#'*n

와 같은 따옴표로 입력을 "Hello World"받습니다.

• 세 번째 줄은에 포함 된 입력입니다 # _ #.
• 두 번째와 네 번째 줄 b 에는 # #올바른 수의 공간 이 있으며 네 줄 바꿈을 처리하기 위해 양쪽에 줄 바꿈이 있습니다.
• 첫 번째와 다섯 번째 줄은 #입력 길이에 곱해집니다

선이 연결되어 인쇄됩니다.

MATLAB, 93 91 바이트

가장 예쁘지는 않지만 일을 마칩니다.

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

코드 설명

1 단계

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

STDIN에서 문자열을 읽고 그 안에 선행 및 후행 단일 공간을 배치하십시오. 32는 공백에 대한 ASCII 코드이며 문자열 유형으로 입력을 읽으면 32를 공백으로 통합합니다.

2 단계

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

열 벡터에 5 개의 해시 기호로 구성된 문자형 배열을 선언합니다.

3 단계

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

먼저 해시 기호로 채워진 다음에 공백으로 채워지는 2 행 문자 행렬을 만듭니다. 문자 수는 입력 문자열의 길이에 2를 더한 값이므로 문자열 앞뒤에 공백을 넣을 수 있습니다.

4 단계

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

우리는 모든 것을 하나로 모을 것입니다. 5 개의 해시의 첫 번째 열, 중앙 부분 및 5 개의 해시의 다른 열을 배치합니다. 가운데 부분은 3 단계에서 생성 된 2 행 문자 행렬로 구성되며, 입력 문자열 자체는 후행 및 선행 공백이 있고 그 뒤에 2 행 문자 행렬이 뒤 따릅니다.

예제 실행

>> 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 바이트

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

54 바이트 + 2 바이트 -lp(입력이 줄 바꿈으로 끝나지 않으면 -l1 바이트를 저장하기 위해 삭제 될 수 있음).

STDIN에서 입력을 승인합니다.

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

작동 원리

프로그램의 핵심은 목록 조각입니다.

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

이것은 출력의 3 개의 고유 한 행을 저장하는 간단한 방법을 제공합니다 (경계 상자의 처음 2 개 행은 마지막 2 개 행과 동일하며 미러링 만 됨). 입력 문자열 foo의 경우 슬라이스 결과는 다음과 같습니다.

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

이 값들을 #\n#합치면 우리에게 상자가 생깁니다.

r음역 연산자에 비파괴 수정자를 사용하려면 Perl 5.14+가 필요합니다 y///.

PHP, 95 93 바이트

정확히 훌륭하거나 비슷한 것은 아니지만 실제로는 재미있었습니다!

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

정확하게 예쁘거나 아무것도 아니지만, 훌륭하게 작동합니다!

2 바이트를 절약 해 준 @Titus 에게 감사 합니다.

C ++, 198 바이트

#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에서의 첫 찌르기, 그리고 C ++이 골프에 가장 적합한 언어는 아니라는 것을 알면서도 첫 시도에서 괜찮은 일이라고 느꼈습니다.

언 골프

#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 및 t는 완전 해시 라인, 입력 (각 끝에 해시 포함) 및 입력과 해시 라인 사이의 라인을 각각 나타냅니다.

> <> , 106 104 바이트

> <>이 (가)이 언어에 가장 적합한 언어가 아닐 수도 있지만 포기하지 않고 게시하지 않았습니다. *4 행의 끝 부분은 공간이 될 예정이다. 이 코드가 얼마나 놀랍도록 괴상한 지 좋아하지 않습니까? 온라인으로 사용해보십시오 .

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

다음은 포인터가 어떻게 움직이는 지에 대한 아이디어를 제공하는 방향 전환기 이외의 버전입니다 (예 : "teleport"문을 생략했습니다. . ).

방향 흐름 :

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

설명

스택의 시각화는 입력을 기반으로합니다. input . > <>는 2 차원 언어이므로, 아래 코드를 실행할 때 포인터가 행 사이를 이동하는 위치에주의하십시오 (이 코드에서<>v^ 에서 주로 방향을 변경하는 데 사용됨). 포인터가 시작되는 위치에서 설명을 시작하겠습니다. 포인터가 다섯 번째 줄 다음으로 뒤로 이동함에 따라 두 개의 줄이 반복됩니다.

>>에 대해 항상 멋진 점은 자체 소스 코드를 수정하는 기능이며이 프로그램에서이를 사용합니다. 3 행과 4 행은 각각의 문자를 수정하여 마지막 두 행을 인쇄하기 위해 재사용됩니다.

라인 1 : 입력 루프

<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

스택: [-1,t,u,p,n,i]

라인 2 : 출력의 세 번째 라인을 생성합니다

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

스택: [9,9,9,9,#, ,t,u,p,n,i, ,#]

3 행 : 출력의 첫 번째 행을 인쇄합니다

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

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

산출:

#########

라인 4 : 출력의 두 번째 라인을 인쇄합니다

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

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

출력 ( *공간을 나타냄) :

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

라인 5 : 출력의 세 번째 라인을 인쇄합니다

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

스택: [9,9,0]

산출:

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

6 행 : 출력의 4 번째 및 5 번째 행을 인쇄하도록 자체 설정

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

스택: [0,9,9,0]

4 행 : 출력의 4 행 인쇄

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

스택: [0,9,0]

출력 ( *공간을 나타냄) :

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

3 행 : 최종 출력 행 인쇄

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

스택: [0,0]

산출:

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

PHP, 93 91 바이트

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

명령 행 인수에서 입력을받습니다. 공백을 피하거나 작은 따옴표를 사용하십시오. 로 실행하십시오 -r.

파이크 (비경쟁), 6 바이트

.X".X#

여기 사용해보십시오!

파이크는 도전 이후에 작성되었으므로 비 경쟁적입니다.

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

.X문자열과 문자열 상수 인수를 취하여 해당 문자 그룹으로 문자열을 둘러 쌉니다. 상수 arg는 최대 8 자이며 문자열을 둘러싸는 방식에 다른 영향을 미칩니다.

05AB1E, 26 바이트 , 경쟁하지 않음

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

온라인으로 사용해보십시오!

편집 : 와우! 이것은 오래된 challange임을 알지 못했습니다! 죄송합니다!

C #-142 바이트 (메소드 본문은 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));}}

언 골프 드 :

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 바이트

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

루아, 90 바이트

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

루비, 83 바이트

추가로 골프를 칠 수는 있지만 루비 답변이 없으므로 여기에 있습니다.

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

라켓 172 바이트

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

언 골프 드 :

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

테스트 :

(f "This is a test" )

산출:

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

C #, 116110 바이트

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

언 골프 드 :

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

초기 버전 :

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

테스트 케이스가 포함 된 전체 프로그램 :

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 바이트

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

언 골프 버전

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 바이트

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