Am vergangenen Donnerstag Benutzer @SpookyGengar erfreut uns mit seiner / ihrem ersten Herausforderung über Squared Worte zu machen . Was ist, wenn wir die Anzahl der Seiten verdoppeln?

Die Herausforderung

Nehmen Sie einen String als Eingabe in einem beliebigen geeigneten Format ( string, charArray ...) und geben Sie eine oktogonale Darstellung der Eingabe aus (auch in einem beliebigen geeigneten Format:, stringListe von strings, charMatrix ...), wie in den folgenden Beispielen:

Input: golf
Output:

   golf
  o    l
 l      o
f        g
l        o
o        l
g        f
 o      l
  l    o
   flog


Input: HelloWorld
Output:

         HelloWorld
        e          l
       l            r
      l              o
     o                W
    W                  o
   o                    l
  r                      l
 l                        e
d                          H
l                          e
r                          l
o                          l
W                          o
o                          W
l                          o
l                          r
e                          l
H                          d
 e                        l
  l                      r
   l                    o
    o                  W
     W                o
      o              l
       r            l
        l          e
         dlroWolleH


Input: a
Output:

a


Input: ab
Output:

 ab
b  a
a  b
 ba


Input: code golf
Output:

        code golf
       o         l
      d           o
     e             g

   g                 e
  o                   d
 l                     o
f                       c
l                       o
o                       d
g                       e

e                       g
d                       o
o                       l
c                       f
 o                     l
  d                   o
   e                 g

     g             e
      o           d
       l         o
        flog edoc

Anmerkungen

• Die Eingabe besteht nur aus druckbaren ASCII-Zeichen.
• Führende und / oder nachfolgende Leerzeichen und Zeilenumbrüche sind zulässig, solange die achteckige Form erhalten bleibt.
• Das ist Code-Golf , also kann das sorteste Programm / die sorteste Funktion für jede Sprache gewinnen!

Kohle , 16 Bytes (10 Bytes nicht konkurrierend)

Ｆ⁸«✂θ⁰±¹↷¹Ａ⮌θθ»θ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆ⁸«                 Repeat for each side of the octagon
   ✂θ⁰±    ¹        Print the input except the last character
        ↷¹          Rotate 45° clockwise
          Ａ⮌θθ      Reverse the input string
              »θ    Print the input again, to handle the length 1 case

Alternative Länge 1 fix, auch 16 Bytes: Ausführliche Version.

ＰθＦ⁸«✂θ⁰±¹↷¹Ａ⮌θθ

Ein Charcoal-Bugfix bedeutet, dass der folgende 10-Byte-Code jetzt funktioniert: Ausführliche Version.

Ｆ⁴«θ←↘⮌θ↖⟲

JavaScript (ES6), 156 Byte

f=
s=>[...Array((l=s.length-1)*3+1)].map((_,i,a)=>a.map((_,j)=>s[i+j-l?l*5-i-j?i+l*2-j?j+l*2-i?i%(l*3)?j%(l*3)?-1:j?i-l:l+l-i:i?l+l-j:j-l:j:l-i:l*3-i:i]||` `))

<input oninput=o.textContent=this.value?f(this.value).map(function(a){return(a.join``)}).join`\n`:``><pre id=o>

Gibt ein Zeichenarray zurück.

Mathematica, 247 Bytes

(T=Table;k=Length[s=Characters@#];If[k==1,#,Column[Flatten@{#,T[""<>{s[[i]],T["  ",k/2-2+i],s[[-i]]},{i,2,k}],T[""<>{s[[-i]],T["  ",k+k/2-2],s[[i]]},{i,2,k}],T[""<>{s[[i]],T["  ",3k/2-1-i],s[[-i]]},{i,2,k-1}],StringReverse@#},Alignment->Center]])&

Pyth , 79 69 65 Bytes

j++K+]+*dJtlzzm+++*;-Jd@zd*;+ytdlz@z_hdSJjL*;t*3tlztC_B_zt__MC.tK

Testsuite .

Japt , 84 79 Bytes

-5 Bytes dank @ETHproductions.

Ål
VoA{A?(UÅw +Uê)£Y¥V*2+AªY¥V-A?X:SÃ:Vç +U+Vç
Wf cU¬£V?(V*3 ç hUg~Y)+X:XÃcWz2

Führende Newline ist Teil des Programms. Nimmt eine Zeichenfolge als Eingabe und gibt ein Array von Zeichenfolgen zurück.

Probieren Sie es online! mit dem -RFlag, um das resultierende Array mit Zeilenumbrüchen zu verbinden.

Nicht meine stolzeste Arbeit, aber ich habe es zumindest von ~ 100 Bytes geschafft. Meine Idee hier war es, den oberen und mittleren Teil zu erstellen und dann den oberen Teil um 180 ° gedreht anzuhängen.

Python 2 , 220 213 Bytes

• Überraschenderweise länger, als ich es mir vorgestellt hatte.

a=input()
l=len(a)
r=range(l)
print'\n'.join(p.center(l*3-2)for p in[a]+(l>1)*([a[i]+(2*i-2+l)*' '+a[~i]for i in r[1:-1]]+[a[~i]+(l*3-4)*' '+a[i]for i in r]+[a[i]+(3*l-2*i-4)*' '+a[~i]for i in r[1:-1]]+[a[::-1]]))

Probieren Sie es online!

PHP 7.1, 230 156 155 Bytes

for($x=$e=strlen($s=$argn)-1;$n<9;$r[$y][$x+=$n+1&3?$n&4?-1:1:0]=$s[$i],$i+=($n+=!$i||$i==$e)&1?:-1)$r[$y+=$n-1&3?$n<6?:-1:0]=$r[$y]?:"";echo join("
",$r);

Lauf als Pipe mit -nRoder versuche es online .

Nervenzusammenbruch

for($x=$e=strlen($s=$argn)-1;   # import to $s, set $e to length-1, init $x
    $n<9;                       # loop through 8 repetitions of string
    $r[$y][
        $x+=$n+1&3?$n&4?-1:1:0      # 3. increment/decrement $x depending on $n
    ]=$s[$i],                       # 4. copy character to current position
    $i+=(
        $n+=!$i||$i==$e             # 5. if first or last character of string, increment $n
    )&1?:-1                         # 6. if odd repetition next, else previous character
)
    $r[
        $y+=$n-1&3?$n<6?:-1:0       # 1. increment/decrement $y depending on $n
    ]=$r[$y]?:"";                   # 2. if empty, init row to string
echo join("\n",$r);             # output

Mathematica, 168 166 147 127 Bytes

(n=Length@#;b=Array[" "&,3{n,n}-2];Do[l={{1,n+k-1},{k,n-k+1}};l=Join[l,Cross/@l];b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,n}];b)&

Dies nimmt eine Liste von Zeichenfolgen mit einem Zeichen und gibt eine Matrix von Zeichenfolgen mit einem Zeichen aus.

Ich habe 18 Bytes gespart, indem ich die Symmetrie ausgenutzt habe, um sie zu verwenden, -lund Cross/@ldie so etwas wie ein Kreuzprodukt von jedem der zwei einzelnen 2D-Vektoren benötigt, um {x,y}zu nehmen {-y,x}. Grundsätzlich sind die beiden Anfangsrichtungen Ost (oberer Rand) und Südwest (oberer rechter Rand). Dann addieren wir sie um 90 Grad gegen den Uhrzeigersinn mit Cross: Norden für den linken Rand und Südosten für den unteren linken Rand. Dann fügen wir die anderen vier Stücke hinzu, indem -lwir die vier, die wir abgedeckt haben, umdrehen.

Sie können es auf der Sandbox mit etwas testen :

(n=Length@#;b=Array[" "&,3{n,n}-2];Do[l={{1,n+k-1},{k,n-k+1}};l=Join[l,Cross/@l];b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,n}];b)&[{"H","e","l","l","o"," ","G","o","l","f"}]//MatrixForm