Jeudi dernier, l'utilisateur @SpookyGengar nous a ravis de son premier défi à propos de Making Squared Words . Et si nous doublons le nombre de côtés?

Le défi

Prenez une chaîne en entrée dans n'importe quel format raisonnable dont vous avez besoin ( string, chartableau ...) et sortez une représentation octogonale de l'entrée (également dans tout format raisonnable:, stringliste de strings, charmatrice ...) comme dans les exemples suivants:

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

Remarques

• L'entrée consistera uniquement en caractères ASCII imprimables.
• Espaces blancs de début et / ou de fin et sauts de ligne autorisés tant que la forme octogonale est maintenue.
• C'est du golf de code , donc le programme / la fonction la plus triée pour chaque langue peut gagner!

Charbon de bois , 16 octets (10 octets sans concurrence)

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆ⁸«                 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

Longueur alternative 1 correctif, également 16 octets: version détaillée.

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

Un correctif de charbon de bois signifie que le code de 10 octets suivant fonctionne désormais: Version détaillée.

Ｆ⁴«θ←↘⮌θ↖⟲

JavaScript (ES6), 156 octets

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>

Renvoie un tableau de caractères.

Mathematica, 247 octets

(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 octets

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

Suite de tests .

Japt , 84 79 octets

-5 octets grâce à @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

La nouvelle ligne principale fait partie du programme. Prend une chaîne en entrée et renvoie un tableau de chaînes.

Essayez-le en ligne! avec le -Rdrapeau pour rejoindre le tableau résultant avec des sauts de ligne.

Ce n'est pas mon travail le plus fier, mais je l'ai au moins de 100 octets. Mon idée ici était de créer les parties supérieure et centrale, puis d'ajouter la partie supérieure, tournée à 180 °.

Python 2 , 220 213 octets

• Étonnamment plus longtemps que je ne l'avais imaginé.

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

Essayez-le en ligne!

PHP 7.1, 230 156 155 octets

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

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

panne

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 147 127 octets

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

Cela prend une liste de chaînes à un caractère et génère une matrice de chaînes à un caractère.

J'ai sauvé 18 octets en exploitant la symétrie à utiliser -let Cross/@lqui prend quelque chose comme un produit croisé de chacun des deux vecteurs 2D simples à prendre {x,y}pour {-y,x}. Fondamentalement, les deux directions initiales sont l'Est (bord supérieur) et Sud-ouest (bord supérieur droit). Ensuite, nous ajoutons des rotations à 90 degrés dans le sens antihoraire avec Cross: le nord pour le bord gauche et le sud-est pour le bord inférieur gauche. Ensuite, nous ajoutons les quatre autres morceaux en utilisant -lpour retourner les quatre que nous avons couverts.

Vous pouvez le tester sur le bac à sable avec quelque chose comme:

(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