Introdução

Da Wikipedia :

Um mosaico de uma superfície plana é o lado a lado de um avião usando uma ou mais formas geométricas, chamadas ladrilhos, sem sobreposições e sem espaços.

Um mosaico bastante conhecido é mostrado abaixo:

Os rhombi são lado a lado de uma maneira que não resulta em sobreposições ou lacunas e simula a troca de colunas de cubos.

Tarefa

Sua tarefa é escrever um programa que combine o losango da mesma maneira que a imagem acima. A entrada para o programa será as dimensões do mosaico:, em height x widthque largura é a quantidade de colunas e altura é a quantidade de linhas.

Um único cubo que é 1 x 1(3 peças de rhombi) é representado exatamente da seguinte maneira:

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

Portanto, se as entradas / dimensões forem 3 x 2, esta deve ser a saída:

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

Como você pode ver, existem 3 linhas (altura) e 2 colunas (largura). As colunas estão trocando para cima e para baixo. Seu programa também deve fazer isso e começar mais alto. Por exemplo, 3 x 3seria:

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

Regras

• O resultado deve ser gerado, a entrada pode ser feita da maneira que você quiser, mas deve corresponder à altura e largura
• Novas linhas à direita são permitidas
• As colunas de mosaico sempre começam de cima e alternam para cima e para baixo
• Os lados dos mosaicos devem ser compartilhados e os mosaicos devem ser colocados corretamente entre as outras colunas, sem espaços
• Seu envio pode ser uma função ou um programa completo
• Seu programa deve imprimir exatamente a saída acima, com a mesma entrada; em outras palavras, a saída deve seguir o mesmo formato para cubos / pavimentações

Premissas

• Você pode assumir que a entrada sempre será maior que 1 x 1, portanto, você não precisa de casos em que um zero é inserido

Pontuação

Isso é código-golfe , então o código mais curto em bytes vence. As brechas padrão também são proibidas.

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 diretamente todos os caracteres desejados. 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!*+
  /\      \
 /  \      \
/    \ _____\
\    /      /
 \  /      /
  \/_____ /
    _____

Experimente online!

Essa pergunta parecia enganosamente fácil, mas os casos extremos tornaram-se mais complicados do que eu havia previsto inicialmente. A melhor abordagem que eu poderia ter foi lidar com as colunas pares e ímpares como renderizações separadas e depois mesclar os resultados.

Portanto, para cada coordenada x, y que deve ser produzida, primeiro precisamos determinar qual caractere deve ser renderizado para uma coluna ímpar, mapeando as coordenadas de saída x , y para as coordenadas u , v no diagrama do cubo da seguinte maneira:

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

A adição de (y==0)é para lidar com o caso especial da primeira linha. Mas também precisamos garantir que não renderizamos as últimas linhas na parte inferior da coluna e os últimos caracteres no final de cada linha. Isso é obtido multiplicando o caractere de saída com a expressão:

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

O !(columns%2)cálculo da largura ocorre porque a quantidade que precisamos cortar no final depende de a contagem total de colunas ser par ou ímpar.

Em seguida, fazemos um segundo cálculo para determinar qual caractere deve ser renderizado para uma coluna par, mapeando as coordenadas u , v da seguinte maneira:

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

Este é o mesmo cálculo básico usado para as colunas ímpares, mas ligeiramente compensado. E, como antes, precisamos garantir que não renderizamos alguns dos caracteres nos limites - desta vez, as primeiras linhas na parte superior da coluna, bem como alguns caracteres no início e no final de cada linha. A expressão que multiplicamos neste caso é:

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

Depois de calcular esses dois caracteres de saída em potencial, o valor final usado é:

char1 + (char2 * !char1) + 32

Em outras palavras, se char1 é zero, precisamos gerar char2 , caso contrário, produzimos char1 . Se ambos são diferentes de zero, vamos apenas gerar char1 , mas tudo bem, porque ambos teriam o mesmo valor. Observe também que esses valores de caracteres são deslocados em 32 (daí a adição de 32), para que o zero sempre acabe como um espaço.

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%

A :csub-rotina usa três parâmetros; %3é a diferença entre 1 e 2 colunas, %2é a diferença entre 2 e 3 colunas, %1é o prefixo extra da primeira coluna; portanto, uma coluna é %1%2, duas colunas são %1%2%3, três colunas é %1%2%3%2, quatro colunas é, quatro colunas é %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)

Experimente online!

Na verdade, 21 24 31 bytes mais curtos do que minha postagem incorreta anterior. Cria listas para as colunas ímpares e pares e concatena-as para cada coluna na largura.