Considérez les blocs 3x3 suivants que l' algorithme des carrés de marche identifierait pour chaque cellule (avec un ID étiqueté basé sur 0):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

Le but de ce défi est de fournir une matrice 2D d'ID de bloc, de dessiner le tracé de contour complet en juxtaposant ces petites cellules ensemble. Notez qu'il y a des cas répétés (ex .: 0 et 15 visuellement sont les mêmes)

Contribution

Votre programme / fonction doit prendre en entrée une matrice rectangulaire 2D d'entiers dans la plage [0+a,15+a](où aest un décalage d'entier arbitraire de votre choix; cela vous permet d'utiliser une indexation à base zéro ou une indexation à base 1 pour les blocs). Cela peut provenir de n'importe quelle source souhaitée (stdin, paramètre de fonction, etc.).

Production

Votre programme / fonction doit produire une seule chaîne représentant le tracé de contour complet. Il ne doit pas y avoir d'espace supplémentaire de début / fin, mais une seule nouvelle ligne de fin est autorisée. Il ne doit pas y avoir de séparation verticale ou horizontale entre les blocs adjacents.

Notez que vous n'avez pas à effectuer de traitement spécial pour les blocs qui correspondent à une "selle"; dessinez simplement le bloc avec l'ID donné tel quel.

La sortie peut être vers n'importe quel récepteur souhaité (sortie standard, valeur de retour, etc.)

Exemples

Tous les exemples ci-dessous utilisent des ID de bloc basés sur 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

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

Notation

C'est le golf de code; le code le plus court en octets gagne. Des échappatoires standard s'appliquent.

Mathematica, 353 326 octets

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

contribution

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

JavaScript (ES6), 195 octets

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

Cas de 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 octets

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

Essayez-le dans le bac à sable Wolfram!

Le " \n" doit être remplacé par une nouvelle ligne réelle. L'entrée est indexée 1 - par exemple, le troisième cas de test devient {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. La sortie est une chaîne.

L'idée est fondamentalement la même que la réponse de Jenny_mathy - faire les seize carrés en prenant une grille de "."s 3x3 et en remplaçant certains des caractères, puis assembler les carrés ensemble - mais en utilisant des fonctions légèrement plus courtes pour le faire. (Merci à alephalpha de me rappeler qu'il ArrayFlattenexiste!)

Il est possible que cela puisse être fait en moins d'octets en créant intelligemment les carrés au lieu de les coder en dur, mais cela nécessiterait beaucoup plus d'efforts…

Rétine , 165 octets

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

Essayez-le en ligne! Le lien inclut un deuxième exemple. Explication: Les deux premières étapes sont converties de décimales en hexadécimales, ce qui permet de supprimer les espaces. La troisième étape triple ensuite chaque ligne, donnant à chaque nouvelle ligne un marqueur distinct. Ces marqueurs traversent ensuite les chiffres hexadécimaux, les convertissant en tracé de contour au fur et à mesure, jusqu'à ce qu'ils atteignent la fin de la ligne, point auquel ils sont supprimés.

Python 2 , 247 octets

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

Essayez-le en ligne!

-1 octet grâce à LeakyNun

SOGL V0.12 , 106 89 octets

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

Essayez-le ici! (qui a un octet supplémentaire →pour faciliter la saisie. Sinon, cela supposerait le tableau déjà sur la pile)

Python 2, 196 191 191 181 176 octets

Essayez-le en ligne!

Une fonction qui prend un tableau de tableaux d'entiers et renvoie une chaîne:

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: enregistré 5 octets en affectant J, N; 10 autres octets parce que j'ai oublié que l'entrée est déjà supposée être un tableau de tableaux d'entiers; puis 5 autres octets économisés grâce à un découpage plus intelligent ...

La chaîne concaténée des 16 cellules 3x3 (144 octets, en omettant les sauts de ligne) est codée en fonction de la longueur de la chaîne de 41 octets:

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

où chaque élément RLE (cellType, length)est codé en caractère chr(32+16*cellType+length)(il est pratique que la course maximale soit de 15 et ord(' ')==32divisibles par 16). Lors du décodage, nous prenons '\/|-.'[cellType]comme caractère imprimable.

Rien de particulièrement intelligent après ça ...

05AB1E , 61 octets

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

Essayez-le en ligne!

La première moitié du motif peut être compressée comme suit:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

La seconde moitié devrait être:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

Nous pouvons simplement refléter verticalement la première moitié et insérer binary 110 (1101110)pour le 2111111125.

Ensuite, nous prenons ce modèle et nous nous divisons sur cinq, puis le garnissons avec ceux-ci:

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

Maintenant, nous avons nos blocs de construction, les dernières parties remplacent simplement les entrées de la matrice par les blocs de construction appropriés, zippent les lignes et impriment à l'utilisateur avec les symboles remplacés:

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

Peut publier une explication d'opération formelle si quelqu'un le veut, merci.

Gelée , 64 octets

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

Essayez-le en ligne!

Cela utilise une compression naïve et pourrait probablement économiser de nombreux octets avec un encodage de longueur.

Comment ça fonctionne

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