Siehe auch: Rotation

Herausforderung

Wenn Sie eine Zeichenfolge als Eingabe angeben, geben Sie ihr Wortzeichen aus.

Wordagons

Ein Wortagon ist eine Möglichkeit, eine Zeichenfolge in einem Sechseck darzustellen. Jetzt erstellen wir ein Wort aus der Zeichenfolge hexa:

Zunächst beginnen Sie mit dem ersten Zeichen in der Zeichenfolge und platzieren es in der Mitte:

h

Dann nehmen Sie das nächste Zeichen in der Zeichenfolge und fügen eine hexagonale Ebene hinzu:

 e e
e h e
 e e

Dann füge die nächste Ebene hinzu:

  x x x
 x e e x
x e h e x
 x e e x
  x x x

Fügen Sie zum Schluss die letzte Ebene hinzu:

   a a a a
  a x x x a
 a x e e x a
a x e h e x a
 a x e e x a
  a x x x a
   a a a a

Und Sie haben jetzt das Wort für die Zeichenfolge hexa.

Beispiele

Hier sind einige, die ich zuvor vorbereitet habe:

hello

    o o o o o
   o l l l l o
  o l l l l l o
 o l l e e l l o
o l l e h e l l o
 o l l e e l l o
  o l l l l l o
   o l l l l o
    o o o o o

PPcg

   g g g g
  g c c c g
 g c P P c g
g c P P P c g
 g c P P c g
  g c c c g
   g g g g

o *

  * * *
 *     *
*   o   *
 *     *
  * * *

(T_T)

    ) ) ) ) )
   ) T T T T )
  ) T _ _ _ T )
 ) T _ T T _ T )
) T _ T ( T _ T )
 ) T _ T T _ T )
  ) T _ _ _ T )
   ) T T T T )
    ) ) ) ) )

Beachten Sie, dass nachfolgende und / oder führende Zeilenumbrüche zulässig sind.

Gewinnen

Der kürzeste Code in Bytes gewinnt.

Pyth - 29 Bytes

j+_K.e+*kdjdjF+*bhk*L2>zhkztK

Test Suite .

Python 2, 83 Bytes

s=input()
l=len(s)
while 1:l-=1;y=abs(l);print' '*y+' '.join(s[:y:-1]+s[y]*y+s[y:])

Druckt das Wordagon und stürzt dann ab (was nur in STDERR gedruckt wird).

Beispiel:

% python2.7 wordagon.py <<<'"abcde"' 2&>/dev/null
    e e e e e
   e d d d d e
  e d c c c d e
 e d c b b c d e
e d c b a b c d e
 e d c b b c d e
  e d c c c d e
   e d d d d e
    e e e e e

xnor sparte 5 Bytes. Vielen Dank!

Vim, 92 Bytes

:se ri|s/./ &/g
ⓋCⓇ"Ⓓ␛$vpmlmrqqYpi ␛`ljxxhmlylv`rjlmr:s/\%V\(.\)./Ⓡ" /g
@qq@qVdy2G:g/^/m0
Gp

Eingekreiste Buchstaben stehen für Control+ Buchstaben; ␛ ist Flucht.

Mathematica 100 219 Bytes

Wenn ASCII-Art nicht Terminal-Art sein muss, sollte dies gültig sein.

Meine frühere Vorlage zeichnete fälschlicherweise eher einen Stern als ein Sechseck. Ich kann nicht sehen, wie es mir so schlecht ging!

c = CirclePoints@6;
f@s_:=Graphics[{Text[s~StringPart~1,{0,0}],Flatten@Table[Text[StringPart[s,n+1],#]&/@Subdivide[Sequence@@#,n]&/@Partition[Riffle[(n)CirclePoints@6,RotateLeft[n CirclePoints@6]],2],{n,1,StringLength@s-1}]},BaseStyle->20]

CirclePoints@6 Gibt die Eckpunkte eines Einheitssechsecks zurück, vorausgesetzt, der Mittelpunkt befindet sich am Ursprung.

SubdivideWenn Sie die Koordinaten für benachbarte Scheitelpunkte eingeben, werden Positionen mit gleichem Abstand entlang der jeweiligen Kante gefunden.

Ein Zähler von 1 bis zur StringLength -1Eingabezeichenfolge ermöglicht, dass jede Ebene des Wordagons separat behandelt wird.
Mit nzunehmendem Abstand jedes Scheitelpunkts vom Ursprung nimmt auch der Abstand zu.

Text[s~StringPart~1,{0,0}] druckt den ersten Buchstaben der Eingabe am Ursprung.

f @ "Wordagon"

Für die Neugierigen sah die Star-Version so aus. Ich weiß, es war weit weg von der Marke. Es wurden nur die Buchstaben an den Eckpunkten des Sechsecks angezeigt.

Graphics@Table[Text[Style[StringPart[#, r + 1], 54], r {Cos@t, Sin@t}], {t, 0, 2π, π/3}, {r, 0, StringLength@# - 1}] &["Hexa"]

Ruby, 82 Bytes

->s{n=s.size-1
(r=-n..n).map{|i|(" "*k=i.abs)+r.map{|j|s[[k+j,k,-j].max]}*" "}*$/}

iteriert 1-n..n-1sowohl in i = y- als auch in j = x-Richtung. Ohne die führenden Leerzeichen in jeder Zeile sieht die Ausgabe wie folgt aus, da ein Zeichen aus s dem Index ausgewählt wurde [[i.abs+j,i.abs,-j].max]. Das Hinzufügen von führenden Leerzeichen bildet das erforderliche Sechseck.

f f f f
f l l l f
f l o o l f
f l o G o l f
f l o o l f
f l l l f
f f f f

Ungolfed im Testprogramm

f=->s{
  n=s.size-1             n=string length - 1
  (r=-n..n).map{|i|      iterate from -n to n, build an array of lines
    (" "*k=i.abs)+       k=i.abs. Start each line with k spaces.
    r.map{|j|            iterate from -n to n, build an array of characters.
      s[[k+j,k,-j].max]  select character from s (store null string in array if index past end of string)
    }*" "                concatenate the array of characters into a line, separated by spaces
  }*$/                   concatenate the array of lines into a single string, separate by newlines
}

puts f[gets.chomp]

Typische Ausgabe

   f f f f
  f l l l f
 f l o o l f
f l o G o l f
 f l o o l f
  f l l l f
   f f f f

JavaScript (ES6), 118 Byte

s=>[...Array((l=s.length-1)*2+1)].map((_,i,a)=>a.map((_,j)=>s[Math.max(i-l,l-i,j-l,i-j,l+l-i-j)]||``).join` `).join`\n`

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt. Basierend auf meiner Antwort auf die Hexplosive ASCII-art-Herausforderung, obwohl Teile der Lösung der Ruby-Antwort von @ LevelRiverSt ähneln. Die verschiedenen Komponenten von Math.maxerzeugen die folgende Ausgabe für l=3:

    i - l           l - i           j - l            i - j        l + l - i - j
- - - - - - -   3 3 3 3 3 3 3   - - - 0 1 2 3    0 - - - - - -    6 5 4 3 2 1 0
- - - - - - -   2 2 2 2 2 2 2   - - - 0 1 2 3    1 0 - - - - -    5 4 3 2 1 0 -
- - - - - - -   1 1 1 1 1 1 1   - - - 0 1 2 3    2 1 0 - - - -    4 3 2 1 0 - -
0 0 0 0 0 0 0   0 0 0 0 0 0 0   - - - 0 1 2 3    3 2 1 0 - - -    3 2 1 0 - - -
1 1 1 1 1 1 1   - - - - - - -   - - - 0 1 2 3    4 3 2 1 0 - -    2 1 0 - - - -
2 2 2 2 2 2 2   - - - - - - -   - - - 0 1 2 3    5 4 3 2 1 0 -    1 0 - - - - -
3 3 3 3 3 3 3   - - - - - - -   - - - 0 1 2 3    6 5 4 3 2 1 0    0 - - - - - -

Der Maximalwert wird genommen und die Werte, die größer als lsind, werden entfernt, wodurch die Sechseckform erzeugt wird, während die verbleibenden Werte Zeichen aus der Zeichenfolge zugeordnet werden:

6 5 4 3 3 3 3      3 3 3 3          a a a a
5 4 3 2 2 2 3     3 2 2 2 3        a x x x a
4 3 2 1 1 2 3    3 2 1 1 2 3      a x e e x a
3 2 1 0 1 2 3   3 2 1 0 1 2 3    a x e h e x a
4 3 2 1 1 2 3    3 2 1 1 2 3      a x e e x a
5 4 3 2 2 2 3     3 2 2 2 3        a x x x a
6 5 4 3 3 3 3      3 3 3 3          a a a a

05AB1E , 31 Bytes

R.pvy`¹gN-©×NFs.ø}Sðý®ð×ì})¦«»

Erläuterung

Verwenden Sie die Symmetrie, um nur den oberen Teil des Sechsecks zu generieren,
und spiegeln Sie diesen dann, um den unteren Teil zu bilden.

R.pv                     }       # for each prefix of the reversed string
                                 # ['f', 'fl', 'flo', 'floG']
    y`                           # split into chars, ex: 'f', 'l', 'o'
      ¹gN-©×                     # repeat the last char len(input)-N times, 
                                 # where N is the 0-based list index of the current prefix
                                 # ex: 'oo'
            NF   }               # N times do
              s.ø                # surround current char with the next char on stack
                                 # ex: 'floolf'
                  Sðý            # insert spaces between each letter, ex: 'f l o o l f'
                     ®ð×ì        # prefix string with len(input)-N spaces
                                 # ex: '  f l o o l f'
                          )      # wrap all strings in a list
                           ¦    # create a reversed copy of the list and 
                                 # remove the first item (as we only need the middle once)
                             «»  # concatenate the lists and merge with newlines

Probieren Sie es online!

Python 2, 104 Bytes

def f(s):
 for n in range(len(s)*2-1):x=abs(n-len(s)+1);print' '*x+' '.join(s[x+1:][::-1]+s[x]*x+s[x:])

PHP - 202 Bytes

$w=$argv[1];$l=$i=$a=strlen($w)-1;while(-$l<=$i){$s=join(" ",str_split(str_repeat($w[$l],($a-1)/2).substr($w,$a?$a:1,$l+1),1));echo str_pad("",$a).strrev($s).($a%2?" ":" {$w[$a]} ")."$s
";$a=abs(--$i);}

Verwendung von der Kommandozeile:

php.exe -r "put the escaped code here" "put your desired word here"

beispielsweise:

php.exe -r "$w=$argv[1];$l=$i=$a=strlen($w)-1;while(-$l<=$i){$s=join(\" \",str_split(str_repeat($w[$l],($a-1)/2).substr($w,$a?$a:1,$l+1),1));echo str_pad(\"\",$a).strrev($s).($a%2?\" \":\" {$w[$a]} \").\"$s\n\";$a=abs(--$i);}" "example"

Test Suite .