I've already made this in Python, but it seems that it could be shortened a lot:
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))
So if the user types:
Hello World
The program prints:
###############
# #
# Hello World #
# #
###############
N, 16 bytesðṛ[l'#×;lṣ;]'#ṛⱮ
ðṛ[l'#×;lṣ;]'#ṛⱮ # Implicit input
ðṛ # Surround by spaces
[ ; ;] # Apply parallelly, and wrap into a list:
l'#× '# [0] length * "#"
lṣ # [1] length * " "
# [2] leave TOS
'#ṛ '# Surround each by "#"s
Ɱ # Palindromise the list
$l=$input.length+4;$p='#'*$l;$s=' '*$l;$p,$s," $input ",$s,$p-replace'^ | $','#'
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())
(λ(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) #\#)
))))
Testing:
(f "This is a test" )
Output:
##################
# #
# This is a test #
# #
##################
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
};
Initial version:
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;};
Full program with test cases:
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"));
}
}
}
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 version
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("");
}
LINPUT S$L=LEN(S$)+2O$="#"+" "*L+"#
T$="#"*(L+2)?T$?O$?"# ";S$;" #
?O$?T$
lambda x:("###### %s ######\n\n\n\n"%' ## '.join(f" {x} ")*5)[::5]
print(("###### %s ######\n\n\n\n"%' ## '.join(f" {input()} ")*5)[::5])
\$\endgroup\$
(\#{#~1+4})(\n# {#~1+2}#\n)# $~1 #$2$1
Takes the string as a command-line argument. Try it here!
Spaces are replaced by underscores so they're easier to see.
( ) Group 1: top row
\# A literal hash character
{ } repeated
#~1 len(input)
+4 + 4 times
( ) Group 2: second row (plus newlines)
\n# Newline followed by hash
_{ } followed by space repeated
#~1+2 len(input) + 2 times
#\n followed by hash and another newline
Middle row:
#_ Hash followed by space
$~1 followed by input
_# followed by space and another hash
Final two rows:
$2 Group 2 again
$1 Group 1 again
s=input()
n=len(s)+2
v='#'*n+'##\n#'+' '*n+'#\n#'
print(v,s,v[::-1])
i->{int l=i.length()+2;return "#".repeat(l+2)+"\n#"+" ".repeat(l)+"#\n# "+i+" #\n#"+" ".repeat(l)+"#\n"+"#".repeat(l+2);}
return
\$\endgroup\$
Commented
Jan 16, 2023 at 15:41
j, 112 bitsv2, 14 bytesL⇧‛# •½pøĊ\#vø.∞
I know I said I love parallel apply, but I didn't actually need it here lol.
L⇧‛# •½pøĊ\#vø.∞
‛# • # Repeat each character in the string "# "
L⇧ # (len input) + 2 times
½ # Split into two halves - a string of #s and spaces
p # Prepend the input
øĊ # And horizontally centre so that the input has enough spacing on both sides
\#vø. # Prepend and append "#" to each string
∞ # And mirror it, not mirroring the centre item
# The j flag joins on newlines
💎
Created with the help of Luminespire.
