Inspiriert von dieser SO-Frage .

Herausforderung:

Eingang:

• Eine Zeichenfolge$s$
• Ein Charakter$c$

Ausgabe:

Erstellen Sie eine rautenförmige ASCII-Grafik der Zeichenfolge in alle vier Richtungen, wobei das erste Zeichen der Zeichenfolge in der Mitte und nach außen zeigt. Welches ist in einem quadratischen ASCII-Art-Teppich, mit dem Charakter als Füllstoff. Das mag ziemlich vage klingen, also hier ein Beispiel:

Eingabe: = , = Ausgabe:$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..........

Herausforderungsregeln:

• Die Eingabezeichenfolge kann auch eine Liste von Zeichen sein
• Die Ausgabe kann auch eine Liste von Zeichenketten oder eine Matrix von Zeichen sein
• Eingabezeichenfolge und Zeichen sind garantiert nicht leer
• Die Zeichenfolge enthält garantiert kein Zeichen
• Sowohl der String als auch das Zeichen können nur als ASCII-Zeichen gedruckt werden (Unicode-Bereich [32,126], Leerzeichen '' bis einschließlich Tilde '~').

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Eingabe: = , = Ausgabe:$s$11111$c=$0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Eingabe: = , = Ausgabe:$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####################

Eingabe: = , = Ausgabe:$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::::::::::::::::::

Eingabe: = , = Ausgabe:$s$cAB$c$c

ccBcc
BcAcB
ccBcc

Eingabe: $s$ = ~, $c$ = X
Ausgabe:

~

Eingabe: $s$ = /\^/\, $c$ = X
Ausgabe:

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

Canvas , 8 Bytes

Ｒ±［］／┼┼＊

Probieren Sie es hier aus!

7 Bytes , spiegelt aber eine Reihe von Zeichen wider.

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)

Probieren Sie es online!

Dank an:

• Giuseppe für die Behebung eines Fehlers und ein Golf
• Aaron Hayman für 22 Bytes Golf

J , 59 56 Bytes

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

Probieren Sie es online!

Zu lange Lösung für J ... (ganz und gar meine Schuld)

R , eine hässliche 118-Byte-Version

Indem die Eingabe ein Vektor aus einzelnen Zeichen ist und eine Matrix ausgegeben wird, anstatt schöne ASCII-Grafiken zu drucken.

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)

Probieren Sie es online!

R , 161 157 Bytes

4 Bytes gespart durch Verwendung von ifelse anstelle von bedingten Änderungen 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='')

Probieren Sie es online!

ungolfed und kommentiert

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, scheint die längste Antwort zu sein!

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]

Probieren Sie es online!

05AB1E , 15 11 Bytes

.sûsζøsýí€û

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Probieren Sie es 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

Negative Indizes beginnen wie in Python bei -1. Sie müssen nur noch die Spalten mit den Nullen einfügen.

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

Vielen Dank an Galen Ivanov für den Algorithmus.

K (ngn / k) , 38 Bytes

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

Probieren Sie es online!

{ }Funktion mit Argumenten x(die Zeichenfolge s ) und y(das Zeichen c )

|x umkehren x

y,'yjedem voranstellen

+ transponieren

,/ concat

1_ Lass das erste Zeichen fallen

An dieser Stelle haben wir eine Folge von length ( x) -Instanzen ygefolgt von den Zeichen vonx

#x Länge von x

(#x)' Schiebefenster von so vielen aufeinanderfolgenden Zeichen

2{ }/ zweimal machen

+x,1_|xverbinden xmit dem umgekehrt , xohne das erste Element, und transponieren

y,''yjedem voranstellen

,/' concat jeder

1_' lassen Sie eins von jedem fallen

Japt , 15 Bytes

Gibt ein Array von Zeilen zurück

Ôå+ ®¬qV êÃûV ê

Versuch es

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

Kohle , 15 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ursprünglich als Kommentar zum nun gelöschten Sandbox-Beitrag eingereicht . Erläuterung:

ＵＢη

Stellen Sie den Hintergrund auf den zweiten Eingang ein c.

Ｅθ✂θκ

Ordnen Sie die erste Eingabe szu, um alle Suffixe zu generieren und implizit in separaten Zeilen zu drucken.

‖Ｏ↑←

Horizontal und vertikal reflektieren.

ＵＥ¹

Fügen Sie horizontal zusätzlichen Platz hinzu.

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

Probieren Sie es online!

Nimmt die Eingabezeichenfolge als ein Array von Zeichen. Gibt ein Array von Zeichenfolgen zurück.

Wolfram-Sprache (Mathematica) , 121 Byte

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

Probieren Sie es online!

Japt , 16 Bytes

Hinweis: Ich werde es Golf spielen :)

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

Probieren Sie es online!

PowerShell , 120 Byte

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]

Probieren Sie es online!

An manchen Tagen schmerzt es wirklich, Indexbereiche anstelle von Slices zu haben. Heute ist einer dieser Tage. Aufgrund der Verwechslung von verbundenen Bereichen beim Umgang mit einzelnen Elementen (z. B. Rückgabe von 0..0 + 1..0) wird eine spezielle Groß- / Kleinschreibung verwendet, um dies insgesamt zu vermeiden (auf Kosten vieler Bytes).

Japt , 15 Bytes

Ôå+ ê ®ê ¬qV
ûV

Versuch es

Jelly , 11 Bytes

jÐƤṚzṚŒḄZŒḄ

Probieren Sie es online!

$s$
$c$
ŒṘY\n

PowerShell , 82 bis 83 Byte

+2 Bytes dank Veskah: Der Fehler in der Groß- und Kleinschreibung wurde behoben

-1 Byte: Die Regel Input-string may also be a list of charactersverwendet

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

Probieren Sie es online!

Weniger golfen:

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

Pip , 24 bis 20 Bytes

QPRV:_JbMa@>RV,#aZDb

Verwenden Sie das -lFlag, um eine lesbare Ausgabe zu erhalten. Probieren Sie es online!

Erläuterung

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

Zum Beispiel mit Eingaben von abcdund .:

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 Bytes

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

Probieren Sie es online! Ausgabe ist eine Liste von Zeilen.

Erläuterung

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

Probieren Sie es online!

Anonymer Codeblock, der Eingaben wie "curried" annimmt f(char)(string)und eine Liste von Zeilen zurückgibt. Ich denke, ein anderer Ansatz wäre kürzer.

Erläuterung:

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

Probieren Sie es online!

Perl 5 mit -lF, -M5.010, 71 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!

Das muss verbesserungsfähig sein ...

JavaScript (Node.js) , 143 Byte

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

Probieren Sie es online!

Ein bisschen mehr Nachdenken würde zu Berechnungen in Form eines eindimensionalen Arrays und weniger Bytes führen.

Kotlin , 250 Bytes

Hinweis: Kotlin tio kann derzeit keine neue Klasse zurückgeben, sodass dieser Code eine Nullzeigerausnahme erhält. Dies gilt auch für Codes, die ich zuvor veröffentlicht habe und die zu diesem Zeitpunkt funktionierten. Ich gehe davon aus, dass es irgendwann behoben wird, konnte aber keinen Support-Kontakt finden, an den das Problem gemeldet werden kann. Es kann auch hier ausgeführt werden .

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

Probieren Sie es online!

Gaia , 19 Bytes

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

Probieren Sie es online!

Erklärung folgt.

JavaScript (Node.js) , 101 Byte

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

Probieren Sie es online!

TSQL-Abfrage, 191 Byte

Drücken Sie in MS-SQL Server Management Studio Strg-T, bevor Sie diese Abfrage ausführen. Dadurch wird die Ausgabe in Text geändert.

Dieses Skript baut die Ausgabe von links nach rechts in einer langen "Zeichenfolge" auf und berechnet den Wert, der an jeder Position eingefügt werden soll. Die Ausgabe ist auf 4096 Zeichen begrenzt.

Golf gespielt:

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

Ich musste einige Änderungen vornehmen, um die Ausgabe in der Online-Version zu formatieren.

Probieren Sie es online aus

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

Probieren Sie es online!

-14 bytes danke an @KevinCruijssen
-1 byte danke an @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-Sprache (Mathematica) , 68 Byte

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

Probieren Sie es online!

Nimmt eine Liste von Zeichen (zusammen mit dem Füllzeichen) als Eingabe und gibt eine Zeichenmatrix aus.

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

Um den Index der Liste der Zeichen zu nehmen, verwenden wir list[[index]], der intern erweitert wird, um Part[list, index]. Wenn der Index gültig ist, wird dieser Ausdruck zu dem Wert an diesem Index ausgewertet. Wenn nicht - wenn der Index keine Ganzzahl ist oder außerhalb des Bereichs liegt - bleibt der Ausdruck unbewertet.
Das einfachste (kürzeste) Muster , das mit einem oder mehreren Argumenten übereinstimmt, Part[...]jedoch nicht mit einem einzelnen Zeichen, ist _@__, dass ein Ausdruck mit einem oder mehreren Argumenten übereinstimmt.