ฉันได้ทำสิ่งนี้ใน Python แล้ว แต่ดูเหมือนว่ามันจะสั้นลงมาก:

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.

เป็นกลุ่ม, 28 27 keystrokes

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 ปฏิบัติต่อผลงานเป็นผืนผ้าใบ 2 มิติและสามารถเขียนไปยัง coords ใด ๆ สิ่งที่เกี่ยวข้องกับการวางตำแหน่งข้อความ / การวาดรอบข้อความ (เช่นความท้าทายนี้) ได้รับการจัดการค่อนข้างสังหรณ์ใจ

ดูมันทำงาน: การ

สร้างภาพข้อมูลนี้สร้างขึ้นด้วยรุ่น pbi ซึ่งเป็นล่าม pb บรรทัดที่มีพื้นหลังสีน้ำเงินคือ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 ไบต์

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

นี่น่าจะเป็นสนามกอล์ฟ มีบางสถานที่ที่ฉันไม่รู้ว่ามันจะเป็นการดีกว่าถ้าจะเก็บค่าไว้ที่อื่นเพื่อนำมาใช้ใหม่หรือนำกลับมาใช้ใหม่ / ไปรับจากที่อื่นบนเทป แทนที่จะทำเพื่อคิดออกฉันไม่ได้ทำอย่างนั้น : D

ด้วยความคิดเห็น:

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

เข้าร่วมสตริงเพิ่มช่องว่างทั้งสี่ด้านของสตริงจากนั้นเพิ่ม octothorpe ไปยังแต่ละด้านของสตริง ในการดำเนินการ:

  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

ขอบคุณผู้คนในความคิดเห็นที่ให้คำแนะนำเกี่ยวกับวิธีการตีกอล์ฟต่อไปฉันไม่รู้ภาษาที่ดีเท่าที่คุณจะบอกได้

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

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

JavaScript (ES6), 73

การใช้สตริงแม่แบบอย่างหนักบรรทัดใหม่ 2 บรรทัดนั้นมีความสำคัญและนับ

ทดสอบการเรียกใช้ข้อมูลโค้ดด้านล่างในเบราว์เซอร์ที่สอดคล้องกับ 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`

Python 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 สำหรับช่องว่างและการอ่านในอินพุตเป็นชนิดสตริงรวมกันเป็น 32s ลงในช่องว่าง

ขั้นตอนที่ 2

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

ประกาศอาร์เรย์อักขระที่มี 5 สัญญาณแฮชในเวกเตอร์คอลัมน์

ขั้นตอนที่ # 3

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

สร้างเมทริกซ์อักขระ 2 แถวที่เต็มไปด้วยสัญญาณแฮชก่อนตามด้วยช่องว่างสีขาวด้านหลัง จำนวนอักขระคือความยาวของสตริงอินพุตบวก 2 เพื่อให้เราสามารถรองรับพื้นที่ก่อนและหลังสตริง

ขั้นตอนที่ # 4

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

เราจะรวมทุกอย่างเข้าด้วยกัน เราวางคอลัมน์แรกของ 5 แฮชแล้วตามด้วยส่วนตรงกลางและตามด้วยคอลัมน์อีก 5 แฮช ส่วนตรงกลางประกอบด้วยเมทริกซ์อักขระ 2 แถวที่สร้างขึ้นในขั้นตอนที่ 3 สตริงอินพุตของตัวเองซึ่งมีพื้นที่ต่อท้ายและนำหน้าตามด้วยเมทริกซ์อักขระ 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(หากอินพุตไม่สิ้นสุดในบรรทัดใหม่-lสามารถดร็อปเพื่อบันทึกหนึ่งไบต์)

ยอมรับอินพุตบน STDIN:

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

มันทำงานอย่างไร

แกนหลักของโปรแกรมคือ list slice:

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

นี่เป็นวิธีที่กะทัดรัดในการจัดเก็บแถวที่ไม่ซ้ำกันสามแถวของเอาต์พุต สำหรับสตริงอินพุตfooผลลัพธ์ของการแบ่งจะเป็น:

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

การเข้าร่วมค่าเหล่านี้ด้วย#\n#ทำให้เรามีกล่องของเรา

โปรดทราบว่า Perl 5.14+ จะต้องใช้แบบไม่ทำลายปรับปรุงไปยังผู้ประกอบการทับศัพท์ry///

PHP, 95 93 ไบต์

ไม่สดใสหรืออะไรที่คล้ายกัน แต่จริงๆแล้วมันสนุก!

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

ไม่ว่าสวยหรืออะไร แต่ทำงานได้ยอดเยี่ยม!

ขอบคุณ@Titusสำหรับการบันทึก 2 ไบต์

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 ++ อาจไม่ใช่ภาษาที่ดีที่สุดสำหรับการเล่นกอล์ฟ

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 และ 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การสร้างภาพของฉันของสแต็คจะตามออกของการป้อนข้อมูล > <> เป็นภาษาสองมิติดังนั้นโปรดสังเกตว่าตัวชี้กำลังเคลื่อนที่ระหว่างบรรทัดใดขณะที่มันรันโค้ดที่อยู่ด้านล่าง (ในรหัส<>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:ตั้งค่าตัวเองเพื่อพิมพ์บรรทัดที่สี่และห้า

.>";^"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:พิมพ์เอาต์พุตบรรทัดที่สี่

"-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ทำงานด้วย

Pyke (ไม่สามารถแข่งขันได้), 6 ไบต์

.X".X#

ลองที่นี่!

Pyke เขียนขึ้นหลังจากการท้าทายดังนั้นจึงไม่สามารถแข่งขันได้

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

.Xรับค่าสตริงและค่าคงที่สตริง arg และล้อมรอบสตริงด้วยกลุ่มของอักขระนั้น ARG คงที่สามารถมีความยาวได้สูงสุด 8 ตัวอักษรและมีเอฟเฟกต์ที่แตกต่างกันเกี่ยวกับการล้อมรอบสตริง

05AB1E, 26 ไบต์ , ไม่ใช่การแข่งขัน

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

ลองออนไลน์!

แก้ไข: ว้าว! ไม่ได้สังเกตว่านี่เป็นการท้าทายครั้งเก่า! ขออภัย!

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

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 ไบต์

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

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

Ruby, 83 ไบต์

ฉันคิดว่ามันน่าจะเล่นกอล์ฟต่อไปได้ แต่เนื่องจากยังไม่มีคำตอบสำหรับ Ruby นี่คือ:

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

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

การทดสอบ:

(f "This is a test" )

เอาท์พุท:

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

C #, 116 110 ไบต์

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

รุ่นเริ่มต้น:

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$