Sechseckige Dreiecke!

20

Ihre Aufgabe: Machen Sie ein sechseckiges Dreieck mit Seitenlänge n, wobei neine positive ganze Zahl oder 0 ist.

Lassen Sie mich zunächst ein Sechseck definieren:

 / \
|   |
 \ /

(Erstaunliche ASCII-Kunst, oder?)

Sechsecke können durch Teilen von Seiten miteinander verbunden werden:

 / \ / \
|   |   |
 \ / \ /

   / \  
  |   |
 / \ /
|   |
 \ /

Ein sechseckiges Dreieck ist das folgende:

   / \
  |   |
 / \ / \
|   |   |
 \ / \ /

Dieses sechseckige Dreieck hat eine Seitenlänge von 2 bis 2 Sechsecken, um eine Seite herzustellen. Ein sechseckiges Dreieck mit der Seitenlänge 1 ist nur ein einzelnes Sechseck, und ein Sechseck mit der Seitenlänge 0 ist leer.

Ein sechseckiges Dreieck ist ein Dreieck aus Sechsecken, die durch ihre Seiten miteinander verbunden sind. Das obere Sechseck ist an den beiden unteren Seiten mit den beiden darunterliegenden Sechsecken verbunden. Das Dreieck in der linken unteren Ecke ist mit dem Dreieck in der rechten oberen Ecke und dem Dreieck in der rechten unteren Ecke und dem Dreieck in der linken oberen Ecke verbunden. Es gibt Sechsecke zwischen den Ecken, die durch ihre gegenüberliegenden Seiten verbunden sind, und ihre Anzahl ist n-2. Die Dreiecke sind nicht ausgefüllt.

Mehr Beispiele:

Side length 3:
     / \
    |   |
   / \ / \
  |   |   |
 / \ / \ / \
|   |   |   |
 \ / \ / \ /

Side length 4:
       / \
      |   |
     / \ / \
    |   |   |
   / \ / \ / \
  |   |   |   |
 / \ / \ / \ / \
|   |   |   |   |
 \ / \ / \ / \ /
(This triangle isn't really filled, the borders make it look like there is a hexagon in the middle, but there is not.)

Side length 5:
         / \
        |   |
       / \ / \
      |   |   |
     / \ / \ / \
    |   |   |   |
   / \ /     \ / \
  |   |       |   |
 / \ / \ / \ / \ / \
|   |   |   |   |   |
 \ / \ / \ / \ / \ /

Side length 6:
           / \
          |   |
         / \ / \
        |   |   |
       / \ / \ / \
      |   |   |   |
     / \ /     \ / \
    |   |       |   |
   / \ /         \ / \
  |   |           |   |
 / \ / \ / \ / \ / \ / \
|   |   |   |   |   |   |
 \ / \ / \ / \ / \ / \ /
code-golf  ascii-art  geometry  hexagonal-grid 
— Genosse SparklePony
quelle
22
Wenn es dafür keine Hexagony-Antwort gibt, verliere ich jegliches Vertrauen in @MartinEnder.
— Caird Coinheringaahing
@Soyoucanreplytomeincomments Sagen wir einfach, wenn ich den Benutzern hier folgen könnte, wären sie auf der Liste.
— Phyrfox
1
— Dennis
2
Ich erwarte eine kurze Antwort in Charcoal. Ich würde es selbst machen, aber ich müsste es zuerst lernen und ich möchte stattdessen einen Film sehen, sorry.
— Neil
3
@Neil dir ist verziehen, dass du keine völlig neue Programmiersprache gelernt hast. Aber das ist deine erste Warnung!
— Caird Coinheringaahing

Antworten:

11

Charcoal , 62 43 39 Bytes

ＮβＦ³«Ｆ⁻β‹ι²« / \¶|   |¶ \ /Ｍײι↑¿⁻¹ιＭ⁶←

Probieren Sie es online!Bearbeiten: Einige Bytes nur dank @ ASCII gespeichert (ich weiß nicht genau, wie viele ich auch weitere 6 bis 10 Bytes gespeichert habe, aber dann 4 Bytes für einen Bugfix ausgeben musste). Verwenden Sie jetzt verschachtelte Schleifen.

— Neil
quelle
45 Bytes: Ａ / \¶| |¶ \ /αＮβＦβ«α←←»Ｆβ«α↖↖Ｍ⁶←»Ｆβ«αＭ⁴↑←←(übrigens wird jede »am Ende benötigte Kohle automatisch vervollständigt )
— Nur ASCII
@ Nur ASCII Leider kann ich die Charcoal-Dokumentation nicht mehr finden, daher habe ich keine Ahnung, was Ihr Code bewirkt.
— Neil
befehle sind hier im wiki , grundsätzlich Assign(hexagon_with_space_to_left, a);InputNumber(b);for(b){Print(a);Move(:Left);Move(:Left);}for(b){Print(a);Move(:UpLeft);Move(:UpLeft);Move(6, :Left);}for(b){Print(a);Move(4, :Up);Move(:Left);Move(:Left);}zeichnet jede for schleife eine seite
— ASCII
So ziemlich genau, was Sie getan haben, aber mit der Zeichenfolge als Variable gespeichert
— ASCII
@ Nur ASCII Durch Umkehren der Zeichenrichtung konnten weitere 2 Bytes eingespart werden. (Ich bin auch etwas enttäuscht darüber, dass die beste Art, das Sechseck zu zeichnen, ein String-Literal ist, aber das macht es zumindest leicht, es zu wiederholen.)
— Neil,
7

Python 2, 184 177 174 164 Bytes

n=input();p='|   |';e=' \\ /'
for i in range(n):k=' '*(4*i-5);w='  '*~(i-n);print w+[' / \\'*-~i+'\n'+w+p[:4]*i+p,' /'+e+k[3:]+e+' \\\n'+w+p+k+p][2<i<n-1]
print e*n

Probieren Sie es online!

-7 Bytes dank Ørjan Johansen

— Mathe-Junkie
quelle
In |den oberen drei Reihen und in der unteren sechseckigen Reihe fehlt das rechte s.
— Ørjan Johansen
p[:4]*(i+2)statt p[:4]*(i+1)scheint es zu beheben.
— Ørjan Johansen
Sie verwenden nur ban einer Stelle. Wenn Sie dies mit Ihrem ~Trick kombinieren, sind Sie w=' '*2*~(i-n)7 Byte kürzer.
— Ørjan Johansen
@ ØrjanJohansen Danke, der Code wurde viel überarbeitet und ich habe vergessen, diese Dinge zu ändern
— Math Junkie
6

JavaScript (ES6), 243 Byte

f=n=>(n=n*2-2,a=[...Array(n+3)].map(_=>Array(n*2+5).fill` `),g=(y,x)=>(a[y+1][x]=a[y+1][x+4]=`|`,a[y][x+1]=a[y+2][x+3]=`/`,a[y][x+3]=a[y+2][x+1]=`\\`),[...Array(n+!n)].map((_,i)=>i%2||(g(n,i*2),g(i,i=n-i),g(i,n+i))),a.map(a=>a.join``).join`
`)
<input type=number oninput=o.textContent=f(this.value)><pre id=o>
Erweitern Sie das Snippet

— Neil
quelle
4

JavaScript (ES6), 133 129 128 126 Bytes

Erstellt die Ausgabe zeichenweise mit zwei for- Schleifen.

n=>{for(s='',y=n*2,n*=4;~y--;s+=`
`)for(x=n;~x--;)s+=' \\ /|'[x>y-2&x<n-y&(k=x+y&3,x>n-y-6|x<y+4|y<2)?y&1?k:k+1&4:0];return s}

Wie es funktioniert

In der äußeren Schleife iteriert y von n * 2-1 bis -1 . In der inneren Schleife iteriert x von n * 4-1 bis -1 . Wir setzen k = (x + y) & 3 , welches das zugrunde liegende Muster ist, das zur Erzeugung der Sechsecke verwendet wird.

Unten ist das resultierende Gitter für n = 4 :

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 6 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 5 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 4 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
 3 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 2 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 1 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 0 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
-1 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2

In geraden Zeilen wird eine Zelle mit einem Pipe-Zeichen gefüllt, wenn k = 3 ist , und ansonsten mit einem Leerzeichen. Die Pipe ist das fünfte Zeichen in unserer Referenzzeichenfolge " \ /|", daher wird der richtige Index durch (k + 1) & 4 angegeben .

In ungeraden Zeilen wird jede Zelle direkt mit dem entsprechenden Zeichen in der Referenzzeichenfolge gefüllt:

  • k = 0 → Leerzeichen
  • k = 1 → ""
  • k = 2 → Leerzeichen
  • k = 3 → "/"

Unten sehen Sie unser aktualisiertes Beispiel (Leerzeichen durch Punkte ersetzt):

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 6 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 5 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 4 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
 3 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 2 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 1 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 0 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
-1 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .

In den folgenden Formeln definieren wir N = n * 4 für die Lesbarkeit (obwohl dieselbe Variable im Code verwendet wird).

Die Dreiecksform wird durch Testen erhalten:

  • x> y - 2 → Entfernt die rechte Ecke
  • AND x <N - y → entfernt die linke Ecke

Und der innere Teil wird durch Testen entfernt:

  • x> N - y - 6 → behält nur den linken Rand bei
  • ODER x <y + 4 → behält nur den rechten Rand bei
  • ODER y <2 → behält nur die Unterkante bei

Demo

Code-Snippet anzeigen

— Arnauld
quelle
Does [x>y-2&x<n-y&(x>n-y-6|x<y+4|y<2)&&y&1?x+y&3:x-~y&4]Arbeit?
— Neil
@ Neil Hmm, ich glaube nicht. Wir brauchen Klammern um den ternären Ausdruck und (x+y+1)&4sind nicht dasselbe wie (((x+y)&3)+1)&4.
— Arnauld
Nein, das ist es natürlich nicht. Was dachte ich ...
— Neil
3

Jelly ,  62  61 Bytes

Derzeit enthält sechs Sechser.

_‘<×⁸>6
Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥
ḤḶUẋ@€⁶;"ǵ-ịṙ6ṭ⁸Y

Probieren Sie es online!

Wie?

_‘<×⁸>6 - Link 1, should we eat the praline? row number, triangle size
_       - row number minus triangle size
 ‘      - plus one
  <     - less than triangle size? (1 if one of the last rows else 0)
   ×⁸   - multiply by row number   (row number or 0)
     >6 - greater than 6?          (row number if between row 6 and last two rows)

Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥ - Link 2, build a solid triangle: triangle size
                                              (except the very bottom row)
R                                  - range: [1,2,...,size]
 µ                                 - monadic chain separation, call that r
  ‘                                - increment: [2,3,...,size+1]
   ⁾| <space                       - literal "| "
      ẋ                            - repeat: ["| | ","| | | ",...]
            ¤                      - nilad followed by link(s) as a nilad:
       ⁾/\                         -   literal "/\"
           ⁸                       -   link's left argument, r
          ẋ                        -   repeat (vectorises): ["/\","/\/\",...]
             ż                     - zip the two repeated lists together: [["/\","| | "],["/\/\","| | | "],...]
              ;/                   - reduce by concatenation: ["/\","| | ","/\/\","| | | ",...]
                K€                 - join with spaces for €ach: ["/ \","|   |  ","/ \ / \","|   |   |  ",...]
                  µ                - monadic chain separation call that s
                                 ¥ - last two links a a dyad:
                               J   -   range(length(s))  
                                ç  -   call the last (1) link as a dyad (left = result of J, right = size)
                              "    - zip with: (call those d)
                    ð       ð¦     -   apply to indexes:
                   ⁶               -   a literal space character
                     M             -     indexes of maximal elements in an element of s (a row)
                      Ṁ            -     maximum (this is the rightmost non-space index, MṀ working like length ignoring trailing spaces)
                       _6          -     subtract 6  (6 indexes back from the right)
                         r6        -     range from there to 6, i.e [l-6,l-7,...,6]
                           ẋ       -     repeat d times (1 or 0), thus applying to the middle rows but not the bottom and top ones.

ḤḶUẋ@€⁶;"ǵ-ịṙ6ṭ⁸Y - Main link: triangle size
Ḥ                  - double(size)
 Ḷ                 - unlength: [0,1,2,...,double(size)-1]
  U                - upend: [double(size)-1,...,2,1,0]
      ⁶            - literal space character
   ẋ@€             - repeat for €ach with reversed arguments ["  ...  ",...,"  "," ",""]
         Ç         - call the last link (2) as a monad(size)
       ;"          - zip with concatenation (zips the leading spaces with the solid triangle body)
          µ        - monadic chain separation, call that t
           -ị      - index -1 (last but one row of t)
             ṙ6    - rotate left by 6 (any number congruent to 2 mod 4 would do)
               ṭ⁸  - tack to t (add this new row on)
                 Y - join all the rows by new lines
                   - implicit print
— Jonathan Allan
quelle
>In der Erklärung fehlt ( <space)
— Roman Gräf
@ Romangräf danke ich habe die erklärung bearbeitet! Wenn Sie nur mehr als "das ẋunter dem Raum in der Erklärung ist falsch ausgerichtet" gemeint haben , lassen Sie es mich wissen.
— Jonathan Allan
1

Mathematica, 155 Bytes

""<>Table[If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]],{j,(d=2#)+1},{i,4#+1}]~Riffle~"\n"&

mit \ndurch eine newline ersetzt.

Besser lesbar:

"" <> Table[
    If[i+j < d || i-j > d+1 || 
      i+j > d+5 && i-j < d-3 && j < d-1, " ", 
     Switch[Mod[i+d+{j,-j}, 4], {1, 3}, "/", {3, 1}, 
      "\\", {1, 1}, "|", _, " "]], {j, (d=2#)+1}, {i, 4#+1}]~
   Riffle~"\n" &

Erstellt ein Array von Zeichen, die horizontal mit i von 1 bis 4 n + 1 und vertikal mit j von 1 bis 2 n + 1 indiziert werden . Zunächst Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]füllt in einem hexagonalen Gitter:

 \ / \ / \ / \ / 
  |   |   |   |  
 / \ / \ / \ / \ 
|   |   |   |   |
 \ / \ / \ / \ / 
  |   |   |   |  
 / \ / \ / \ / \ 
|   |   |   |   |
 \ / \ / \ / \ /

dann If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",...]ersetzt diese mit " "außerhalb des ungefüllten Dreiecks.

— Kein Baum
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.