Dibuja un diagrama de contorno ASCII

11

Considere los siguientes bloques 3x3 que el algoritmo de cuadrados de marcha identificaría para cada celda (con ID etiquetada basada en 0):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

El objetivo de este desafío se le da una matriz 2D de ID de bloque, dibuje el diagrama de contorno completo al unir estas celdas más pequeñas. Tenga en cuenta que hay algunos casos repetidos (ej .: 0 y 15 visualmente son lo mismo)

Entrada

Su programa / función debe tomar como entrada una matriz rectangular de números enteros en 2D en el rango [0+a,15+a](donde aes un desplazamiento arbitrario de su elección; esto le permite usar indexación basada en cero o indexación basada en 1 para los bloques). Esto puede ser de cualquier fuente deseada (stdin, parámetro de función, etc.).

Salida

Su programa / función debe generar una sola cadena que represente el diagrama de contorno completo. No debe haber espacios en blanco iniciales / finales adicionales, pero se permite una nueva línea final. No debe haber separación entre bloques adyacentes vertical u horizontalmente.

Tenga en cuenta que no tiene que hacer ningún tipo de tratamiento especial para los bloques que se asignan a una "silla de montar"; simplemente dibuje el bloque con la ID dada tal cual.

La salida puede ser a cualquier sumidero deseado (stdout, valor de retorno, etc.)

Ejemplos

Todos los ejemplos a continuación usan ID de bloque basados ​​en 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

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

Puntuación

Este es el código de golf; el código más corto en bytes gana. Se aplican lagunas estándar.

code-golf  ascii-art 
— helloworld922
fuente
— Martin Ender
1
¿No debería el último caso de prueba tener 3 líneas principales más de las barras verticales?
— dzaima
Si, arreglado. ¡Gracias!
— helloworld922
Debería haber usado la entrada hexadecimal.
— Urna de pulpo mágico
— Urna mágica del pulpo

Respuestas:

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


entrada

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

— J42161217
fuente
Impresionante, difícil de hacer esto en Mathematica.
— Urna de pulpo mágico
2

JavaScript (ES6), 195 bytes

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

Casos de prueba

Mostrar fragmento de código

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

¡Pruébalo en el sandbox de Wolfram!

El " \n" debe ser reemplazado por una nueva línea real. La entrada está indexada en 1; por ejemplo, se convierte en el tercer caso de prueba {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. El resultado es una cadena.

La idea es básicamente la misma que la respuesta de Jenny_mathy : crea los dieciséis cuadrados tomando una cuadrícula de 3x3 "."y reemplazando algunos de los caracteres, luego une los cuadrados, pero usando funciones un poco más cortas para hacerlo. (¡Gracias a alephalpha por recordarme que ArrayFlattenexiste!)

Es posible que esto se pueda hacer en menos bytes haciendo los cuadrados de forma inteligente en lugar de básicamente codificarlos, pero eso requeriría mucho más esfuerzo ...

— No un arbol
fuente
@ Jenny_mathy: Editado, ¿es eso lo que querías?
— No es un árbol
@ Jenny_mathy, parece estar funcionando para mí. Estoy usando la indexación 1, por lo que debe agregar 1 a cada número; el caso de prueba se convierte {{16,14,13,15,16},{14,9,1,5,15},{12,2,1,3,8},{16,12,4,8,16}}. Si lo intentó y todavía no funciona, ¿podría decirme qué problema tiene?
— No es un árbol
2

Retina , 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

Pruébalo en línea! El enlace incluye el segundo ejemplo. Explicación: Las dos primeras etapas se convierten de decimal a hexadecimal, lo que permite eliminar los espacios. La tercera etapa luego triplica cada línea, dando a cada nueva línea un marcador separado. Estos marcadores luego atraviesan los dígitos hexadecimales, convirtiéndolos en el diagrama de contorno a medida que avanzan, hasta que alcanzan el final de la línea, en cuyo punto se eliminan.

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

Pruébalo en línea!

-1 byte gracias a LeakyNun

— Hiperneutrino
fuente
Tenga en cuenta que 10 y 5 son diferentes.
— Leaky Nun
@LeakyNun suspiro Sabía que tenía que haber estropeado algo. Eliminar hasta que lo arregle, tal vez para mañana.
— HyperNeutrino
@LeakyNun He arreglado el código, aunque ahora se ha vuelto extremadamente feo y sin golf.
— 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

Pruébalo aquí! (que tiene un byte adicional →para facilitar la entrada. De lo contrario, esperaría que la matriz ya esté en la pila)

— dzaima
fuente
Haga que el intérprete SOGL use la fuente monoespacio>. <
— HyperNeutrino
10 barras son más anchas que 10 períodos.
— HyperNeutrino
1

Python 2, 196 191 181 176 bytes

Pruébalo en línea!

Una función que toma una matriz de matrices de entradas y devuelve una cadena:

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)

EDITAR: guardado 5 bytes asignando J, N; otros 10 bytes porque olvidé que la entrada ya se supone que es una matriz de matrices de entradas; y luego otros 5 bytes guardados por un corte más inteligente ...

La cadena concatenada de las 16 celdas 3x3 (144 bytes, omitiendo los saltos de línea) está codificada en longitud de ejecución a la cadena de 41 bytes:

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

donde cada elemento RLE (cellType, length)está codificado para el personaje chr(32+16*cellType+length)(es útil que la ejecución máxima sea 15; y eso ord(' ')==32es divisible por 16). Al decodificar, tomamos '\/|-.'[cellType]como personaje imprimible.

Nada particularmente inteligente después de eso ...

— Chas Brown
fuente
1

05AB1E , 61 bytes

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

Pruébalo en línea!

La primera mitad del patrón se puede comprimir como:

5
11111105
1111111125
1113335
1105
2111111125
141141145
25

La segunda mitad debería ser:

25
141141145
11011105
1105
1113335
1111111125
11111105
5

Podemos duplicar verticalmente la primera mitad e insertar binary 110 (1101110)para 2111111125.

Luego tomamos este patrón y lo dividimos en cinco, luego lo rellenamos con unos:

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

Ahora que tenemos nuestros bloques de construcción, las últimas partes simplemente reemplazan las entradas de la matriz con los bloques de construcción apropiados, juntan las filas e imprimen al usuario con símbolos reemplazados:

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

Puede publicar una explicación formal de la operación si alguien lo quiere, gracias.

— Urna de pulpo mágico
fuente
1

Jalea , 64 bytes

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

Pruébalo en línea!

Esto utiliza una compresión ingenua y probablemente podría ahorrar muchos bytes con codificación de longitud de ejecución.

Cómo funciona

“¡_ḟ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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.