Zainspirowany tym pytaniem SO .

Wyzwanie:

Wejście:

• Ciąg$s$
• Znak$c$

Wynik:

Utwórz diamentową kwadratową grafikę ASCII sznurka we wszystkich czterech kierunkach, z pierwszym znakiem sznurka pośrodku i skierowanym na zewnątrz. Który znajduje się w kwadratowym dywanie ASCII-art, z postacią wypełniającą. Może to zabrzmieć dość niejasno, więc oto przykład:

Dane wejściowe: = , = Dane wyjściowe:$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..........

Zasady konkursu:

• Ciąg wejściowy może być również listą znaków
• Wyjściem może być również lista linii ciągów lub macierz znaków
• Ciąg wejściowy i znak są gwarantowane jako niepuste
• Ciąg nie może zawierać znaku
• Zarówno ciąg, jak i znak będą drukowane tylko w formacie ASCII (zakres Unicode [32, 126], spacja „” włącznie z tyldą „~”)

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

Dane wejściowe: = , = Dane wyjściowe:$s$c =11111$c=$0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Dane wejściowe: = , = Dane wyjściowe:$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####################

Dane wejściowe: = , = Dane wyjściowe:$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::::::::::::::::::

Dane wejściowe: = , = Dane wyjściowe:$s$cAB$c$c

ccBcc
BcAcB
ccBcc

Dane wejściowe: = , = Dane wyjściowe:$s$c~$c$X

~

Dane wejściowe: = , = Dane wyjściowe:$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

Płótno , 8 bajtów

Ｒ±［］／┼┼＊

Wypróbuj tutaj!

7 bajtów, ale odzwierciedla kilka znaków.

R , 118 95 92 bajtów

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)

Wypróbuj online!

Dzięki:

• Giuseppe za naprawienie błędu i golfa
• Aaron Hayman za 22 bajty golfa

J , 59 56 bajtów

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

Wypróbuj online!

Zbyt długie rozwiązanie dla J ... (całkowicie moja wina)

R , brzydka wersja 118 bajtów

Pozwalając na wejście jako wektor pojedynczych znaków i generowanie matrycy zamiast drukowania ładnej sztuki 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)

Wypróbuj online!

R , 161 157 bajtów

zapisano 4 bajty, używając ifelse zamiast warunkowo modyfikować 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='')

Wypróbuj online!

nie golfił i komentował

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, wydaje się najdłuższą jak dotąd odpowiedzią!

Python 2 , 97 96 90 84 bajtów

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]

Wypróbuj online!

05AB1E , 15 11 bajtów

.sûsζøsýí€û

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

.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 bajtów

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

Wypróbuj online!

Od prawej do lewej:
-&#długość$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

Wskaźniki ujemne zaczynają się od -1 jak w Pythonie. Pozostało tylko wstawić kolumny zer.

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

Ogromne podziękowania dla Galena Iwanowa za algorytm.

K (ngn / k) , 38 bajtów

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

Wypróbuj online!

{ }funkcja z argumentami x(napisu s ) i y(znak c )

|x rewers x

y,'dodawać ydo każdego

+ transponować

,/ konkat

1_ upuść pierwszy znak

w tym momencie mamy ciąg xinstancji length ( ), ypo których następuje znak zx

#x długość x

(#x)' przesuwne okno wielu kolejnych znaków

2{ }/ zrobić dwa razy

+x,1_|xpołącz xz odwróconym xbez pierwszego elementu i transponuj

y,''dodawać ydo każdego z nich

,/' konkat każdy

1_' upuść po jednym z każdego

Japt , 15 bajtów

Zwraca tablicę wierszy

Ôå+ ®¬qV êÃûV ê

Spróbuj

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

Węgiel drzewny , 15 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Pierwotnie przedstawiony jako komentarz do piaskownicy teraz usuniętego postu . Wyjaśnienie:

ＵＢη

Ustaw tło na drugie wejście c.

Ｅθ✂θκ

Odwzoruj na pierwszym wejściu, saby wygenerować wszystkie przyrostki i niejawnie wydrukować je w osobnych wierszach.

‖Ｏ↑←

Odbijaj w poziomie i w pionie.

ＵＥ¹

Dodaj dodatkową przestrzeń w poziomie.

Rubin , 95 84 75 bajtów

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

Wypróbuj online!

Pobiera ciąg wejściowy jako tablicę znaków. Zwraca tablicę ciągów.

Wolfram Language (Mathematica) , 121 bajtów

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

Wypróbuj online!

Japt , 16 bajtów

Uwaga: zagram w golfa :)

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

Wypróbuj online!

PowerShell , 120 bajtów

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]

Wypróbuj online!

W niektóre dni posiadanie zakresów indeksów zamiast plasterków naprawdę boli. Dzisiaj jest jeden z tych dni. Ze względu na bałagan połączonych zakresów w przypadku pojedynczych elementów (np. Zwracanie wartości 0..0 + 1..0) zastosowano specjalną obudowę, aby całkowicie tego uniknąć (kosztem wielu bajtów).

Japt , 15 bajtów

Ôå+ ê ®ê ¬qV
ûV

Spróbuj

Galaretka , 11 bajtów

jÐƤṚzṚŒḄZŒḄ

Wypróbuj online!

$s$
$c$
ŒṘY\n

PowerShell , 82 83 bajty

+2 bajty dzięki Veskah: naprawiono błąd dotyczący pojedynczego znaku

-1 bajt: Input-string may also be a list of characterszastosowana reguła

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

Wypróbuj online!

Mniej golfa:

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

Pip , 24 20 bajtów

QPRV:_JbMa@>RV,#aZDb

Użyj -lflagi, aby uzyskać wynik czytelny dla człowieka. Wypróbuj online!

Wyjaśnienie

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

Na przykład z danymi wejściowymi abcdi .:

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

Attache , 57 bajtów

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

Wypróbuj online! Dane wyjściowe to lista wierszy.

Wyjaśnienie

?? 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 bajtów

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

Wypróbuj online!

Anonimowy blok kodu, który pobiera wejście curry (jak f(char)(string)) i zwraca listę wierszy. Myślę, że inne podejście byłoby krótsze.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Perl 5 z -lF, -M5.010, 71 bajtów

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

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 249 bajtów

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

Wypróbuj online!

To musi być możliwe do ulepszenia ...

JavaScript (Node.js) , 143 bajty

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

Wypróbuj online!

Nieco bardziej przemyślane podejście prowadziłoby do obliczeń w postaci jednowymiarowej tablicy i mniejszej liczby bajtów.

Kotlin , 250 bajtów

Uwaga: Kotlin tio obecnie nie zwraca nowej klasy, więc ten kod otrzymuje wyjątek wskaźnika zerowego. Dzieje się tak również w przypadku wcześniej opublikowanych kodów, które działały. Zakładam, że w końcu zostanie to naprawione, ale nie mogłem znaleźć kontaktu z pomocą techniczną do zgłoszenia problemu. Można go również uruchomić tutaj .

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

Wypróbuj online!

Gaia , 19 bajtów

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

Wypróbuj online!

Wyjaśnienie do naśladowania.

JavaScript (Node.js) , 101 bajtów

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

Wypróbuj online!

Zapytanie TSQL, 191 bajtów

W MS-SQL Server Management Studio naciśnij Ctrl-T przed uruchomieniem tego zapytania, zmieni to wynik na tekst.

Ten skrypt buduje dane wyjściowe od lewej do prawej w jednym długim „łańcuchu”, obliczając wartość, którą należy umieścić w każdej pozycji. Dane wyjściowe są ograniczone do 4096 znaków.

Gra w golfa:

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

Nie golfowany:

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

Musiałem wprowadzić pewne zmiany, aby sformatować dane wyjściowe w wersji online.

Wypróbuj online

Java (JDK) , 213 199 198 bajtów

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

Wypróbuj online!

-14 bytesdzięki @KevinCruijssen
-1 bytedzięki @ceilingcat

Bez golfa

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 bajtów

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

Wypróbuj online!

Pobiera na wejściu listę znaków (wraz ze znakiem wypełniającym) i wysyła macierz znaków.

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

Aby wziąć indeks listy znaków, używamy list[[index]], który jest wewnętrznie rozszerzony do Part[list, index]. Jeśli indeks jest prawidłowy, to wyrażenie wyraża wartość tego indeksu. Jeśli nie - jeśli indeks nie jest liczbą całkowitą lub jest poza zakresem - wyrażenie pozostaje nieocenione.
Najprostszym (najkrótszym) wzorcem, który pasuje, Part[...]ale nie jest jednym znakiem _@__, który pasuje do dowolnego wyrażenia z jednym lub więcej argumentami.