Inspirado por esta pregunta SO .

Reto:

Entrada:

• Una cadena$s$
• Un personaje$c$

Salida:

Cree un arte ASCII cuadrado de diamante de la cuerda en las cuatro direcciones, con el primer carácter de la cuerda en el centro y hacia afuera. Que está dentro de una alfombra cuadrada de arte ASCII, con el personaje como relleno. Esto puede sonar bastante vago, así que aquí hay un ejemplo:

Entrada: = , = Salida:$s$string$c$.

..........g..........
........g.n.g........
......g.n.i.n.g......
....g.n.i.r.i.n.g....
..g.n.i.r.t.r.i.n.g..
g.n.i.r.t.s.t.r.i.n.g
..g.n.i.r.t.r.i.n.g..
....g.n.i.r.i.n.g....
......g.n.i.n.g......
........g.n.g........
..........g..........

Reglas de desafío:

• La cadena de entrada también puede ser una lista de caracteres
• La salida también puede ser una lista de líneas de cadena o una matriz de caracteres
• Se garantiza que la cadena de entrada y el carácter no están vacíos
• Se garantiza que la cadena no contiene el carácter.
• Tanto la cadena como el carácter solo serán ASCII imprimibles (rango unicode [32,126], espacio '' e incluyendo tilde '~')

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Entrada: = , = Salida:$s$11111$c=$0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Entrada: = , = Salida:$s$12345ABCDEF$c$#

####################F####################
##################F#E#F##################
################F#E#D#E#F################
##############F#E#D#C#D#E#F##############
############F#E#D#C#B#C#D#E#F############
##########F#E#D#C#B#A#B#C#D#E#F##########
########F#E#D#C#B#A#5#A#B#C#D#E#F########
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
F#E#D#C#B#A#5#4#3#2#1#2#3#4#5#A#B#C#D#E#F
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
########F#E#D#C#B#A#5#A#B#C#D#E#F########
##########F#E#D#C#B#A#B#C#D#E#F##########
############F#E#D#C#B#C#D#E#F############
##############F#E#D#C#D#E#F##############
################F#E#D#E#F################
##################F#E#F##################
####################F####################

Entrada: = , = Salida:$s$@+-|-o-|-O$c$:

::::::::::::::::::O::::::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
O:-:|:-:o:-:|:-:+:@:+:-:|:-:o:-:|:-:O
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::::::O::::::::::::::::::

Entrada: = , c = Salida:$s$AB$c$c

ccBcc
BcAcB
ccBcc

Entrada: $s$ = ~, $c$ = X
Salida:

~

Entrada: $s$ = /\^/\, $c$ = X
Salida:

XXXXXXXX\XXXXXXXX
XXXXXX\X/X\XXXXXX
XXXX\X/X^X/X\XXXX
XX\X/X^X\X^X/X\XX
\X/X^X\X/X\X^X/X\
XX\X/X^X\X^X/X\XX
XXXX\X/X^X/X\XXXX
XXXXXX\X/X\XXXXXX
XXXXXXXX\XXXXXXXX

Lienzo , 8 bytes.

Ｒ±［］／┼┼＊

Pruébalo aquí!

7 bytes pero refleja un montón de caracteres.

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)

Pruébalo en línea!

Gracias a:

• Giuseppe por arreglar un error y un golf
• Aaron Hayman por 22 bytes de golf

J , 59 56 bytes

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

Pruébalo en línea!

Solución demasiado larga para J ... (completamente culpa mía)

R , una versión fea de 118 bytes

Al permitir que la entrada sea un vector de caracteres individuales y generar una matriz en lugar de imprimir un bonito arte ascii.

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)

Pruébalo en línea!

R , 161 157 bytes

ahorró 4 bytes usando ifelse en lugar de modificar condicionalmente 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='')

Pruébalo en línea!

no golfista y comentado

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, ¡parece la respuesta más larga hasta ahora!

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]

Pruébalo en línea!

05AB1E , 15 11 bytes

.sûsζøsýí€û

Pruébalo en línea! o como un conjunto de pruebas

Explicación

.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 , 35 34 33 bytes

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

Pruébalo en línea!

-&#$c$$s$
i:
1-|+/|
{: (<*-)-&#

 0  0 _1  0  0
 0 _1 _2 _1  0
_1 _2 _3 _2 _1
 0 _1 _2 _1  0
 0  0 _1  0  0

Los índices negativos comienzan desde -1 como en python. Lo único que queda es insertar las columnas de ceros.

1j1( #"1
  }:@
,{~$c$$s$

Muchas gracias a Galen Ivanov por el algoritmo.

K (ngn / k) , 38 bytes

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

Pruébalo en línea!

{ } funcionar con argumentos x (la cadena s ) y y(el carácter c )

|x marcha atrás x

y,'anteponer ya cada

+ transponer

,/ concat

1_ soltar el primer char

en este punto tenemos una serie de xinstancias de length ( ) dey seguidas por los caracteres dex

#x longitud de x

(#x)' ventana deslizante de tantos caracteres consecutivos

2{ }/ hacer dos veces

+x,1_|xunirse xcon el reverso xsin su primer elemento, y transponer

y,''anteponer ya cada uno

,/' concat cada

1_' soltar uno de cada

Japt , 15 bytes

Devuelve una matriz de líneas.

Ôå+ ®¬qV êÃûV ê

Intentalo

Ôå+ ®¬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

Carbón de leña , 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Originalmente presentado como un comentario en la entrada caja de arena ahora borrado . Explicación:

ＵＢη

Establecer el fondo a la segunda entrada c.

Ｅθ✂θκ

Asigne sobre la primera entrada spara generar todos los sufijos e imprimirlos implícitamente en líneas separadas.

‖Ｏ↑←

Refleja horizontal y verticalmente.

ＵＥ¹

Añadir espacio extra horizontalmente.

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

Pruébalo en línea!

Toma la cadena de entrada como una matriz de caracteres. Devuelve una matriz de cadenas.

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

Pruébalo en línea!

Japt , 16 bytes

Nota: voy a jugar al golf :)

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

Pruébalo en línea!

Potencia Shell , 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]

Pruébalo en línea!

Algunos días, tener rangos de índice en lugar de sectores realmente duele. Hoy es uno de esos dias. Debido a que los rangos combinados se confunden cuando se trata de elementos individuales (por ejemplo, devolver 0..0 + 1..0), se utiliza una carcasa especial para evitarlo por completo (a costa de muchos bytes).

Japt , 15 bytes

Ôå+ ê ®ê ¬qV
ûV

Intentalo

Jalea , 11 bytes

jÐƤṚzṚŒḄZŒḄ

Pruébalo en línea!

Argumento izquierdo: $s$.
Argumento correcto:$c$(como un solo carácter, no como una cadena).
Salida: Lista de cadenas Jelly (aparece como una lista de listas de cadenas Python de 1 carácter, reemplace ŒṘcon Ypara ver la \nsalida unida).

PowerShell , 82 83 bytes

+2 bytes gracias Veskah: el error de mayúsculas y minúsculas solucionado

-1 byte: la regla Input-string may also be a list of charactersutilizada

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

Pruébalo en línea!

Menos golfizado:

$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

Utilizar el -l bandera para obtener resultados legibles por humanos. Pruébalo en línea!

Explicación

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

Por ejemplo, con entradas de abcdy .:

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

Adjunto , 57 bytes

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

Pruébalo en línea!La salida es una lista de líneas.

Explicación

?? 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 6 , 79 bytes

->\c{{map {join c,g $_ X||c},g .[^*X+(^$_,)]}o*.comb}
my&g={.[$_-1...0...$_-1]}

Pruébalo en línea!

Codeblock anónimo que toma la entrada al curry (como f(char)(string) ) y devuelve una lista de líneas. Creo que un enfoque diferente sería más corto.

Explicación:

my&g={.[$_-1...0...$_-1]}  # Helper function to palindromise a list
->\c{                                                }  # Code block that takes a char
     {                                       }o*.comb   # And returns a function
                                .[^*X+(^$_,)]  # Get all prefixes with end padding
                                               # e.g. "str" => [["r",Nil,Nil]
                                                                ["t","r",Nil]
                                                                ["s","t","r"]]
                              g   # Palindromise the lsit
       map {                },    # Map each element to
                     $_ X||c      # Replace all Nils with the character
                   g              # Palindromise it
            join c,               # And join by the character

APL (Dyalog Classic) , 32 31 bytes

(⍉1↓¯1↓⊖⍪1↓⊢)⍣2∘↑(≢⊣),/,¨,2⍴¨⊢¨

Pruébalo en línea!

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

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 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);}

Pruébalo en línea!

Esto debe ser mejorable ...

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

Pruébalo en línea!

Un poco más de reflexión llevaría a calcular en términos de una matriz unidimensional y menos bytes.

Kotlin , 250 bytes

Nota: Kotlin tio actualmente no puede devolver una nueva clase, por lo que este código obtiene una excepción de puntero nulo. Esto también ocurre para los códigos que publiqué anteriormente que funcionaban en ese momento. Supongo que eventualmente se solucionará, pero no pude encontrar un contacto de soporte para informar el problema. También se puede ejecutar aquí .

{s:String,c:Char->val h=s.length*2-1
val w=h*2-1
val m=Array(h){Array(w){c}}
for(i in s.indices)for(r in 0..h-1){val o=(i-Math.abs(h/2-r))*2
if(o>=0){m[r][w/2+o]=s[i].toChar()
m[r][w/2-o]=s[i].toChar()}}
m.map{it.joinToString("")}.joinToString("\n")}

Pruébalo en línea!

Gaia , 19 bytes

:ṫl¤┅v;@&Z¦<¦v¦ṫ¦ṫṣ

Pruébalo en línea!

Explicación a seguir.

JavaScript (Node.js) , 101 bytes

s=>c=>[l=s.length-1,...Array(l*2)].map((x,i,a,m=Math.abs)=>a.map((y,j)=>s[m(l-i)+m(l-j)]||c).join(c))

Pruébalo en línea!

Consulta TSQL, 191 bytes

En MS-SQL Server Management Studio, presione Ctrl-T antes de ejecutar esta consulta, esto cambiará la salida a texto.

Este script está construyendo la salida de izquierda a derecha en una "cadena" larga, calculando el valor para colocar en cada posición. La salida está limitada a 4096 caracteres.

Golfizado:

SELECT
string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@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)d
WHERE n<k*k and'P'=type

Sin golf:

USE master
DECLARE 
@y char='.',
@ varchar(20) = 'abcd'

SELECT
  string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@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
)d
WHERE n<k*k and'P'=type

Tuve que hacer algunos cambios para formatear la salida en la versión en línea.

Pruébalo en línea

Java (JDK) , 213 199 198 bytes

a->b->{int i=0,l=a.length()-1;String s=a,r[]=new String[l-~l],p;for(;i<=l;s=s.substring(1))r[l+i]=r[l-i]=new StringBuffer(p=b.join(b,s.split(""))+b.repeat(2*i++)).reverse()+p.substring(1);return r;}

Pruébalo en línea!

-14 bytes gracias a @KevinCruijssen
-1 byte gracias a @ceilingcat

Sin golf

a->
    b-> {
        int i = 0, l = a.length() - 1;
        String s = a, r[]=new String[a.length()*2-1],p;
        for (; i<=l; s=s.substring(1))
            r[l+i]
              = r[l-i++]
              =   new StringBuffer(
                                   p =   String.join(b,s.split(""))
                                       + b.repeat(2*i)
                                  ).reverse()
                + p.substring(1);
        return r;
    }

Wolfram Language (Mathematica) , 68 bytes

Table[#[[1+Abs@y+Abs@x/2]]/._@__:>#2,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&

Pruébalo en línea!

Toma una lista de caracteres (junto con el carácter de relleno) como entrada y genera una matriz de caracteres.

Table[                              ,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&    (* make a (2*len-1 x 4*len-3) table centered at (0,0) *)
      #[[               ]]                                              (*  where the value at each point is the string indexed at *)
         1+Abs@y+Abs@x/2                                                (*   (1 + |y-coordinate| + |x-coordinate|/2) *)
                          /._@__:>#2                                    (*  if that indexing fails, use the filler character instead *)

Para tomar el índice de la lista de caracteres, utilizamos list[[index]], que se expande internamente a Part[list, index]. Si el índice es válido, esa expresión se evalúa como el valor en ese índice. Si no, si el índice no es un número entero o está fuera de rango, la expresión permanece sin evaluar.
El patrón más simple (más corto) que coincide Part[...]pero no tiene un solo carácter es _@__, que coincide con cualquier expresión con uno o más argumentos.