Considere os seguintes blocos 3x3 que o algoritmo dos quadrados de marchas identificaria para cada célula (com ID rotulado com base em 0):

0:
...
...
...

1:
...
...
\..

2:
...
...
../

3:
...
---
...

4:
..\
...
...

5:
/..
...
../

6:
.|.
.|.
.|.

7:
/..
...
...

8:
/..
...
...

9:
.|.
.|.
.|.

10:
..\
...
\..

11:
..\
...
...

12:
...
---
...

13:
...
...
../

14:
...
...
\..

15:
...
...
...

O objetivo deste desafio é fornecer uma matriz 2D de IDs de bloco, desenhar o gráfico de contorno completo, unindo essas células menores. Observe que existem alguns casos repetidos (por exemplo: 0 e 15 são visualmente iguais)

Entrada

Seu programa / função deve ter como entrada uma matriz retangular 2D de números inteiros no intervalo [0+a,15+a](onde aé um deslocamento inteiro arbitrário de sua escolha; isso permite que você use indexação com base em zero ou indexação com base em 1 para os blocos). Pode ser de qualquer fonte desejada (stdin, parâmetro de função, etc.).

Resultado

Seu programa / função deve gerar uma única sequência representando o gráfico de contorno completo. Não deve haver espaço em branco inicial / final, mas uma nova linha final é permitida. Não deve haver separação entre os blocos adjacentes verticalmente ou horizontalmente.

Observe que você não precisa fazer nenhum tipo de tratamento especial para blocos mapeados para uma "sela"; basta desenhar o bloco com o ID fornecido como está.

A saída pode ser para qualquer coletor desejado (saída padrão, valor de retorno, etc.)

Exemplos

Todos os exemplos abaixo usam IDs de bloco baseados em 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

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

Pontuação

Isso é código de golfe; o menor código em bytes vence. Aplicam-se brechas padrão.

code-golf ascii-art helloworld922
fonte

Relacionado.

Martin Ender

1

O último caso de teste não deveria ter mais três linhas iniciais das barras verticais?

dzaima

sim, consertado. Obrigado!

precisa

Deveria ter usado entrada hexidecimal.

Magic Octopus Urn

Chora internamente.

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

entrada

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

J42161217
fonte

Impressionante, difícil de fazer isso no Mathematica.

Magic Octopus Urn

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 teste

Mostrar snippet de código

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

Expandir snippet

Arnauld
fonte

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

Experimente na sandbox Wolfram!

" \n" Deve ser substituído por uma nova linha real. A entrada é indexada em 1 - por exemplo, o terceiro caso de teste se torna {{13,13,13,9,5},{1,1,1,1,3},{1,1,1,3,8},{1,3,4,8,16}}. A saída é uma sequência.

A idéia é basicamente a mesma que a resposta de Jenny_mathy - faça os dezesseis quadrados pegando uma grade de 3x3 de "."s e substituindo alguns dos caracteres, depois junte os quadrados - mas usando funções um pouco mais curtas para fazer isso. (Obrigado a alephalpha por me lembrar que ArrayFlattenexiste!)

É possível que isso possa ser feito em menos bytes, tornando os quadrados habilmente, em vez de basicamente codificá-los, mas isso exigiria muito mais esforço ...

Não é uma árvore
fonte

@Jenny_mathy: Editado - é isso que você queria?

Não é uma árvore

@Jenny_mathy, parece estar funcionando para mim. Estou usando a indexação 1, então você precisa adicionar 1 a cada número; o caso de teste se torna {{16,14,13,15,16},{14,9,1,5,15},{12,2,1,3,8},{16,12,4,8,16}}. Se você tentou e ainda não está funcionando, poderia me dizer qual é o problema?

Não é uma árvore

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

Experimente online! O link inclui o segundo exemplo. Explicação: Os dois primeiros estágios são convertidos de decimal em hexadecimal, permitindo que os espaços sejam excluídos. O terceiro estágio então triplica cada linha, dando a cada nova linha um marcador separado. Esses marcadores percorrem os dígitos hexadecimais, convertendo-os no gráfico de contorno à medida que avançam, até chegar ao final da linha, quando são excluídos.

Neil
fonte

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

Experimente online!

-1 byte graças a LeakyNun

HyperNeutrino
fonte

Por favor, note que 10 e 5 são diferentes.

Leaky Nun

@LeakyNun suspiro eu sabia que tinha que ter estragado alguma coisa. Excluindo até eu corrigir, talvez amanhã.

HyperNeutrino

@LeakyNun Corrigi o código, mas agora ele se tornou extremamente feio e não-destruído.

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

Experimente aqui! (que possui um byte extra →para facilitar a entrada. Caso contrário, seria de esperar que a matriz já estivesse na pilha)

dzaima
fonte

Faça com que o intérprete SOGL use fonte monoespaçada>. <

HyperNeutrino 26/06

10 barras são maiores que 10 períodos.

HyperNeutrino

1

Python 2, 196 191 181 176 bytes

Experimente online!

Uma função que pega uma matriz de matrizes de ints e retorna uma string:

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: salvou 5 bytes atribuindo J, N; outros 10 bytes porque esqueci que a entrada já é assumida como uma matriz de matrizes de entradas; e depois outros 5 bytes salvos por um corte mais inteligente ...

A sequência concatenada de todas as 16 células 3x3 (144 bytes, omitindo quebras de linha) é codificada em comprimento de execução para a sequência de 41 bytes:

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

onde cada elemento RLE (cellType, length)é codificado para o caractere chr(32+16*cellType+length)(é útil que a execução máxima seja 15; e que ord(' ')==32seja divisível por 16). Ao decodificar, tomamos '\/|-.'[cellType]como caractere imprimível.

Nada particularmente inteligente depois disso ...

Chas Brown
fonte

1

05AB1E , 61 bytes

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

Experimente online!

A primeira metade do padrão pode ser compactada como:

A segunda metade precisaria ser:

Podemos apenas espelhar verticalmente a primeira metade e inserir binary 110 (1101110)a 2111111125.

Em seguida, pegamos esse padrão e dividimos em cinco, depois juntamos-o com os seguintes:

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

Agora temos nossos blocos de construção, as últimas partes substituem as entradas da matriz pelos blocos de construção apropriados, fecham as linhas e imprimem ao usuário com símbolos substituídos:

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

Pode postar uma explicação formal da operação, se alguém quiser, obrigado.

Urna de polvo mágico
fonte

1

Geléia , 64 bytes

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

Experimente online!

Isso usa uma compactação ingênua e provavelmente poderia economizar muitos bytes com a codificação no comprimento da execução.

Como 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
fonte

Desenhar um gráfico de contorno ASCII

Entrada

Resultado

Exemplos

Pontuação

Respostas:

Mathematica, 353 326 bytes

JavaScript (ES6), 195 bytes

Casos de teste

Mathematica, 173 bytes

Retina , 165 bytes

Python 2 , 247 bytes

SOGL V0.12 , 106 89 bytes

Python 2, 196 191 181 176 bytes

05AB1E , 61 bytes

Geléia , 64 bytes