introduction

De Wikipédia :

Une tessellation d'une surface plane est le carrelage d'un plan en utilisant une ou plusieurs formes géométriques, appelées tuiles, sans chevauchements ni espaces.

Un pavage assez bien connu est illustré ci-dessous:

Les losanges sont carrelés d'une manière qui n'entraîne aucun chevauchement ni espace et simule des colonnes de cubes interchangeables.

Tâche

Votre tâche consiste à écrire un programme qui mosaïque les losanges de la même manière que l'image ci-dessus. L'entrée pour le programme sera les dimensions de la tessellation:, height x widthoù la largeur est la quantité de colonnes et la hauteur est la quantité de lignes.

Un seul cube qui est 1 x 1(3 tuiles de losanges) est représenté exactement comme suit:

    _____
  /\      \
 /  \      \
/    \ _____\ 
\    /      /
 \  /      /  
  \/_____ /   

Donc, si les entrées / dimensions sont 3 x 2, cela devrait être la sortie:

    _____
  /\      \
 /  \      \
/    \ _____\ _____
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
  /\      \    /      /
 /  \      \  /      /
/    \ _____\/_____ /
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
  /\      \    /      /
 /  \      \  /      /
/    \ _____\/_____ /
\    /      /\      \
 \  /      /  \      \
  \/_____ /    \ _____\
          \    /      /
           \  /      /
            \/_____ /

Comme vous pouvez le voir, il y a 3 lignes (hauteur) et 2 colonnes (largeur). Les colonnes changent de haut en bas. Votre programme devrait le faire aussi et commencer plus haut. Par exemple, 3 x 3serait:

    _____               _____
  /\      \           /\      \
 /  \      \         /  \      \
/    \ _____\ _____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
  /\      \    /      /\      \
 /  \      \  /      /  \      \
/    \ _____\/_____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
  /\      \    /      /\      \
 /  \      \  /      /  \      \
/    \ _____\/_____ /    \ _____\
\    /      /\      \    /      /
 \  /      /  \      \  /      /
  \/_____ /    \ _____\/_____ /
          \    /      /
           \  /      /
            \/_____ /

Règles

• Le résultat doit être sorti, la saisie peut être prise comme vous le souhaitez mais doit correspondre à la hauteur et à la largeur
• Les retours à la ligne sont autorisés
• Les colonnes de pavage commencent toujours par le haut puis alternent de haut en bas
• Les côtés des pavages doivent être partagés et les pavages doivent être correctement placés entre les autres colonnes sans espaces
• Votre soumission peut être une fonction ou un programme complet
• Votre programme doit imprimer exactement la sortie ci-dessus étant donné la même entrée; en d'autres termes, la sortie doit suivre le même format pour les cubes / pavages

Hypothèses

• Vous pouvez supposer que l'entrée sera toujours supérieure à 1 x 1, vous n'avez donc pas besoin de cas où un zéro est entré

Notation

Il s'agit de code-golf , donc le code le plus court en octets l'emporte. Les failles standard sont également interdites.

JavaScript (ES6), 243 octets

f=
(h,w)=>[...Array(h*6+4)].map((_,i)=>[...Array(w*9+3)].map((_,j)=>i&&(i+j+3)%6==0&&j%9<(i>3?6:3)&&(i>3|j<w*9)&&(j>2|i<h*6)?'/':i&&(i-j+2)%6==0&&j%9<(i>h*6?j<w*9?3:0:6)?'\\':i%3==0&&j>2&&(i*3+j+14)%18%(!i|i>h*6?18:12)<4?'_':' ').join``).join`
`

<div oninput=o.textContent=+h.value&&+w.value?f(h.value,w.value):''><input id=h type=number min=1><input id=w type=number min=1><pre id=o>

Calcule directement tous les caractères souhaités. Pour /:

i&&                         Not on first row of output
(i+j+3)%6==0&&              Backward diagonals
j%9<                        Not on top (right) diamond of hexagons or
    (i>3?6:3)&&             empty spaces on top half row
(i>3|j<w*9)&&               Not on top right corner of output
(j>2|i<h*6)                 Not on bottom left corner of output

Pour \:

i&&                         Not on first row of output
(i-j+2)%6==0&&              Forward diagonals
j%9<                        Not on bottom (right) diamond of hexagons or
    (i>h*6?                 empty spaces on bottom half row or
        j<w*9?3:0:6)        bottom right corner of output

Pour _:

i%3==0&&                    Every third line
j>2&&                       Not on left two columns
(i*3+j+14)%18%              Every 18 characters
    (!i|i>h*6?18:12)<4      One or two groups

Befunge, 277 269 ​​octets

&6*4+00p&:55+*3+10p2%20pv@
6+5:g03%*54:::<<0+55p03:<<v%*54++55:\p04:**`+3g03g00`\g01+*3!g02\-*84g+3+!\%
48*+,1+:10g`!#^_$,1+:00g-|>30g:2+6%\3-!+3+g48*-\:2`\20g3*+10g\`*30g2`**40g!*+
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /
    _____

Essayez-le en ligne!

Cette question semblait trompeusement facile, mais les cas marginaux se sont révélés plus compliqués que je ne l'avais prévu à l'origine. La meilleure approche que j'ai pu trouver était de gérer les colonnes paires et impaires en tant que rendus séparés, puis de simplement fusionner les résultats.

Donc, pour chaque coordonnée x, y qui doit être sortie, nous devons d'abord déterminer quel caractère doit être rendu pour une colonne impaire, en mappant les coordonnées de sortie x , y aux coordonnées u , v dans le diagramme de cube comme suit:

u = x%20
v = (y+5)%6 + (y==0)

L'ajout de (y==0)est pour gérer le cas particulier de la première ligne. Mais nous devons également nous assurer que nous ne rendons pas les dernières lignes en bas de la colonne et les derniers caractères à la fin de chaque ligne. Ceci est réalisé en multipliant le caractère de sortie par l'expression:

(y > h-3) && (x > w-3*!(columns%2))

le !(columns%2) dans le calcul de la largeur est dû au fait que la quantité dont nous avons besoin pour couper l'extrémité dépend du nombre total de colonnes, pair ou impair.

Nous faisons ensuite un deuxième calcul pour déterminer quel caractère doit être rendu pour une colonne paire, en cartographiant les coordonnées u , v comme suit:

u = (x+10)%20
v = (y+2)%6 + (y==3)

Il s'agit du même calcul de base que celui utilisé pour les colonnes impaires, mais légèrement décalé. Et comme auparavant, nous devons nous assurer que nous ne rendons pas certains des caractères sur les limites - cette fois les premières lignes en haut de la colonne, ainsi que certains caractères au début et à la fin de chaque ligne. L'expression que nous multiplions dans ce cas est:

(y > 2) && (x > 2) && (x < w-3*(columns%2))

Après avoir calculé ces deux caractères de sortie potentiels, la valeur finale utilisée est:

char1 + (char2 * !char1) + 32

En d'autres termes, si char1 est nul, nous devons sortir char2 , sinon nous sortirons char1 . Si les deux sont différents de zéro, nous allons simplement afficher char1 , mais c'est très bien car ils auraient tous les deux la même valeur de toute façon. Notez également que ces valeurs de caractères sont décalées de 32 (d'où l'ajout de 32) de sorte que zéro finira toujours par un espace.

Lot, 590 octets

@echo off
set c=call:c 
set b=\      \
set f=%b:\=/%
set s=       
set u=_____
set w=%2
%c%"   " " %u%" "%s%%s%"
%c%"  " "/%b%" "%s%    "
%c%" " "/  %b%" "%s%  "
%c%"" "/    \ %u%\" " %u% "
for /l %%i in (1,1,%1)do %c%"\" "    %f%" "%b%"&%c%" \" "  %f%" "  %b%"&%c%"  \" "/%u% /" "    \ %u%\"&if %%i lss %1 %c%"  /" "%b%" "    %f%"&%c%" /" "  %b%" "  %f%"&%c%"/" "    \ %u%\" "/%u% /"
%c%"   " "" "%s%\    %f%"
%c%"  " "" "  %s%\  %f%"
%c%" " "" "    %s%\/%u% /"
exit/b
:c
set o=%~1
for /l %%j in (%w%,-2,1)do call set o=%%o%%%~2&if %%j gtr 1 call set o=%%o%%%~3
echo(%o%

Le :csous-programme prend trois paramètres; %3est la différence entre 1 et 2 colonnes, %2est la différence entre 2 et 3 colonnes, %1est le préfixe supplémentaire pour la première colonne, donc une colonne est %1%2, deux colonnes est %1%2%3, trois colonnes est %1%2%3%2, quatre colonnes est %1%2%3%2%3etc.

Python 2 , 329 326 319 octets

h,w=input()
a,R=[' '*10]*3,range
b='  /\      \  # /  \      \ #/    \ _____\#\    /      /# \  /      / #  \/_____ /  '.split('#')
c=['    _____    ']+b*h
e,o=c+a,a+c
k=len(e)
f=e[:]
o[3]=o[3][:10]
for x in R(1,w):
 for y in R(k):f[y]+=((e[y][3:],e[y])[y in R(4)],(o[y][3:],o[y])[y in R(k-3,k)])[x%2]
print'\n'.join(f)

Essayez-le en ligne!

En fait, 21 24 31 octets de moins que mon message incorrect précédent. Crée des listes pour les colonnes paires et impaires puis les concatène pour chaque colonne dans la largeur.