introduzione

Da Wikipedia :

Una tassellatura di una superficie piana è la piastrellatura di un piano utilizzando una o più forme geometriche, chiamate tessere, senza sovrapposizioni e spazi vuoti.

Di seguito è riportata una tassellazione abbastanza nota:

I rombi sono piastrellati in un modo che non provoca sovrapposizioni o lacune e simula lo scambio di colonne di cubi.

Compito

Il tuo compito è quello di scrivere un programma che tessera i rombi allo stesso modo dell'immagine sopra. L'input per il programma saranno le dimensioni della tassellatura:, height x widthdove larghezza è la quantità di colonne e altezza è la quantità di righe.

Un cubo singolo 1 x 1(3 tessere di rombo) è rappresentato esattamente come:

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

Quindi, se l'input / le dimensioni sono 3 x 2, questo dovrebbe essere l'output:

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

Come puoi vedere, ci sono 3 righe (altezza) e 2 colonne (larghezza). Le colonne si stanno scambiando su e giù. Anche il tuo programma dovrebbe farlo e iniziare più in alto. Ad esempio, 3 x 3sarebbe:

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

Regole

• Il risultato deve essere emesso, l'input può essere preso come preferisci ma deve corrispondere ad altezza e larghezza
• Sono consentite nuove righe finali
• Le colonne di tassellatura iniziano sempre dall'alto, quindi si alternano su e giù
• I lati delle tessellazioni devono essere condivisi e le tessellazioni devono essere posizionate correttamente tra le altre colonne senza spazi vuoti
• L'invio può essere una funzione o un programma completo
• Il tuo programma deve stampare esattamente l'output sopra dato lo stesso input; in altre parole, l'output deve seguire lo stesso formato per cubi / tassellazioni

ipotesi

• Puoi presumere che l'input sarà sempre maggiore di 1 x 1, quindi non hai bisogno di casi in cui viene immesso uno zero

punteggio

Questo è code-golf , quindi vince il codice più breve in byte. Sono inoltre vietate le scappatoie standard .

JavaScript (ES6), 243 byte

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>

Calcola direttamente tutti i caratteri desiderati. Per /:

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

Per \:

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

Per _:

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

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

Provalo online!

Questa domanda sembrava ingannevolmente facile, ma i casi limite si sono rivelati più complicati di quanto avessi inizialmente previsto. L'approccio migliore che ho potuto trovare è stato quello di gestire le colonne pari e dispari come rendering separati e quindi unire i risultati.

Quindi per ogni coordinata x, y che deve essere emessa, dobbiamo prima determinare quale carattere deve essere riprodotto per una colonna dispari, mappando le coordinate di output x , y su coordinate u , v nel diagramma del cubo come segue:

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

L'aggiunta di (y==0)è di gestire il caso speciale della prima riga. Ma dobbiamo anche assicurarci di non visualizzare le ultime righe nella parte inferiore della colonna e gli ultimi caratteri alla fine di ogni riga. Ciò si ottiene moltiplicando il carattere di output con l'espressione:

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

Il !(columns%2)calcolo della larghezza è dovuto al fatto che la quantità di cui abbiamo bisogno per tagliare l'estremità dipende dal fatto che il conteggio totale delle colonne sia pari o dispari.

Facciamo quindi un secondo calcolo per determinare quale carattere deve essere visualizzato per una colonna pari, mappando le coordinate u , v come segue:

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

Questo è lo stesso calcolo di base usato per le colonne dispari, ma leggermente sfalsato. E come prima, dobbiamo assicurarci di non rendere alcuni dei caratteri sui confini - questa volta le prime poche righe nella parte superiore della colonna, così come alcuni caratteri all'inizio e alla fine di ogni riga. L'espressione che moltiplichiamo in questo caso è:

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

Dopo aver calcolato questi due potenziali caratteri di output, il valore finale utilizzato è:

char1 + (char2 * !char1) + 32

In altre parole, se char1 è zero, dobbiamo generare char2 , altrimenti generiamo char1 . Se entrambi sono diversi da zero, avremo solo l'output di char1 , ma va bene perché entrambi avrebbero lo stesso valore comunque. Si noti inoltre che questi valori di carattere sono sfalsati di 32 (quindi l'aggiunta di 32) in modo che lo zero finisca sempre come spazio.

Lotto, 590 byte

@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 :csubroutine accetta tre parametri; %3è la differenza tra 1 e 2 colonne, %2è la differenza tra 2 e 3 colonne, %1è il prefisso aggiuntivo per la prima colonna, quindi una colonna è %1%2, due colonne è %1%2%3, tre colonne è %1%2%3%2, quattro colonne è %1%2%3%2%3ecc.

Python 2 , 329 326 319 byte

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)

Provalo online!

In realtà 21 24 31 byte in meno rispetto al mio precedente post errato. Crea elenchi per le colonne pari e dispari, quindi le concatena per ogni colonna della larghezza.