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.

code-golf ascii-art helloworld922
quelle

Verbunden.

Martin Ender

1

Sollte der letzte Testfall nicht 3 weitere führende Linien der vertikalen Balken haben?

Dzaima

ja, behoben. Vielen Dank!

helloworld922

Hätte hexadezimale Eingabe verwenden sollen.

Magic Octopus Urn

Weint innerlich.

Magic Octopus Urn

2

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

J42161217
quelle

Beeindruckend, in Mathematica schwer zu machen.

Magic Octopus Urn

2

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

Code-Snippet anzeigen

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 ]
]));

Erweitern Sie das Snippet

Arnauld
quelle

2

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…

Kein Baum
quelle

@ Jenny_mathy: Bearbeitet - ist es das, was du wolltest?

Kein Baum

@ Jenny_mathy, es scheint für mich zu funktionieren. Ich verwende die 1-Indizierung, daher müssen Sie jeder Zahl 1 hinzufügen. Der Testfall wird {{16,14,13,15,16},{14,9,1,5,15},{12,2,1,3,8},{16,12,4,8,16}}. Wenn Sie das versucht haben und es immer noch nicht funktioniert, können Sie mir dann sagen, welches Problem Sie bekommen?

Kein Baum

2

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.

Neil
quelle

1

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

HyperNeutrino
quelle

Bitte beachten Sie, dass 10 und 5 unterschiedlich sind.

Undichte Nonne

@LeakyNun seufze ich wusste , dass ich etwas vermasselt haben musste. Löschen, bis ich es repariert habe, vielleicht bis morgen.

HyperNeutrino

@LeakyNun Ich habe den Code repariert, obwohl er jetzt extrem hässlich und ungolfed geworden ist.

HyperNeutrino

1

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.)

Dzaima
quelle

Bitte lassen Sie den SOGL-Interpreter die Monospace-Schriftart> verwenden. <

HyperNeutrino

10 Schrägstriche sind breiter als 10 Perioden.

HyperNeutrino

1

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 ...

Chas Brown
quelle

1

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:

Die zweite Hälfte müsste sein:

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.

Magische Krakenurne
quelle

1

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

fireflame241
quelle

Zeichnen Sie ein ASCII-Konturdiagramm

Eingang

Ausgabe

Beispiele

Wertung

Antworten:

Mathematica, 353 326 Bytes

JavaScript (ES6), 195 Byte

Testfälle

Mathematica, 173 Bytes

Netzhaut , 165 Bytes

Python 2 , 247 Bytes

SOGL V0.12 , 106 89 Bytes

Python 2, 196 191 181 176 Bytes

05AB1E , 61 Bytes

Gelee , 64 Bytes