Python 2, 97 96 90 84 bytes

def f(s,c):r=range(len(s));return[c.join(c*i+s[:i:-1]+s[i:]+c*i)for i in r[:0:-1]+r]

Try it online!

05AB1E, 15 11 bytes

.sûsζøsýí€û

Try it online!
or as a Test Suite

Explanation

.s            # push suffixes of input

  û           # palendromize this list

   sζ         # transpose using the second input as filler

     ø        # transpose back

      sý      # merge each on the second input

        í     # reverse each row

         €û   # palendromize each row

J, 59 56 bytes

,{~[:((0-2*#)}.[:,0,:"0({:>:t)*t=:]+/<:)[:(|.@}.,])#@]

Try it online!

Too long solution for J ... (entirely my fault)

R, an ugly 118 bytes version

By letting the input be a vector of single characters, and outputting a matrix instead of printing nice ascii art.

function(s,C,l=length(s),L=4*l-3,k=2*l-1,y=abs(rep(1:k,L)-l)+abs(rep(1:L,e=k)-k)/2+1)matrix(ifelse(y%%1|y>l,C,s[y]),k)

Try it online!

R, 161 157 bytes

saved 4 bytes by using ifelse instead of conditionally modifying y

function(S,C,l=nchar(S),L=4*l-3,k=2*l-1,y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1)cat(rbind(matrix(ifelse(y%%1|y>l,C,el(strsplit(S,''))[y]),L),'

'),sep='')

Try it online!

ungolfed and commented

function(S,C){

    s=el(strsplit(S,''))

    l=nchar(S)

    L=4*l-3

    k=2*l-1

    y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1 # distance from centre

    y[!!y%%1]=l+1  # set non integers to one more than length of string

    y[y>l]=l+1     # set number beyond length of string to one more than length of string

    M = rbind(matrix(c(s,C)[y],L),'n') # build matrix and add line returns

    cat(M,sep='') # print the matrix as a string

}

hmmm, seems like the longest answer so far!

R, 118 95 92 bytes

function(a,d,n=length(a),I=c(n:1,1:n)[-n])for(i in I-1)write(c(a,d)[pmin(I+i,n+1)],1,n*2,,d)

Try it online!

Thanks to:

• Giuseppe for fixing an error and a golf


• Aaron Hayman for 22 bytes worth of golf

Japt, 15 bytes

Returns an array of lines

Ôå+ ®¬qV êÃûV ê

Try it

Ôå+ ®¬qV êÃûV ê     :Implicit input of strings U=s & V=c

Ô                   :Reverse U

 å+                 :Prefixes

    ®               :Map

     ¬              :  Split

      qV            :  Join with V

         ê          :  Palindromise

          Ã         :End map

           ûV       :Centre pad each string with V, to the length of the longest

              ê     :Palindromise

Charcoal, 15 bytes

ＵＢηＥθ✂θκ‖Ｏ↑←ＵＥ¹

Try it online! Link is to verbose version of code. Originally submitted as a comment on the now deleted sandbox post. Explanation:

ＵＢη

Set the background to the second input c.

Ｅθ✂θκ

Map over the first input s to generate all suffixes and implicitly print them on separate lines.

‖Ｏ↑←

Reflect horizontally and vertically.

ＵＥ¹

Add extra space horizontally.

K (ngn/k), 38 bytes

{1_',/'y,''2{+x,1_|x}/(#x)'1_,/+y,'|x}

Try it online!

J, 35 34 33 bytes

,{~1j1(}:@#"1{:(<*-)1-|+/|)i:@-&#

Try it online!

Many thanks to Galen Ivanov for the algorithm.

Ruby, 95 84 75 bytes

->a,c{(1...2*z=a.size).map{|i|s=a[j=(z-i).abs,z]*c+c*2*j;s.reverse.chop+s}}

Try it online!

Takes input string as an array of chars. Returns an array of strings.

Wolfram Language (Mathematica), 121 bytes

Join[q=Table[(v=Table[#2,2(l-k)])<>Riffle[Join[(h=Reverse)[n=(g=Take)[#,-k]],g[n,-k+1]],#2]<>v,{k,l=Length@#}],Rest@h@q]&

Try it online!

Japt, 16 bytes

Note: I'll golf it :)

Ôå+ ®¬qVÃùV mê ê

Try it online!

PowerShell, 120 bytes

param($s,$c)($s,(($l=$s.length-1)..0+1..$l|%{($x=$c*(2*$_))+($s[($_,($l..$_+($_+1)..$l))[$_-ne$l]]-join$c)+$x}))[$l-gt0]

Try it online!

Some days, having index ranges instead of slices really hurts. Today is one of those days. Due to conjoined ranges messing up when dealing with single elements (e.g. returning 0..0+1..0), special-casing is used to avoid it altogether (at the cost of many bytes).

Japt, 15 bytes

Ôå+ ê ®ê ¬qV

ûV

Try it

Jelly, 11 bytes

jÐƤṚzṚŒḄZŒḄ

Try it online!

Left argument: $s$.

Right argument: $c$ (as a single character, not as a string).

Output: List of Jelly strings (appears as a list of lists of 1-char Python strings, replace ŒṘ with Y to see the n-joined output).

PowerShell, 82 83 bytes

+2 bytes thanks Veskah: the single character case bug fixed

-1 byte: The rule Input-string may also be a list of characters used

$c,$s=$args

($s|%{(-join$s|% s*g $i)+$c*$i++})[($r=$i..0+1..$i)]|%{"$_"[$r]-join$c}

Try it online!

Less golfed:

$c,$s=$args

$southEast = $s|%{

    (-join$s|% substring $i) + $c*$i++

}

$range=$i..0+1..$i

$southEast[$range]|%{

    "$_"[$range]-join$c

}

Pip, 24 20 bytes

QPRV:_JbMa@>RV,#aZDb

Use the -l flag to get human-readable output. Try it online!

Explanation

QPRV:_JbMa@>RV,#aZDb

                      a,b are cmdline args (implicit)

                a     1st cmdline arg (the string)

               #      Length

              ,       Range

            RV        Reverse

         a@>          Take slices of a starting at those indices

                 ZDb  Zip the list of slices together, filling out missing values in

                      the matrix with b (the character)

        M             To each row, map this function:

     _Jb               Join on b

  RV:                 Reverse (making top row the bottom and vice versa)

QP                    Quad-palindromize: reflect downward and rightward, with overlap

For example, with inputs of abcd and .:

RV,#a

 [3 2 1 0]

a@>

 ["d" "cd" "bcd" "abcd"]

ZDb

 [['d 'c 'b 'a] ['. 'd 'c 'b] ['. '. 'd 'c] ['. '. '. 'd]]

_JbM

 ["d.c.b.a" "..d.c.b" "....d.c" "......d"]

RV:

 ["......d" "....d.c" "..d.c.b" "d.c.b.a"]

QP

 ["......d......" "....d.c.d...." "..d.c.b.c.d.." "d.c.b.a.b.c.d" "..d.c.b.c.d.." "....d.c.d...." "......d......"]

Perl 6, 79 bytes

->c{{map {join c,g $_ X||c},g .[^*X+(^$_,)]}o*.comb}

my&g={.[$_-1...0...$_-1]}

Try it online!

Anonymous codeblock that takes input curried (like f(char)(string)) and returns a list of strings. I think a different approach would be shorter.

Attache, 57 bytes

${q:=#x-1Bounce!Bounce@Join&y@PadLeft&y&#x=>x[q::(q::0)]}

Try it online! Output is a list of lines.

Explanation

?? parameters: x, y

${

    ?? q is length of x - 1

    q:=#x-1

    ?? Reflect, collapsing middle:

    Bounce!

        ?? Function:

            ?? Reflect,

            Bounce@

            ?? Joined by y,

            Join&y@

            ?? padded to the length of x with y

            PadLeft&y&#x

        ?? Mapped over

        =>

            ?? The elements of x at

            x[

                ?? decreasing range from q to

                q::(

                    ?? each element in the range from q to 0

                    q::0

                )

            ]

}

Perl 5 with -lF, -M5.010, 71 bytes

$"=<>;$A=abs,$_="@F[$A..$#F]".$"x($A*2),/./,say reverse.$' for-$#F..$#F

Try it online!

C# (Visual C# Interactive Compiler), 249 bytes

s=>c=>{var r=s.Select((x,_)=>{int k=s.Length;var m=s.Substring(_,k-_).Aggregate("",(a,b)=>a+c+b);return new string(m.Skip(2).Reverse().Concat(m.Skip(1)).ToArray()).PadLeft(2*k-3+m.Length,c).PadRight(4*k-3,c);});return r.Skip(1).Reverse().Concat(r);}

Try it online!

This must be improvable...

Canvas, 8 bytes

Ｒ±［］／┼┼＊

Try it here!

7 bytes but mirrors a bunch of chars.

JavaScript (Node.js), 143 bytes

(s,c)=>{q=Math.abs;m=(l=s.length*4-3)-1;for(i=j=0;j<l/2;(i=(++i)%l)?0:++j){p=s[q(i-m/2)/2+q(j-m/4)];process.stdout.write((i?"":"n")+(p?

p:c))}}

Try it online!

A bit more thinkering would lead to calculating in terms of a one-dimensional array, and less bytes.

TSQL query, 200 bytes

In MS-SQL Server Management Studio press Ctrl-T before running this query, this will change the output to text.

This script is building up the output from left to right in one long "string", calculating the value to put in each position. The output is limited to 4096 characters.

Golfed:

USE master

DECLARE 

@y char='.',

@ varchar(20) = 'abcd'



SELECT

string_agg(iif(h>k/2,@y,substring(@,h+1,1),@y)+iif((n+1)%k=0,char(13)),'')FROM(SELECT

abs(k/2-n%k)+abs(k/2-n/k)h,*FROM(SELECT

number n,len(@)*2-1k,*FROM spt_values)c)d

WHERE n<k*k and'P'=type

Ungolfed:

USE master

DECLARE 

@y char='.',

@ varchar(32) = 'abcd'



SELECT 

  string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif((n+1)%k=0,char(13),@y),'')

FROM

  (

    SELECT abs(k/2-n%k)+abs(k/2-n/k)h,*

    FROM

    (

      SELECT number n,len(@)*2-1k,*

      FROM spt_values

    )c

  WHERE n<k*k and'P'=type

  )d

I had to make some changes to format the output in the online version.

Try it online