HexaGolf: Wordagons

25

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.

Beta-Zerfall
quelle
14
Bonuspunkte, wenn jemand dies in Hexagony tut? ;)
Kevin Cruijssen
Kann die Eingabezeichenfolge Zeilenumbrüche enthalten? Ich denke nicht, dass es ein Implementierungsproblem darstellen würde, sondern nur ungültige Wordagons
Aaron
@Aaron Nein, die Eingabezeichenfolge wird niemals Zeilenumbrüche enthalten
Beta Decay
Ist es in Ordnung, wenn die Ausgabe eine Zeichenfolge mit Zeilenumbrüchen ist, die von einer Funktion zurückgegeben werden?
Daniel
2
Aww. Ich bin enttäuscht, weil ich den Titel als "word-dragons" gelesen habe ...
mbomb007

Antworten:

19

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!

Lynn
quelle
2
Elegante Lösung.
DavidC
1
Sie können die y's durchlaufen , indem Sie einen n=len(s)\nwhile 1:n-=1;y=abs(n);...Fehler machen und abbrechen.
Xnor
10

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.

asciicast

Lynn
quelle
3
Würde dies nicht als Tastendruck gezählt?
Soren
1
@moo_we_all_do Nein. Dies ist Code-Golf (im Gegensatz zu Editor-Golf), daher sollten alle Antworten in Bytes bewertet werden.
Martin Ender
Die zweite @qbewirkt für mich eine Endlosschleife. Es funktioniert perfekt, wenn es entfernt wird.
MTCoster
6

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"

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

hexa

DavidC
quelle
5
Können Sie uns mitteilen, wie der Stern ausgesehen hat? : D
Beta Decay
Sicher. Es ist jetzt gebucht.
DavidC
2
Wow, das ist ein netter Star
Beta Decay
3

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
Level River St
quelle
3

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
Neil
quelle
1

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!

Emigna
quelle
0

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:])
Daniel
quelle
0

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 .

nl-x
quelle