Considera i seguenti blocchi 3x3 che l' algoritmo dei quadrati in marcia identificherebbe per ogni cella (con ID con etichetta a base 0):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

L'obiettivo di questa sfida è ottenere una matrice 2D di ID blocco, disegnare l'intero diagramma di contorno piastrellando insieme queste celle più piccole. Nota che ci sono alcuni casi ripetuti (es .: 0 e 15 visivamente sono gli stessi)

Ingresso

Il tuo programma / funzione dovrebbe assumere come input una matrice rettangolare 2D di numeri interi nell'intervallo [0+a,15+a](dove si atrova uno spostamento di numero intero arbitrario di tua scelta; ciò ti consente di utilizzare l'indicizzazione in base zero o l'indicizzazione in base 1 per i blocchi). Questo può provenire da qualsiasi sorgente desiderata (stdin, parametro di funzione, ecc.).

Produzione

Il tuo programma / funzione dovrebbe generare una singola stringa che rappresenta il diagramma di contorno completo. Non ci dovrebbero essere spazi bianchi iniziali / finali aggiuntivi, ma è consentita una singola riga finale finale. Non ci dovrebbe essere alcuna separazione tra blocchi adiacenti in verticale o in orizzontale.

Si noti che non è necessario eseguire alcun tipo di trattamento speciale per i blocchi che corrispondono a una "sella"; basta disegnare il blocco con l'ID fornito così com'è.

L'output può essere su qualsiasi sink desiderato (stdout, valore di ritorno, ecc.)

Esempi

Tutti gli esempi seguenti utilizzano ID di blocco basati su 0.

case 1:

2 1
4 8

......
......
../\..
..\/..
......
......

case 2:

15 13 12 14 15
13 8 0 4 14
11 1 0 2 7
15 11 3 7 15

...............
......---......
...../...\.....
.../.......\...
...............
../.........\..
..\........./..
...............
...\......./...
.....\.../.....
......---......
...............


case 3:

12 12 12 8 4
0 0 0 0 2
0 0 0 2 7
0 2 3 7 15

........./....\
---------......
...............
...............
...............
............../
............/..
...............
.........../...
........./.....
......---......
...../.........

case 4:

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

............
.........---
...\..../...
..\/...|./..
.......|....
...../.|....
/...|...\..\
....|.......
....|.\.....
............
---.........
...../\.....

case 5:

0 0 0 0 6 15 15
0 0 0 0 6 15 15
0 0 0 0 6 15 15
0 0 0 2 7 15 15
0 0 2 5 14 15 15
0 2 5 8 4 12 14
0 4 8 0 0 0 6
0 0 0 0 0 0 4

.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
.............|.......
............/........
.....................
.........../.........
........./...........
.....................
......../../\........
....../../....\......
...............---...
...../../.........\..
.....\/............|.
...................|.
...................|.
....................\
.....................
.....................

punteggio

Questo è il codice golf; vince il codice più breve in byte. Si applicano scappatoie standard.

Mathematica, 353 326 byte

s=Table[".",3,3];z=Reverse;l@0=l@15=s;y=s;y[[3,1]]="\\";l@1=l@14=y;y=s;y[[3,3]]="/";l@2=l@13=y;y=s;y[[2,All]]="-";l@3=l@12=y;y=l@4=l@11=z/@z@l@1;y[[3,1]]="\\";l@10=y;y=s;y[[All,2]]="|";l@6=l@9=y;y=l@7=l@8=z/@z@l@2;y[[3,3]]="/";l@5=y;StringReplace[ToString@Grid@Map[Column,Map[StringJoin,Map[l,#,{2}],{3}],{2}],{"\n\n"->"\n"}]&

ingresso

[{{15, 13, 12, 14, 15}, {13, 8, 0, 4, 14}, {11, 1, 0, 2, 7}, {15, 11, 3, 7, 15}} ]

JavaScript (ES6), 195 byte

a=>a.map((r,y)=>r.map((i,x)=>[...s='76843210_'].map((_,j)=>(o[Y=y*3+j/3|0]=o[Y]||[])[x*3+j%3]='.\\/-\\/|/\\'[[0,64,256,56,4,257,146,1,68][k=s[i-8]||i]>>j&1&&k])),o=[])&&o.map(r=>r.join``).join`
`

Casi test

let f =

a=>a.map((r,y)=>r.map((i,x)=>[...s='76843210_'].map((_,j)=>(o[Y=y*3+j/3|0]=o[Y]||[])[x*3+j%3]='.\\/-\\/|/\\'[[0,64,256,56,4,257,146,1,68][k=s[i-8]||i]>>j&1&&k])),o=[])&&o.map(r=>r.join``).join`
`

console.log(f([
  [ 2, 1 ],
  [ 4, 8 ]
]));

console.log(f([
  [ 15, 13, 12, 14, 15 ],
  [ 13,  8,  0,  4, 14 ],
  [ 11,  1,  0,  2,  7 ],
  [ 15, 11,  3,  7, 15 ]
]));

console.log(f([
  [ 12, 12, 12,  8,  4 ],
  [  0,  0,  0,  0,  2 ],
  [  0,  0,  0,  2,  7 ],
  [  0,  2,  3,  7, 15 ]
]));

console.log(f([
  [  0,  1,  2,  3 ],
  [  4,  5,  6,  7 ],
  [  8,  9, 10, 11 ],
  [ 12, 13, 14, 15 ]
]));

console.log(f([
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  0,  6, 15, 15 ],
  [  0,  0,  0,  2,  7, 15, 15 ],
  [  0,  0,  2,  5, 14, 15, 15 ],
  [  0,  2,  5,  8,  4, 12, 14 ],
  [  0,  4,  8,  0,  0,  0,  6 ],
  [  0,  0,  0,  0,  0,  0,  4 ]
]));

Mathematica, 173 byte

StringRiffle[ArrayFlatten[ReplacePart[Table[".",16,3,3],{{2|11|15,3,1}|{5|11|12,1,3}->"\\",{3|6|14,3,3}|{6|8|9,1,1}->"/",{4|13,2,_}->"-",{7|10,_,2}->"|"}][[#]]&/@#],"\n",""]&

Provalo nella sandbox Wolfram!

Il " \n" dovrebbe essere sostituito da una nuova riga effettiva. L'input è 1 indicizzato, ad esempio il terzo caso di test diventa {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. L'output è una stringa.

L'idea è sostanzialmente la stessa della risposta di Jenny_mathy : crea i sedici quadrati prendendo una griglia 3x3 di "."s e sostituendo alcuni caratteri, quindi unisci i quadrati, ma usando funzioni leggermente più brevi per farlo. (Grazie ad alephalpha per avermi ricordato che ArrayFlattenesiste!)

È possibile che ciò possa essere fatto in un minor numero di byte rendendo i quadrati in modo intelligente anziché sostanzialmente codificarli, ma ciò richiederebbe molto più sforzo ...

Retina , 165 byte

T`d`L`1\d
 |\bB\B

.+
X$&¶Y$&¶Z$&
%{`[XYZ]$

([XYZ])[69]
.|.$1
X[^4-B]
...X
X[4AB]
..\X
X[578]
/..X
Y[^369C]
...Y
Y[3C]
---Y
Z[03478BCF]
...Z
Z[1AE]
\..Z
Z[25D]
../Z

Provalo online! Il link include un secondo esempio. Spiegazione: I primi due stadi vengono convertiti da decimale a esadecimale, consentendo di eliminare gli spazi. Il terzo stadio quindi triplica ogni riga, assegnando a ciascuna nuova riga un marker separato. Questi marcatori attraversano quindi le cifre esadecimali, convertendole nel diagramma di contorno mentre procedono, fino a raggiungere la fine della linea, a quel punto vengono eliminate.

Python 2 , 247 byte

J='...'
print'\n'.join(map(''.join,sum([[sum([f[i*3:][:3]for i in j],[])for f in map(list,[J*4+'..\\/...|./../...|...\\..\\'+J*4,J*3+'---.......|........|.......---'+J*3,'...\\..../......../.|........|.\\'+J*3+'./\\.....'])]for j in input()],[])))

Provalo online!

-1 byte grazie a LeakyNun

SOGL V0.12 , 106 89 byte

žj}² ³
ē0=?²
{ā;{"⁰9═‼pnk№Ο|╚φ;“2─6nwEX .9*3n²Xƨ.ƨ-¹╬-}²X"č7_#‘3n}² /33³\13³\31³/11žj}┼}O

Provalo qui! (che ha un byte in più →per facilitare l'input. Questo altrimenti si aspetterebbe che l'array sia già in pila)

Python 2, 196 191 181 176 byte

Provalo online!

Una funzione che accetta una matrice di matrici di ints e restituisce una stringa:

J=''.join;N='\n'.join
f=lambda I:N(N(J(J('\/|-.'[C/16-2]*(C%16)for C in map(ord,'o!j1cSe!f1g1aAbAbAa1h1iAbAbAc!c!d!iSk1f!k'))[c*9+3*j:][:3]for c in r)for j in[0,1,2])for r in I)

EDIT: salvato 5 byte assegnando J, N; altri 10 byte perché ho dimenticato che si presume che l'input sia una matrice di array di ints; e poi altri 5 byte salvati dall'affettatura più intelligente ...

La stringa concatenata di tutte le 16 celle 3x3 (144 byte, omettendo le interruzioni di riga) è codificata per la lunghezza di esecuzione nella stringa di 41 byte:

o!j1cSe!f1g1aAbAbAa1h1iAbAbAc!c!d!iSk1f!k

dove ogni elemento RLE (cellType, length)è codificato per il carattere chr(32+16*cellType+length)(è utile che la corsa massima sia 15; e che ord(' ')==32sia divisibile per 16). Durante la decodifica, prendiamo '\/|-.'[cellType]come carattere stampabile.

Niente di particolarmente intelligente dopo quello ...

05AB1E , 61 byte

v•2mßklJFΘõÿ|åU‚ιØØ•6B5¡∊¶¡110bTǝ.BJ3ô3ôyèøJ»}»4ÝJð«"\./-|."‡

Provalo online!

La prima metà del motivo può essere compressa come:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

La seconda metà dovrebbe essere:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

Possiamo semplicemente rispecchiare verticalmente la prima metà e inserirla binary 110 (1101110)per il 2111111125.

Quindi prendiamo questo schema e lo dividiamo in cinque, quindi lo riempiamo con quelli:

1 = 111111111
2 = 111111011
3 = 111111112
4 = 111333111
5 = 110111111
6 = 211111112
7 = 141141141
8 = 211111111
9 = 141141141
A = 110111011
B = 110111111
C = 111333111
D = 111111112
E = 111111111

Ora abbiamo i nostri blocchi predefiniti, le ultime parti sostituiscono le voci della matrice con i blocchi appropriati, comprimono le righe e stampano all'utente con i simboli sostituiti:

0 = .........
1 = ......\..
2 = ......../
3 = ...---...
4 = ..\......
5 = /......./
6 = .|..|..|.
7 = /........
8 = /........
9 = .|..|..|.
A = ..\...\..
B = ..\......
C = ...---...
D = ......../
E = .........

Può pubblicare spiegazioni operative formali se qualcuno lo desidera, grazie.

Gelatina , 64 byte

“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ṃ“/-\|.”s3s3ṙ9ị@³ZY$€Y

Provalo online!

Questo utilizza una compressione ingenua e potrebbe probabilmente salvare molti byte con la codifica run-length.

Come funziona

“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ṃ“/-\|.”s3s3ṙ9ị@³ZY$€Y
“¡_ḟ5⁸ṫ⁺Y"⁷ƘzƬɼ¥@TR/ṖQ½3yİ>ẎḄT¥⁹iḟQ¬Ɠl¹µŒ’ encodes the integer 4591777158889232952973696500124538798606476761349931038636020730336909822188496590423586252520
ṃ“/-\|.”                   - convert to base 5 and index into the string to get "/......../.........|..|..|...\...\....\.........---.........../......\.................\........../...---.....\....../......./.|..|..|."
        s3s3               - split every 9 characters into a 3x3 square submatrix       
            ṙ9             - rotate left by 9 to line up the submatrix for 1 with index 1
              ị@³          - index the input into this
                 ZY$€Y     - format