Betrachten Sie die folgenden 3x3-Blöcke, die der Marschquadrat-Algorithmus für jede Zelle identifizieren würde (mit 0-basierter beschrifteter ID):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

Das Ziel dieser Herausforderung ist es, eine 2D-Matrix von Block-IDs zu erhalten. Zeichnen Sie das vollständige Konturdiagramm, indem Sie diese kleineren Zellen zusammenkacheln. Beachten Sie, dass es einige wiederholte Fälle gibt (Beispiel: 0 und 15 sind visuell gleich)

Eingang

Ihr Programm / Ihre Funktion sollte eine rechteckige 2D-Matrix von Ganzzahlen im Bereich als Eingabe verwenden [0+a,15+a](wobei aeine beliebige Ganzzahlverschiebung Ihrer Wahl vorliegt; dies ermöglicht Ihnen die Verwendung einer nullbasierten Indizierung oder einer 1-basierten Indizierung für die Blöcke). Dies kann von jeder gewünschten Quelle stammen (Standard, Funktionsparameter usw.).

Ausgabe

Ihr Programm / Ihre Funktion sollte eine einzelne Zeichenfolge ausgeben, die das vollständige Konturdiagramm darstellt. Es sollte kein zusätzliches Leerzeichen für führende / nachfolgende Zeilen geben, aber eine einzelne nachfolgende neue Zeile ist zulässig. Es sollte keine vertikale oder horizontale Trennung zwischen benachbarten Blöcken geben.

Beachten Sie, dass Sie für Blöcke, die einem "Sattel" zugeordnet sind, keine spezielle Behandlung durchführen müssen. Zeichnen Sie einfach den Block mit der angegebenen ID wie er ist.

Die Ausgabe kann an eine beliebige Senke erfolgen (Standardausgabe, Rückgabewert usw.)

Beispiele

Alle folgenden Beispiele verwenden 0-basierte Block-IDs.

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

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

Wertung

Das ist Code Golf; Der kürzeste Code in Bytes gewinnt. Es gelten Standardlücken.

Mathematica, 353 326 Bytes

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"}]&

Eingang

[{{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`
`

Testfälle

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 Bytes

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",""]&

Probieren Sie es im Wolfram Sandkasten!

Das " \n" sollte durch eine tatsächliche neue Zeile ersetzt werden. Die Eingabe ist 1-indiziert - zum Beispiel wird der dritte Testfall {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. Die Ausgabe ist eine Zeichenfolge.

Die Idee ist im Grunde die gleiche wie die Antwort von Jenny_mathy - mache die sechzehn Quadrate, indem du ein 3x3-Gitter von "."s nimmst und einige der Zeichen ersetzst , dann die Quadrate zusammennähst - aber benutze etwas kürzere Funktionen, um dies zu tun. (Danke an alephalpha , dass du mich daran erinnert hast, dass es ArrayFlattenexistiert!)

Es ist möglich, dass dies in weniger Bytes durchgeführt werden kann, indem die Quadrate geschickt erstellt werden, anstatt sie im Grunde hart zu codieren, aber das würde viel mehr Aufwand erfordern…

Netzhaut , 165 Bytes

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

Probieren Sie es online aus! Link enthält zweites Beispiel. Erläuterung: Die ersten beiden Stufen werden von dezimal in hexadezimal konvertiert, sodass die Leerzeichen gelöscht werden können. Die dritte Stufe verdreifacht dann jede Zeile und gibt jeder neuen Zeile einen separaten Marker. Diese Markierungen durchlaufen dann die hexadezimalen Ziffern und wandeln sie im Verlauf in das Konturdiagramm um, bis sie das Ende der Linie erreichen und an diesem Punkt gelöscht werden.

Python 2 , 247 Bytes

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()],[])))

Probieren Sie es online aus!

-1 Byte dank LeakyNun

SOGL V0.12 , 106 89 Bytes

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

Probieren Sie es hier aus! (Das hat ein zusätzliches Byte →für eine einfache Eingabe. Andernfalls würde das Array bereits auf dem Stapel erwartet.)

Python 2, 196 191 181 176 Bytes

Probieren Sie es online aus!

Eine Funktion, die ein Array von Ints-Arrays verwendet und eine Zeichenfolge zurückgibt:

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)

BEARBEITEN: 5 Bytes durch Zuweisen von J, N gespeichert; weitere 10 Bytes, weil ich vergessen habe, dass die Eingabe bereits als Array von Ints-Arrays angenommen wird; und dann weitere 5 Bytes, die durch intelligentes Schneiden eingespart wurden ...

Die verkettete Zeichenfolge aller 16 3x3-Zellen (144 Byte, ohne Zeilenumbrüche) wird in die 41-Byte-Zeichenfolge lauflängencodiert:

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

Dabei ist jedes RLE-Element (cellType, length)für das Zeichen codiert chr(32+16*cellType+length)(es ist praktisch, dass der maximale Lauf 15 beträgt; und das ord(' ')==32ist durch 16 teilbar). Beim Dekodieren nehmen wir '\/|-.'[cellType]als druckbares Zeichen.

Nichts besonders klug danach ...

05AB1E , 61 Bytes

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

Probieren Sie es online aus!

Die erste Hälfte des Musters kann wie folgt komprimiert werden:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

Die zweite Hälfte müsste sein:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

Wir können die erste Hälfte nur vertikal spiegeln und binary 110 (1101110)für die einfügen 2111111125.

Als nächstes nehmen wir dieses Muster und teilen es auf fünf auf, dann füllen wir es mit denen auf:

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

Jetzt haben wir unsere Bausteine, die letzten Teile ersetzen einfach die Matrixeinträge durch die entsprechenden Bausteine, komprimieren die Zeilen und drucken sie mit ersetzten Symbolen an den Benutzer:

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

Kann formelle Betriebserklärungen posten, wenn jemand es will, danke.

Gelee , 64 Bytes

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

Probieren Sie es online aus!

Dies verwendet eine naive Komprimierung und könnte wahrscheinlich viele Bytes mit Lauflängencodierung sparen.

Wie es funktioniert

“¡_ḟ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