Triangles hexagonaux!

20

Votre tâche: faire un triangle hexagonal avec une longueur de côté n, où nest un nombre entier positif ou 0.

Tout d'abord, permettez-moi de définir un hexagone:

 / \
|   |
 \ /

(Art ASCII incroyable, non?)

Les hexagones peuvent être liés entre eux en partageant les côtés:

 / \ / \
|   |   |
 \ / \ /

   / \  
  |   |
 / \ /
|   |
 \ /

Un triangle hexagonal est le suivant:

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

Ce triangle hexagonal a une longueur de côté de 2 à 2 hexagones sont nécessaires pour former un côté. Un triangle hexagonal de longueur latérale 1 n'est qu'un hexagone unique et un hexagone de longueur latérale 0 est vide.

Plus formellement, un triangle hexagonal est un triangle composé d'hexagones liés par leurs côtés. L'hexagone supérieur est lié aux deux ci-dessous sur ses deux côtés inférieurs. Le triangle en bas à gauche relie à celui à sa droite et en haut à droite, et celui en bas à droite renvoie à ceux à sa gauche et en haut à gauche. Il y a des hexagones entre les coins, reliés par leurs côtés opposés, et leur nombre est n-2. Les triangles ne sont pas remplis.

Plus d'exemples:

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 
— Camarade SparklePony
source
22
S'il n'y a pas de réponse Hexagony pour cela, je perdrai toute confiance en @MartinEnder.
— caird coinheringaahing du
@Soyoucanreplytomeincomments Disons simplement que si je pouvais suivre les utilisateurs ici, ils seraient sur la liste.
— phyrfox
1
— Dennis
2
Je m'attends à voir une réponse courte en charbon de bois. Je le ferais moi-même, mais je devrais d'abord l'apprendre, et je veux plutôt regarder un film, désolé.
— Neil
3
@Neil, vous êtes pardonné de ne pas avoir appris un tout nouveau langage de programmation. Mais c'est votre premier avertissement!
— caird coinheringaahing

Réponses:

11

Charbon de bois , 62 43 39 octets

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

Essayez-le en ligne! Edit: enregistré quelques octets grâce à @ ASCII uniquement (je ne sais pas exactement combien car j'ai également enregistré 6 10 octets supplémentaires, mais j'ai ensuite dû dépenser 4 octets pour corriger un bug). Maintenant, en utilisant des boucles imbriquées, c'est ce que cela aurait dû être tout au long.

— Neil
source
45 octets: Ａ / \¶| |¶ \ /αＮβＦβ«α←←»Ｆβ«α↖↖Ｍ⁶←»Ｆβ«αＭ⁴↑←←(btw charbon de bois complète automatiquement tout ce qui est nécessaire »à la fin)
— ASCII uniquement
@ ASCII uniquement Malheureusement, je n'arrive plus à trouver la documentation de Charcoal, donc je n'ai aucune idée de ce que fait votre code.
— Neil
les commandes sont sur le wiki ici , fondamentalement 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);}, chacune pour la boucle dessine un côté
— ASCII uniquement
Donc, à peu près ce que vous faisiez, mais avec la chaîne enregistrée en tant que variable
— ASCII uniquement
@ ASCII uniquement En inversant le sens du dessin, j'ai pu enregistrer 2 octets supplémentaires. (Je suis également légèrement déçu que la meilleure façon de dessiner l'hexagone soit un littéral de chaîne, mais au moins cela le rend facile à répéter.)
— Neil
7

Python 2, 184 177 174 164 164 octets

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

Essayez-le en ligne!

-7 octets grâce à Ørjan Johansen

— accro aux mathématiques
source
Il vous manque le |s le plus à droite sur les trois premiers et la rangée hexagonale inférieure.
— Ørjan Johansen du
p[:4]*(i+2)au lieu de p[:4]*(i+1)semble le réparer.
— Ørjan Johansen
Vous n'utilisez que bdans un seul endroit, donc la combinaison avec votre ~astuce, w=' '*2*~(i-n)est 7 octets plus court.
— Ørjan Johansen
@ ØrjanJohansen Merci, le code a subi beaucoup de refactoring et j'ai oublié de changer ces choses
— junkie math
6

JavaScript (ES6), 243 octets

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>
Développer l'extrait

— Neil
source
4

JavaScript (ES6), 133 129 128 126 126 octets

Construit le caractère de sortie par caractère avec deux boucles for .

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}

Comment ça fonctionne

Dans la boucle externe, y itère de n * 2-1 à -1 . Dans la boucle interne, x itère de n * 4-1 à -1 . Nous définissons k = (x + y) & 3 , qui est le motif sous-jacent utilisé pour générer les hexagones.

Voici la grille résultante pour 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

Sur les lignes paires, une cellule est remplie d'un caractère de tuyau lorsque k = 3 et d'un espace sinon. Le tuyau est le 5ème caractère de notre chaîne de référence" \ /|", donc l'index correct est donné par (k + 1) & 4 .

Sur les lignes impaires, chaque cellule est remplie directement avec le caractère correspondant dans la chaîne de référence:

  • k = 0 → espace
  • k = 1 → "\"
  • k = 2 → espace
  • k = 3 → "/"

Voici notre exemple mis à jour (espaces remplacés par des points):

     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 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .

Dans les formules suivantes, nous définissons N = n * 4 pour la lisibilité (bien que la même variable soit utilisée dans le code).

La forme du triangle est obtenue en testant:

  • x> y - 2 → supprime le coin droit
  • ET x <N - y → supprime le coin gauche

Et la partie intérieure est retirée en testant:

  • x> N - y - 6 → ne garde que le bord gauche
  • OU x <y + 4 → ne garde que le bord droit
  • OU y <2 → ne conserve que le bord inférieur

Démo

Afficher l'extrait de code

— Arnauld
source
Ça [x>y-2&x<n-y&(x>n-y-6|x<y+4|y<2)&&y&1?x+y&3:x-~y&4]marche?
— Neil
@Neil Hmm, je ne pense pas. Nous aurions besoin de parenthèses autour de l'expression ternaire et ce (x+y+1)&4n'est pas la même chose que (((x+y)&3)+1)&4.
— Arnauld
Non, bien sûr que non. À quoi je pensais ...
— Neil
3

Gelée ,  62  61 octets

Contient actuellement six six.

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

Essayez-le en ligne!

Comment?

_‘<×⁸>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
source
Il y a un manquant >dans l'explication ( <space)
— Roman Gräf
@ RomanGräf merci j'ai édité l'explication! Si vous vouliez simplement dire plus que "le ẋsous-espace dans l'explication est mal aligné", faites-le moi savoir.
— Jonathan Allan
1

Mathematica, 155 octets

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

avec \nremplacé par une nouvelle ligne.

Plus lisible:

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

Crée un tableau de caractères, indexé par i de 1 à 4 n + 1 horizontalement et j de 1 à 2 n + 1 verticalement. Tout d'abord, Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]remplit une grille hexagonale:

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

le If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",...]remplace ensuite par l' " "extérieur du triangle non rempli.

— Pas un arbre
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.