Introducción

De Wikipedia :

Un mosaico de una superficie plana es el mosaico de un plano que utiliza una o más formas geométricas, llamadas mosaicos, sin superposiciones y sin huecos.

A continuación se muestra una teselación bastante conocida:

Los rombos están en mosaico de una manera que no produce solapamientos ni huecos, y simula el intercambio de columnas de cubos.

Tarea

Su tarea es escribir un programa que tesele rombos de la misma manera que la imagen de arriba. La entrada para el programa serán las dimensiones de la teselación: height x widthdonde ancho es la cantidad de columnas y altura es la cantidad de filas.

Un cubo simple que es 1 x 1(3 fichas de rombo) se representa exactamente de la siguiente manera:

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

Entonces, si las entradas / dimensiones son 3 x 2, esta debería ser la salida:

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

Como puede ver, hay 3 filas (alto) y 2 columnas (ancho). Las columnas se intercambian arriba y abajo. Su programa también debería hacer esto y comenzar más alto. Por ejemplo, 3 x 3sería:

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

Reglas

• El resultado se debe generar, la entrada se puede tomar de la forma que desee, pero debe corresponder con la altura y el ancho
• Se permiten nuevas líneas al final
• Las columnas de teselación siempre comienzan desde arriba y luego se alternan hacia arriba y hacia abajo
• Los lados de las teselaciones deben compartirse y las teselaciones deben colocarse correctamente entre las otras columnas sin espacios.
• Su envío puede ser una función o un programa completo
• Su programa debe imprimir exactamente la salida anterior dada la misma entrada; en otras palabras, la salida debe seguir el mismo formato para cubos / teselaciones

Supuestos

• Puede suponer que la entrada siempre será mayor que 1 x 1, por lo que no necesita casos en los que se ingrese un cero

Puntuación

Este es el código de golf , por lo que gana el código más corto en bytes. Las lagunas estándar también están prohibidas.

JavaScript (ES6), 243 bytes

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>

Calcula directamente todos los caracteres deseados. Para /:

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

Para \:

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

Para _:

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 ​​bytes

&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!*+
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /
    _____

Pruébalo en línea!

Esta pregunta parecía engañosamente fácil, pero los casos extremos resultaron ser más complicados de lo que había previsto originalmente. El mejor enfoque que se me ocurrió fue manejar las columnas pares e impares como representaciones separadas, y luego fusionar los resultados.

Entonces, para cada coordenada x, y que se debe generar, primero debemos determinar qué carácter se debe representar para una columna impar, asignando las coordenadas de salida x , y a las coordenadas u , v en el diagrama de cubos de la siguiente manera:

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

La adición de (y==0)es para manejar el caso especial de la primera línea. Pero también debemos asegurarnos de no mostrar las últimas líneas en la parte inferior de la columna y los últimos caracteres al final de cada fila. Esto se logra multiplicando el carácter de salida con la expresión:

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

El !(columns%2)cálculo en el ancho se debe a que la cantidad que necesitamos recortar al final depende de si el recuento total de columnas es par o impar.

Luego hacemos un segundo cálculo para determinar qué carácter se debe representar para una columna par, mapeando las coordenadas u , v de la siguiente manera:

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

Este es el mismo cálculo básico que se usa para las columnas impares, pero se compensa ligeramente. Y como antes, debemos asegurarnos de no representar algunos de los caracteres en los límites, esta vez las primeras líneas en la parte superior de la columna, así como algunos caracteres al principio y al final de cada fila. La expresión que multiplicamos en este caso es:

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

Una vez calculados estos dos caracteres de salida potenciales, el valor final utilizado es:

char1 + (char2 * !char1) + 32

En otras palabras, si char1 es cero, necesitamos generar char2 , de lo contrario, generará char1 . Si ambos no son cero, solo vamos a generar char1 , pero eso está bien porque ambos serían el mismo valor de todos modos. También tenga en cuenta que estos valores de caracteres están compensados ​​por 32 (por lo tanto, la adición de 32) para que cero siempre termine como un espacio.

Lote, 590 bytes

@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%

La :csubrutina toma tres parámetros; %3es la diferencia entre 1 y 2 columnas, %2es la diferencia entre 2 y 3 columnas, %1es el prefijo adicional para la primera columna, entonces una columna es %1%2, dos columnas es %1%2%3, tres columnas es %1%2%3%2, cuatro columnas es %1%2%3%2%3etc.

Python 2 , 329 326 319 bytes

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)

Pruébalo en línea!

En realidad 21 24 31 bytes más corto que mi publicación incorrecta anterior. Crea listas para las columnas pares e impares y luego las concatena para cada columna en el ancho.