Étant donné une chaîne d'entrée de longueur 2ou plus composée uniquement de caractères alphabétiques [A-Z]ou [a-z](votre choix s'ils sont tous en majuscules ou tout en minuscules), sortez une chaîne continue de caractères formant un motif double losange.

La chaîne d'entrée commence sur la ligne centrale et s'étend vers le bas et la droite en diagonale jusqu'à ce que la fin de la chaîne d'entrée soit atteinte. Ensuite, le motif continue de haut en bas sur une diagonale jusqu'à ce que vous soyez aussi loin au-dessus de la ligne médiane que la longueur de la chaîne d'entrée moins 1. Continuez de bas en haut jusqu'à la ligne médiane, puis de bas en haut. gauche, puis en haut et à gauche (en allant "derrière" le caractère central), et enfin en bas et à gauche jusqu'au caractère de départ.

C'est un peu verbeux, et c'est mieux démontré par quelques exemples:

"YOU"
  U   Y
 Y O U O
Y   O   U
 O Y U Y
  U   O

  ^   ^
 ↙ ↖ ↗ ↘
↘   ↗   >
 ↘ ↗ ↖ ↙
  V   V

Voyez comment YOUcommence la ligne médiane et suit de bas en haut, puis de haut en bas, etc., jusqu'à ce qu'elle revienne au début. Notez en particulier comment la Ypartie supérieure et gauche est "derrière" la Oet donc non représentée.

Quelques exemples supplémentaires:

"HI"
 I I
H H H
 I I

"TEST"
   E     E
  S T   T S
 T   T T   T
T     S     T
 E   E E   E
  S T   T S
   T     T

"HELLO"
    L       L
   O L     E L
  H   E   H   O
 E     H O     H
H       L       E
 E     L L     L
  L   E   L   L
   L H     E O
    O       H

• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• L'entrée est garantie sur au moins deux lettres (c'est-à-dire que vous ne recevrez jamais ""en entrée).
• Vous pouvez l'imprimer sur STDOUT ou le renvoyer en tant que résultat de fonction.
• Un programme complet ou une fonction sont acceptables.
• N'importe quelle quantité d'espace blanc étranger est acceptable, tant que les caractères s'alignent de manière appropriée (par exemple, n'hésitez pas à remplir comme un rectangle).
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Fusain , 17 octets

ＧＨ<↗↘>↖↙ＬθθＧＨ<Ｌθθ

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

ＧＨ

Tracez le long d'un chemin.

<↗↘>↖↙

Dessinez dans les directions ↘↗↗↘↙↖↖↙ (les <et >sont des raccourcis pour ces deux paires, mais les autres paires n'ont pas de raccourcis.)

Ｌθ

Chaque segment de chemin a la même longueur, y compris les extrémités, de la longueur de l'entrée.

θ

Utilisez l'entrée comme texte à écrire le long du chemin.

ＧＨ<Ｌθθ

Imprimez à nouveau les deux premières parties du chemin afin que le caractère du milieu soit correct.

05AB1E , 12 octets

gIR7._•Íη•Λ

Essayez-le en ligne!

           Λ    use the canvas function
g               with the length of input for each segment
 IR7._          the input reversed and rotated left by 7 characters (we will draw this backwards to have the right center character)
      •Íη•     and the directions 1, 3, 3, 1, 7, 5, 5, 7 as a compressed number. 

JavaScript (ES6),  157 155  154 octets

Renvoie une matrice de caractères.

s=>(y=n=s.length,y+=i=X=Y=-1,m=[...Array(y+n)].map(_=>r=Array(4*n-3).fill` `),g=x=>x?g(x-=r[m[y][++i==6*n-6||+x]=s[i%n],y-=m[y-Y]?Y:Y=-Y,x-X]?X:X=-X):m)``

Essayez-le en ligne!

Comment?

$n$$w\times h$

• $w = 4n-3$
• $h = 2n-1$

$(0,n-1)$

L'index de base 0 du caractère central qui doit être ignoré en forme de losange est:

$n=4$

Commenté

s => (                           // s = input string
  y = n = s.length,              // n = length of s
  y += i = X = Y = -1,           // y = n - 1; i = X = Y = -1
  m =                            // create a matrix m[]:
    [...Array(y + n)].map(_ =>   //   - of height 2n-1
      r = Array(4 * n - 3)       //   - of width 4n-3 (save one of these rows in r[])
          .fill` `               //   - initially filled with spaces
    ),                           //
    g = x =>                     // g is a recursive function taking x
      x ?                        //   if x is truthy:
        g(                       //     do a recursive call:
          x -= r[                //       update x:
            m[y][                //         update m[y][x]:
              ++i == 6 * n - 6   //           unless this is the 2nd pass through the
              || +x              //           center cell, set it to the next character
            ] = s[i % n],        //           in s (otherwise we write to m[y][true]
                                 //           instead, which has no effect)
            y -=                 //         update y:
              m[y - Y] ? Y       //           bounce vertically if m[y - Y] is undefined
                       : Y = -Y, //
            x - X                //         bounce horizontally
          ] ? X                  //         if r[x - X] is undefined
            : X = -X             //
        )                        //     end of recursive call
      :                          //   else:
        m                        //     stop recursion and return m[]
)``                              // initial call to g with x = [''] (zero-ish but truthy)

JavaScript (ES6), 136 octets

f=
(s,l=s.length-1,z=l*4,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `),g=x=>x--?g(x,a[a[y=(x+l)%z]?y:z-y][x>z?z+z-x:x]=s[x%-~l]):a)=>g(z+z)

<input oninput=o.textContent=f(this.value).map(c=&gt;c.join``).join`\n`><pre id=o>

Renvoie un tableau à deux dimensions. Fonctionne en dessinant la chaîne dans le tableau en calculant directement les coordonnées de destination en travaillant vers l'arrière à partir de la fin afin que la cellule centrale soit automatiquement remplacée. Explication:

(s

Chaîne d'entrée.

,l=s.length-1

Distance entre les "rebonds", également la moitié de l'index de la dernière ligne et une de moins que la longueur.

,z=l*4

Index de la dernière colonne, également la moitié de la longueur du texte à dessiner.

,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `)

Tableau d'espaces.

,g=x=>x--

Compte à rebours de la dernière cellule à la première.

  ?g(x

Appel récursif pour traiter les cellules restantes.

    ,a[a[y=(x+l)%z]?y:z-y]

Calculez la ligne de cette cellule.

      [x>z?z+z-x:x]=s[x%-~l])

Calculez la colonne de cette cellule et le caractère qui y appartient.

  :a

Terminez en renvoyant le tableau.

)=>g(z+z)

Commencez à la fin du texte.

J , ^{79 77} 75 octets

(|.@$~8*])`([:;/(1,~<:@])+/\@,(_2{&1 _1\#:33495)}.@#~])`(' '$~1+2 4*])}<:@#

Essayez-le en ligne!

C (bruit) , 201 196 188 octets

x,y,i,v,m,n;f(s,z){char*a=s,o[i=(y=z*2-1)*(x=y+y)];for(v=x*2-2;i;n=m=1)o[--i]=i%x?32:10;for(i=x*--z;v--;i+=x*m+n)o[i]==32?o[i]=*a:0,a=*++a?a:s,n=i%x>x-3?-1:n,m=i/x?i/x<y-1?m:-1:1;puts(o);}

Essayez-le en ligne!

-13 @ceilingcat suggestions

Python 2 , 137 octets

s=input();n=len(s);m=2*n-2
for r in range(m+1):print''.join([s[[x,-8-x][(x<=m)==(m>2*r)]%n],' '][r!=(x+1-n)%m!=m-r]for x in range(4*n-3))

Essayez-le en ligne!

Un programme complet qui prend une chaîne en entrée pour imprimer la version diamantée.