Wenn eine Eingabezeichenfolge mit einer Länge 2oder einer Länge, die ausschließlich aus alphabetischen Zeichen besteht, [A-Z]oder [a-z](nach Wahl in Groß- oder Kleinbuchstaben), wird eine fortlaufende Zeichenfolge ausgegeben, die ein doppeltes Rautenmuster bildet.

Die Eingabezeichenfolge beginnt auf der Mittellinie und verläuft diagonal nach unten und rechts, bis das Ende der Eingabezeichenfolge erreicht ist. Dann wird das Muster diagonal nach oben und rechts fortgesetzt, bis Sie so weit über der Mittellinie sind wie die Länge der Eingabezeichenfolge minus 1. Fahren Sie nach unten und rechts zurück zur Mittellinie, und dann nach unten und rechts. links, dann hoch und links ("hinter" dem mittleren Zeichen) und schließlich runter und links zurück zum Startzeichen.

Das ist ein bisschen wortreich und wird anhand einiger Beispiele besser demonstriert:

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

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

Sehen Sie, wie der YOUVorgang an der Mittellinie beginnt und nach unten und rechts, dann nach oben und rechts usw. abläuft, bis er zum Anfang zurückkehrt. Beachten Sie insbesondere, wie der Yobere und linke Teil "hinter" Ound daher nicht dargestellt ist.

Einige weitere Beispiele:

"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

• Die Ein- und Ausgabe kann auf jede bequeme Weise erfolgen .
• Die Eingabe ist garantiert mindestens zwei Buchstaben lang (dh, Sie werden niemals ""als Eingabe empfangen ).
• Sie können es an STDOUT drucken oder als Funktionsergebnis zurückgeben.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig.
• Beliebig viel fremdes Leerzeichen ist akzeptabel, solange die Zeichen richtig ausgerichtet sind (z. B. können Sie die Zeichen auch als Rechtecke auffüllen).
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Kohle , 17 Bytes

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

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

ＧＨ

Entlang eines Pfades zeichnen.

<↗↘>↖↙

Zeichne in die Richtungen ↘↗↗↘↙↖↖↙ (die <und >sind Abkürzungen für diese beiden Paare, aber die anderen Paare haben keine Abkürzungen.)

Ｌθ

Jedes Pfadsegment hat die gleiche Länge, einschließlich der Enden, der Länge der Eingabe.

θ

Verwenden Sie die Eingabe als Text, der entlang des Pfads geschrieben werden soll.

ＧＨ<Ｌθθ

Drucken Sie die ersten beiden Teile des Pfads erneut, damit das mittlere Zeichen korrekt ist.

05AB1E , 12 Bytes

gIR7._•Íη•Λ

Probieren Sie es online!

           Λ    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 Bytes

Gibt eine Zeichenmatrix zurück.

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

Probieren Sie es online!

Wie?

$n$$w\times h$

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

$(0,n-1)$

Der auf 0 basierende Index des mittleren Zeichens, der in der Rautenform übersprungen werden muss, lautet:

$n=4$

Kommentiert

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 Byte

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>

Gibt ein zweidimensionales Array zurück. Zeichnet die Zeichenfolge direkt in das Array und berechnet die Zielkoordinaten vom Ende an rückwärts, sodass die mittlere Zelle automatisch überschrieben wird. Erläuterung:

(s

Eingabezeichenfolge.

,l=s.length-1

Abstand zwischen "Bounces", ebenfalls die Hälfte des letzten Zeilenindex und eine unter der Länge.

,z=l*4

Letzter Spaltenindex, auch die Hälfte der zu zeichnenden Textlänge.

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

Array von Räumen.

,g=x=>x--

Countdown von der letzten bis zur ersten Zelle.

  ?g(x

Rekursiver Aufruf zur Verarbeitung der verbleibenden Zellen.

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

Berechnen Sie die Zeile dieser Zelle.

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

Berechnen Sie die Spalte dieser Zelle und das dazugehörige Zeichen.

  :a

Beenden Sie den Vorgang, indem Sie das Array zurückgeben.

)=>g(z+z)

Beginnen Sie am Ende des Textes.

J , ^{79 77} 75 Bytes

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

Probieren Sie es online!

C (Klappern) , 201 196 188 Bytes

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

Probieren Sie es online!

-13 @ceilingcat Vorschläge

Python 2 , 137 Bytes

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

Probieren Sie es online!

Ein vollständiges Programm, das eine Zeichenfolge als Eingabe verwendet, um die diamantierte Version auszudrucken.