Inspirado por esta pergunta SO .

Desafio:

Entrada:

• Uma string$s$
• Um caractere$c$

Saída:

Crie uma arte ASCII de diamante em forma de quadrado nas quatro direções, com o primeiro caractere da seqüência no centro e indo para fora. Que fica dentro de um tapete quadrado de arte ASCII, com o personagem como preenchedor. Isso pode parecer bastante vago, então aqui está um exemplo:

Entrada: = , = Saída:$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..........

Regras do desafio:

• A string de entrada também pode ser uma lista de caracteres
• A saída também pode ser uma lista de linhas de sequência ou matriz de caracteres
• A string e o caractere de entrada têm a garantia de que não estão vazios
• A cadeia é garantida para não conter o caractere
• Tanto a string quanto o caractere só podem ser impressos em ASCII (intervalo unicode [32,126], espaço '' para e incluindo o til '~')

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Entrada: = , = Saída:$s$c =11111$c=$0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Entrada: = , = Saída:$s$c12345ABCDEF$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: = , = Saída:$s$c@+-|-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: = , = Saída:$s$cAB$c$c

ccBcc
BcAcB
ccBcc

Entrada: = , = Saída:$s$c~$c$X

~

Entrada: = , = Saída:$s$c/\^/\$c$X

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

Tela , 8 bytes

Ｒ±［］／┼┼＊

Experimente aqui!

7 bytes, mas reflete um monte 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)

Experimente online!

Graças a:

• Giuseppe por corrigir um erro e um golfe
• Aaron Hayman por 22 bytes de golfe

J , 59 56 bytes

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

Experimente online!

Solução muito longa para J ... (inteiramente minha culpa)

R , uma versão feia de 118 bytes

Permitindo que a entrada seja um vetor de caracteres únicos e produzindo uma matriz em vez de imprimir uma bela 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)

Experimente online!

R , 161 157 bytes

salvou 4 bytes usando ifelse em vez 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='')

Experimente online!

ungolfed e comentou

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 ser a resposta mais longa até agora!

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]

Experimente online!

05AB1E , 15 11 bytes

.sûsζøsýí€û

Experimente online! ou como um conjunto de testes

Explicação

.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:@-&#

Experimente online!

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

Os índices negativos começam em -1, como em python. A única coisa que resta é inserir as colunas de zeros.

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

Muito obrigado a Galen Ivanov pelo algoritmo.

K (ngn / k) , 38 bytes

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

Experimente online!

{ }função com argumentos x(a sequência s ) e y(o caractere c )

|x marcha ré x

y,'anexar ya cada

+ transpor

,/ concat

1_ soltar primeiro caractere

Neste ponto, temos uma sequência de xocorrências length ( ) yseguidas pelos caracteres dex

#x Comprimento de x

(#x)' janela deslizante de muitos caracteres consecutivos

2{ }/ faça duas vezes

+x,1_|xjunte x-se ao invertido xsem seu primeiro elemento e transponha

y,''anexar ya cada um

,/' concat cada

1_' solte um de cada

Japonês , 15 bytes

Retorna uma matriz de linhas

Ôå+ ®¬qV êÃûV ê

Tente

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

Carvão , 15 bytes

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

Experimente online! Link é a versão detalhada do código. Originalmente enviado como um comentário na postagem da sandbox agora excluída . Explicação:

ＵＢη

Defina o plano de fundo para a segunda entrada c.

Ｅθ✂θκ

Mapeie a primeira entrada spara gerar todos os sufixos e imprimi-los implicitamente em linhas separadas.

‖Ｏ↑←

Reflita horizontalmente e verticalmente.

ＵＥ¹

Adicione espaço 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}}

Experimente online!

Leva a string de entrada como uma matriz de caracteres. Retorna uma matriz de seqüências de caracteres.

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

Experimente online!

Japonês , 16 bytes

Nota: Vou jogar :)

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

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

Experimente online!

Alguns dias, ter intervalos de índice em vez de fatias realmente dói. Hoje é um daqueles dias. Devido aos intervalos conjugados que atrapalham ao lidar com elementos únicos (por exemplo, retornando 0..0 + 1..0), a caixa especial é usada para evitá-la completamente (ao custo de muitos bytes).

Japonês , 15 bytes

Ôå+ ê ®ê ¬qV
ûV

Tente

Gelatina , 11 bytes

jÐƤṚzṚŒḄZŒḄ

Experimente online!

$s$
$c$
ŒṘY\n

PowerShell , 82 83 bytes

+2 bytes graças Veskah: o erro de maiúsculas e minúsculas corrigido

-1 byte: a regra Input-string may also be a list of charactersusada

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

Experimente online!

Menos golfe:

$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 o -lsinalizador para obter uma saída legível por humanos. Experimente online!

Explicação

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 exemplo, com entradas de abcde .:

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

Anexo , 57 bytes

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

Experimente online! Saída é uma lista de linhas.

Explicação

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

Experimente online!

Codeblock anônimo que recebe entrada com curry (like f(char)(string)) e retorna uma lista de linhas. Eu acho que uma abordagem diferente seria mais curta.

Explicação:

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⍴¨⊢¨

Experimente online!

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

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

Experimente online!

C # (compilador interativo do 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);}

Experimente online!

Isso deve ser improvável ...

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

Experimente online!

Um pouco mais de reflexão levaria ao cálculo em termos de uma matriz unidimensional e menos bytes.

Kotlin , 250 bytes

Nota: O Kotlin tio atualmente falha ao retornar uma nova classe, portanto esse código obtém uma exceção de ponteiro nulo. Isso também ocorre para os códigos que eu publiquei anteriormente que funcionavam naquele momento. Suponho que ele acabará sendo corrigido, mas não foi possível encontrar um contato de suporte para reportar o problema. Também pode ser executado aqui .

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

Experimente online!

Gaia , 19 bytes

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

Experimente online!

Explicação 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))

Experimente online!

Consulta TSQL, 191 bytes

No MS-SQL Server Management Studio, pressione Ctrl-T antes de executar esta consulta, isso mudará a saída para texto.

Este script está construindo a saída da esquerda para a direita em uma "string" longa, calculando o valor a ser colocado em cada posição. A saída é limitada a 4096 caracteres.

Golfe:

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

Ungolfed:

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

Eu tive que fazer algumas alterações para formatar a saída na versão online.

Experimente online

JDK (Java) , 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;}

Experimente online!

-14 bytesObrigado a @KevinCruijssen
-1 byteobrigado a @ceilingcat

Ungolfed

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

Experimente online!

Pega uma lista de caracteres (junto com o caractere de preenchimento) como entrada e gera uma 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 pegar o índice da lista de caracteres, usamos list[[index]], que é expandido internamente para Part[list, index]. Se o índice for válido, essa expressão será avaliada como o valor nesse índice. Caso contrário, se o índice não for um número inteiro ou estiver fora do intervalo, a expressão permanecerá sem avaliação.
O padrão mais simples (mais curto) que corresponde, Part[...]mas não um caractere é _@__, que corresponde a qualquer expressão com um ou mais argumentos.