bac à sable

Pour les besoins de la tâche en cours, un cube de longueur unitaire est rendu en projection oblique avec des symboles ASCII comme suit:

  +-----+
 /     /|
+-----+ |
|     | +
|     |/
+-----+

• + pour les sommets.
• -pour les X bords. L'unité de longueur le long de X est représentée par cinq -entre deux sommets.
• |pour les bords en Y. L'unité de longueur le long de Y est représentée par deux |entre deux sommets.
• /pour les bords Z. L'unité de longueur le long de Z est représentée par une /entre deux sommets.
• Les sommets ne sont tracés que là où les trois plans se coupent.
• Les bords ne sont dessinés que là où exactement deux plans se croisent.

Lorsqu'une face d'unité est extrudée, elle est décalée d'une longueur d'unité par rapport à sa position d'origine et quatre nouvelles arêtes sont créées pour chaque direction (positive et négative).

Vous pouvez imaginer que l'extrusion consiste à dessiner les axes d'un système de coordonnées cartésien 3D, chaque axe étant représenté par un cuboïde avec une section transversale de 1x1 et une ndistance de (0,0,0).

Extrudé par 1 le long de X:

  +-----------------+
 /                 /|   
+-----------------+ |
|                 | +
|                 |/
+-----------------+

Tâche

A partir de trois nombres pour les axes XYZ, extrudez les faces d'un cube unité de manière symétrique par les quantités indiquées et restituez le résultat avec les symboles ASCII comme spécifié ci-dessus.

Contribution

x, y, z - nombres non négatifs - longueurs d'extrusion pour les axes respectifs. 0 signifie pas d'extrusion. L'entrée peut être trois chiffres, une liste de trois chiffres, un triple, une chaîne ou tout ce qui vous convient.

Sortie

Le dessin ASCII du cube après extrusion. Les espaces libres de début et de fin sont autorisés.

Cas de test

X Y Z
0 0 0

  +-----+
 /     /|
+-----+ |
|     | +
|     |/
+-----+

1 0 0

  +-----------------+
 /                 /|   
+-----------------+ |
|                 | +
|                 |/
+-----------------+


0 0 1   
        +-----+
       /     /|
      /     / |
     /     /  +
    /     /  /
   /     /  /
  +-----+  /
  |     | / 
  |     |/
  +-----+


1 1 0

        +-----+
       /     /|      
      +-----+ |
  +---|     | +-----+
 /    |     |/     /|
+-----+     +-----+ |
|                 | +
|                 |/
+-----+     +-----+
      |     | +
      |     |/
      +-----+

2 0 1

                +-----+
               /     /|
  +-----------+     +-----------+
 /                             /|
+-----------+     +-----------+ |
|          /     /|           | +
|         +-----+ |           |/
+---------|     | +-----------+
          |     |/
          +-----+

1 1 1 

        +-----+
       /     /|-+   
      +-----+ |/|
  +---|     | +-----+
 /    |     |/     /|
+-----+-----+-----+ |
|    /     /|     | +
|   +-----+ |     |/
+---|     | +-----+
    |     |/| +
    +-----+ |/
      +-----+

Critères gagnants

La solution la plus courte en octets dans toutes les langues gagne. Veuillez ajouter une brève description de la méthode utilisée et votre code.

JavaScript (ES6),  525 ... 475 471  459 octets

13 octets sauvés grâce à @Neil

Prend les entrées sous forme de tableau [X,Y,Z]. Retourne une matrice de caractères.

a=>([X,Y,Z]=a,m=[],W=X*6+Z*2,'1uol9h824lsqpq17de52u1okgnv21dnjaww111qmhx1gxf4m50xg6pb42kzijq21xyh34t0h2gueq0qznnza2rrimsg3bkrxfh3yrh0em').replace(/.{7}/g,s=>[[c,x,A,y,B,w,C,h,D,t]=parseInt(s,36)+s,Y*W,Z,X,Y|!W,Z*X,X*Y*!Z,X*Z*!Y,Y*Z*!X][c]&&(g=H=>V<h&&((m[r=y-(3-B)*p+(t>1?H-V:V)+Y*3+Z*2]=m[r]||Array(W*2+9).fill` `)[x-2*(3-A)*p+(t>1?V:H-V*t)+W]=` ${c>5?'  + ':t>1?'|-':'-|'}+/+`[(H%~-w?0:+t?4:2)|!(V%~-h)],g(++H<w?H:!++V)))(V=0,p=a[c%3],w-=-3*C*p,h-=-D*p))&&m

Essayez-le en ligne!

Comment?

Étapes de dessin

La sortie comprend 15 côtés, dessinés dans un ordre spécifique.

la mise en oeuvre

La fonction de dessin est $g$ . Cela fonctionne avec les paramètres suivants:

• $(x, y)$ : par où commencer à dessiner
• $w$ : largeur
• $h$ : hauteur
• $t$ : type de côté

Les sommets sont toujours dessinés. Selon la valeur d'un autre paramètre $c$ , les arêtes sont dessinées ou effacées.

Si $t=0$ , la fonction dessine une face avant:

...........      ...........
..+-----+..      ..+     +..
..|     |..  or  ..       ..
..|     |..      ..       ..
..+-----+..      ..+     +..
...........      ...........

Si $t=1$ , il dessine un côté supérieur:

...........      ...........
...+-----+.      ...+     +.
../     /..  or  ..       ..
.+-----+...      .+     +...
...........      ...........

$t=2$

......+....      ......+....
...../|....      .....  ....
....+ |....  or  ....+  ....
....| +....      ....  +....
....|/.....      ....  .....
....+......      ....+......

$(x,y)$$(w,h)$$X$$Y$$Z$

$c \in[1..8]$

Pour résumer, un côté est complètement décrit avec:

$$\begin{cases} c\\ t\\ x=o_x+m_x\times P\\ y=o_y+m_y\times P\\ w=o_w+m_w\times P\\ h=o_h+m_h\times P \end{cases}$$

$P$$c$

Par conséquent, nous devons stocker les 10 paramètres suivants pour chaque côté:

$$[c, o_x, m_x, o_y, m_y, o_w, m_w, o_h, m_h, t]$$

Vous trouverez ci-dessous les paramètres des 15 côtés à dessiner:

$$\begin{array}{|c|c|} \hline \text{side} & c & o_x & m_x & o_y & m_y & o_w & m_w & o_h & m_h & t\\ \hline 0 & 4 & 0 & 0 & 2 & -3 & 7 & 0 & 4 & 6 & 0\\ 1 & 4 & 6 & 0 & 2 & -3 & 4 & 6 & 3 & 0 & 2\\ 2 & 2 & 6 & -2 & 2 & 2 & 4 & 0 & 3 & 4 & 2\\ 3 & 3 & 6 & 6 & 2 & 0 & 4 & 0 & 3 & 0 & 2\\ 4 & 3 & 0 & -6 & 2 & 0 & 7 & 12 & 4 & 0 & 0\\ 5 & 2 & 2 & 2 & 0 & -2 & 7 & 0 & 3 & 4 & 1\\ 6 & 3 & 2 & -6 & 0 & 0 & 7 & 12 & 3 & 0 & 1\\ 7 & 2 & 0 & -2 & 2 & 2 & 7 & 0 & 4 & 0 & 0\\ 8 & 5 & 6 & -2 & 2 & 2 & 4 & 0 & 1 & 2 & 2\\ 9 & 4 & 2 & 0 & 0 & -3 & 7 & 0 & 3 & 0 & 1\\ 10 & 1 & 0 & 0 & 2 & -3 & 7 & 0 & 1 & 3 & 0\\ 11 & 1 & 6 & 0 & 2 & -3 & 1 & 3 & 3 & 0 & 2\\ 12 & 6 & 0 & 0 & 2 & 0 & 7 & 0 & 4 & 0 & 0\\ 13 & 7 & 2 & 0 & 0 & 0 & 7 & 0 & 3 & 0 & 1\\ 14 & 8 & 6 & 0 & 2 & 0 & 4 & 0 & 3 & 0 & 2\\ \hline \end{array}$$

$[0..9]$

$$m_x\gets (m_x+6)/2\\ m_y\gets m_y+3\\ m_w\gets m_w/3$$

Il en résulte 15 chiffres d’exactement 10 chiffres décimaux, qui sont stockés dans 15 groupes de 7 chiffres en base 36.

Par exemple, le premier côté est codé 4032070460et stocké sous 1uol9h8.

APL (Dyalog Classic) , 162 161 132 130 octets

{' |+/+ +-? ??? ++'[⍉(⊃~∘0)⍤1⍣3⍉↑a↑¨⍨↓(--1-⌊/∘,)2-/1⌽↑⍳⍴a←16|29|1+{2⊥+/¨∊¨=⌿¨⍵(⍉⍵)(⍉↓⍵)}⌺2 2 2{⍉⍤2⍉⌽0,⍵}⍣6↑3/↓2/6⌿1<⍵+.=⍨↑⍳1+2×⍵]}

Essayez-le en ligne!

• générer un tableau 3D bool de cubes d'unités
• répliquer chaque cube 6 3 2 fois le long de xyz
• entourer de zéros
• pour chaque 2 x 2 x 2 sous - matrice calculer un nombre compris entre 0 et 16 qui détermine le produit de carbonisation de sortie correspondant: (1 + 4*cx + 2*cy + cz) mod 16où cx, cy, czsont le nombre de même valeur « tiges » le long de l' axe x, y, z, à savoir des vecteurs le long de cet axe qui se composent de la même valeur: 0 0 ou 1 1. Nous faisons une exception si le sous-tableau est tout à zéro (ou tout à un - ceux qui comptent n'a pas d'importance) et nous considérons son nombre 0 au lieu de 28
• pour chaque cellule calculer où le caractère correspondant doit être dessiné à l'écran
• pour chaque cellule, construisez une matrice transparente (à remplissage 0) contenant un seul "pixel" opaque
• mélangez les matrices - à ce stade, nous avons un tableau 5d de dimensions inx, iny, inz, outx, outy
• réduire les trois premiers axes en ne conservant que le premier élément non transparent (0)
• utiliser une table de correspondance (une chaîne) pour convertir les nombres en -|/+

Merci Scott Milner pour repérer que certains +s rendus comme ?s

Charbon de bois , 325 octets

≔×⁶Ｎθ≔׳Ｎη≔⊗Ｎζ¿‹¹№⟦θηζ⟧⁰«Ｂ⁺⁷⊗θ⁺⁴⊗η↗↗⊕⊗ζ+⁺⁵⊗θＰ↙⊗⊕ζ↓+↓⁺²⊗η↙+↙⊕⊗ζ»«Ｆ‹⁰θ«↗+↗←+←⊖θ↙+/Ｐ→θ↓+↓²+⊖θ+»Ｆ‹⁰η«Ｊ⁶¦³↗+↗↓+↓⊖η↙+/Ｐ↑η←+←⁵↑+↑⊖η+»Ｆ‹⁰ζ«Ｊ⁸±²↓+↓↓↗+↗⊖ζ↑+↑²Ｐ↙ζ←+←⁵↙+↙⊖ζ+»Ｊ⁶¦⁰Ｆ‹⁰ζ«Ｇ↓³↙⊕ζ←⁷↑³↗⊕ζ ↙+↙⊖ζ↓+↓²+→⁵Ｐ↗ζ↑+↑²Ｐ←⁶↗+↗⊖ζ»Ｆ‹⁰η«Ｇ←⁶↑⊕η↗³→⁶↓⊕η ↑+↑⊖η←+←⁵↙+/Ｐ↓η+⁵Ｐ↗²↓+↓⊖η»Ｆ‹⁰θ«Ｇ↗²→⊕θ↓⁴↙²←⊕θ →+⊖θ↗+/↑+↑²Ｐ←θ↙+/Ｐ↓³←+←⊖θ»Ｐ↗∧∧θη²Ｐ↓∧∧ζθ³Ｐ←∧∧ηζ⁶+

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

≔×⁶Ｎθ≔׳Ｎη≔⊗Ｎζ

Entrez les extrusions, mais prémultipliez-les pour économiser des octets.

¿‹¹№⟦θηζ⟧⁰«Ｂ⁺⁷⊗θ⁺⁴⊗η↗↗⊕⊗ζ+⁺⁵⊗θＰ↙⊗⊕ζ↓+↓⁺²⊗η↙+↙⊕⊗ζ»«

Si au moins deux des extrusions sont nulles, tracez simplement un cuboïde de dimensions (2x + 1, 2y + 1, 2z + 1). Autrement:

Ｆ‹⁰θ«↗+↗←+←⊖θ↙+/Ｐ→θ↓+↓²+⊖θ+»

Imprimer l'extrusion de gauche, le cas échéant.

Ｆ‹⁰η«Ｊ⁶¦³↗+↗↓+↓⊖η↙+/Ｐ↑η←+←⁵↑+↑⊖η+»

Imprimez l'extrusion vers le bas, le cas échéant.

Ｆ‹⁰ζ«Ｊ⁸±²↓+↓↓↗+↗⊖ζ↑+↑²Ｐ↙ζ←+←⁵↙+↙⊖ζ+»

Imprimer l'extrusion arrière, le cas échéant.

Ｊ⁶¦⁰

Les extrusions restantes se rencontrent toutes à ce stade (qui ne sera pas tiré avant la fin!)

Ｆ‹⁰ζ«Ｇ↓³↙⊕ζ←⁷↑³↗⊕ζ ↙+↙⊖ζ↓+↓²+→⁵Ｐ↗ζ↑+↑²Ｐ←⁶↗+↗⊖ζ»

Imprimez les extrusions avant, le cas échéant, en prenant soin d’effacer les parties des extrusions gauche et inférieure qui peuvent se chevaucher.

Ｆ‹⁰η«Ｇ←⁶↑⊕η↗³→⁶↓⊕η ↑+↑⊖η←+←⁵↙+/Ｐ↓η+⁵Ｐ↗²↓+↓⊖η»

Imprimez l’extrusion, le cas échéant, en prenant soin d’effacer les parties du dos et les extrusions laissées qui peuvent se chevaucher.

Ｆ‹⁰θ«Ｇ↗²→⊕θ↓⁴↙²←⊕θ →+⊖θ↗+/↑+↑²Ｐ←θ↙+/Ｐ↓³←+←⊖θ»

Imprimez la bonne extrusion, le cas échéant, en prenant soin d’effacer les parties des extrusions vers le bas et vers le bas qui peuvent se chevaucher.

Ｐ↗∧∧θη²Ｐ↓∧∧ζθ³Ｐ←∧∧ηζ⁶+

Dessinez les jointures entre ces dernières extrusions.

Charbon de bois , 195 164 144 octets

≔⁺³×⁶Ｎθ≔⁺²×³Ｎη≔⊕⊗ＮζＦ…·±ζζＦ…·±ηηＦ…·±θθ«Ｊ⁻λι⁺κι≔⟦⟧δＦＥ²↔⁻⁺ιμ·⁵ＦＥ²↔⁻κνＦＥ²↔⁻⁺λξ·⁵⊞δ⌊⟦‹μζ‹νη‹ξθ‹¹№Ｅ⟦μνξ⟧‹π⊕ρ¹⟧≡Σδ¹+²§ |-/⁺⌕δ¹⌕⮌δ¹¦³+⁴§ +Σ…δ⁴¦⁶§ |-/⌕δ⁰

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Je publie cette réponse séparément, car elle utilise une approche complètement différente pour dessiner l'extrusion. Explication:

≔⁺³×⁶Ｎθ≔⁺²×³Ｎη≔⊕⊗Ｎζ

Entrez les extrusions et calculez la moitié de la taille du cuboïde englobant, mais en arithmétique sur nombres entiers, car les plages de Charcoal sont toujours des entiers. L'origine de la sortie est mappée sur le centre du cube d'unité d'origine.

Ｆ…·±ζζＦ…·±ηηＦ…·±θθ«

Boucle sur toutes les coordonnées à l'intérieur (y compris la limite) du cuboïde contenant l'extrusion.

Ｊ⁻λι⁺κι

Aller à la position de sortie correspondant à ces coordonnées.

≔⟦⟧δＦＥ²↔⁻⁺ιμ·⁵ＦＥ²↔⁻κνＦＥ²↔⁻⁺λξ·⁵⊞δ⌊⟦‹μζ‹νη‹ξθ‹¹№Ｅ⟦μνξ⟧‹π⊕ρ¹⟧

À partir des coordonnées indiquées, examinez les huit directions en diagonale afin de déterminer si l’extrusion se chevauche dans cette direction. Les coordonnées détectées sont vérifiées dans le cuboïde, puis le nombre d'axes dans lesquels la coordonnée se trouve dans le cube d'origine doit être supérieur à 1. Notez que, comme le cube a une hauteur d'affichage impaire, les valeurs de l'axe Y qui sont regardés sont des entiers tandis que les autres axes utilisent des coordonnées fractionnaires.

≡Σδ

Considérez le nombre de directions dans lesquelles l'extrusion se chevauche. Il y a cinq cas d’intérêt où nous voulons imprimer quelque chose, comme dans le cas de zéro, cela signifie que c’est un espace vide et que nous ne voulons rien imprimer, alors que dans le cas de huit, cela signifie que c’est à l’intérieur. l'extrusion et tout ce que nous avons imprimé seraient surimprimés par une couche plus proche du point de vue.

¹+

Si l'extrusion ne se chevauche que dans une direction, il s'agit d'un coin externe et nous devons générer un +.

²§ |-/⁺⌕δ¹⌕⮌δ¹¦

Si l'extrusion se chevauche dans deux directions, il s'agit d'un bord extérieur. Quelle sorte d'arête est déterminée à partir de la séparation entre les deux chevauchements; 6 et 7 sont des bords tournés vers l'arrière et seront écrasés, 4 est un bord diagonal, 2 est un bord vertical et 1 est un bord horizontal. (En fait, je calcule 7 moins la séparation car cela semble être plus facile à faire.)

³+

Si l'extrusion se chevauche dans trois directions, il s'agit d'un coin interne dans le cas où l'une des extrusions est égale à zéro et que nous devons générer un +.

⁴§ +Σ…δ⁴¦

Si l'extrusion se chevauche dans quatre directions, il y a deux cas: les faces (toutes directions) et les angles intérieurs dans le cas de trois extrusions positives. Dans ce dernier cas, il existe un nombre impair de chevauchements vers le spectateur.

⁶§ |-/⌕δ⁰

Si l'extrusion se chevauche dans six directions, il s'agit d'un bord intérieur. Cela fonctionne comme le complément d'un bord extérieur, sauf que nous ne sommes intéressés que lorsqu'un des deux espaces vides est la direction vers le point de l'oeil (la dernière entrée du tableau).

K (ngn / k) , 172 octets

{s:1+|/'i-:&//i:1_--':1_4#!#'2*:\a:16!29!1+2/(!3){+'+x}/'{2+':''1+':'0=':x}'{++'x}\6{+'+0,|x}/{6}#{3}#'{2}#''s#1<+/x=!s:1+2*x;" |+/+ +-? ??? ++"s#@[&*/s;s/i;{x+y*~x};,//a]}

Essayez-le en ligne!

réécriture k obligatoire de ma solution apl

Même algorithme, sauf que le rendu 3d-> 2D est réalisé avec (l'équivalent de k) d'affectation d'indice de dispersion au lieu de créer des matrices 2D pour chaque élément 3D et de les mélanger.