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ù a
est 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.
Réponses:
Mathematica,
353326 octetscontribution
la source
JavaScript (ES6), 195 octets
Cas de test
Afficher l'extrait de code
la source
Mathematica, 173 octets
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'ilArrayFlatten
existe!)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…
la source
{{16,14,13,15,16},{14,9,1,5,15},{12,2,1,3,8},{16,12,4,8,16}}
. Si vous avez essayé et que cela ne fonctionne toujours pas, pourriez-vous me dire quel problème vous rencontrez?Rétine , 165 octets
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.
la source
Python 2 , 247 octets
Essayez-le en ligne!
-1 octet grâce à LeakyNun
la source
SOGL V0.12 ,
10689 octetsEssayez-le ici! (qui a un octet supplémentaire
→
pour faciliter la saisie. Sinon, cela supposerait le tableau déjà sur la pile)la source
Python 2,
196191 191181176 octetsEssayez-le en ligne!
Une fonction qui prend un tableau de tableaux d'entiers et renvoie une chaîne:
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èrechr(32+16*cellType+length)
(il est pratique que la course maximale soit de 15 etord(' ')==32
divisibles par 16). Lors du décodage, nous prenons'\/|-.'[cellType]
comme caractère imprimable.Rien de particulièrement intelligent après ça ...
la source
05AB1E , 61 octets
Essayez-le en ligne!
La première moitié du motif peut être compressée comme suit:
La seconde moitié devrait être:
Nous pouvons simplement refléter verticalement la première moitié et insérer
binary 110 (1101110)
pour le2111111125
.Ensuite, nous prenons ce modèle et nous nous divisons sur cinq, puis le garnissons avec ceux-ci:
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:
Peut publier une explication d'opération formelle si quelqu'un le veut, merci.
la source
Gelée , 64 octets
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
la source