Visualice el tejido de bits

32

El lenguaje de programación esotérico evil tiene una operación interesante sobre los valores de bytes que llama "tejido". Es esencialmente una permutación de los ocho bits del byte (no importa desde qué extremo comencemos a contar, ya que el patrón es simétrico):

  • El bit 0 se mueve al bit 2
  • El bit 1 se mueve al bit 0
  • El bit 2 se mueve al bit 4
  • El bit 3 se mueve al bit 1
  • El bit 4 se mueve al bit 6
  • El bit 5 se mueve al bit 3
  • El bit 6 se mueve al bit 7
  • El bit 7 se mueve al bit 5

Por conveniencia, aquí hay otras dos representaciones de la permutación. Como un ciclo:

(02467531)

Y como una lista de pares de mapeo:

[[0,2], [1,0], [2,4], [3,1], [4,6], [5,3], [6,7], [7,5]]

Su tarea es visualizar esta permutación, utilizando los caracteres de cuadro de dibujo , , , , , , (Unicode puntos de código: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, U + 253C). Esta visualización debe satisfacer las siguientes restricciones:

La primera y la última línea son exactamente:

0 1 2 3 4 5 6 7

Entre ellos, puede usar tantas líneas como desee de hasta 15 caracteres cada una para adaptarse a los caracteres de su cuadro de dibujo (necesitará al menos 4 líneas). Las líneas deben comenzar verticalmente debajo de uno de los dígitos en la primera fila y terminar verticalmente arriba del dígito correspondiente en la última fila. Las ocho líneas deben estar conectadas y solo pueden cruzarse (lo que siempre es un cruce, nunca dos líneas de giro que se tocan). Los caminos exactos de las líneas dependen de usted (y encontrar un diseño particularmente golfable es el núcleo de este desafío). Una salida válida sería:

0 1 2 3 4 5 6 7
│ │ └─┼┐│ │ └┐│
└─┼─┐ ││└─┼─┐││
┌─┘ │ ││  │ │││
│ ┌─┼─┘│  │ │││
│ │ │ ┌┼──┘ │││
│ │ │ │└┐ ┌─┼┼┘
│ │ │ │ │ │ │└┐
0 1 2 3 4 5 6 7

Sin embargo, cualquier otro diseño que conecte correctamente los dígitos correctos también está bien. Por favor, muestre el resultado elegido en su respuesta.

Puede escribir un programa o función y no tomará ninguna entrada. Envíe el diagrama a STDOUT (o la alternativa más cercana) o como un valor de retorno de función en forma de una cadena o una lista de cadenas (cada una representa una línea).

Se aplican las reglas estándar de , por lo que gana el código más corto (en bytes).

Martin Ender
fuente
1
¿Podríamos usar otros símbolos para idiomas que no admiten Unicode?
flawr
3
Este desafío esencialmente se reduce a copiar y pegar la salida proporcionada ... ¿Qué hay de tomar una permutación de 01234567como una entrada y luego conectar que a 01234567? ¿Para que tengas que descubrir los enlaces tú mismo? Sería una tarea significativamente más desafiante, especialmente para el golf.
shooqie
55
@shooqie Esto se discutió en el sandbox. Ese sería un desafío muy diferente y estoy considerando publicar eso también en algún momento. Sin embargo, creo que hay mucho más en este desafío que copiar y pegar el ejemplo anterior. Hay innumerables salidas admisibles diferentes y la anterior es especialmente difícil de comprimir, mientras que otras (como las utilizadas por las respuestas existentes) son mucho más compresibles. El desafío está en encontrar una sola cadena compresible. Eso es muy diferente de encontrar automáticamente un diseño en pocos bytes.
Martin Ender
2
Alguien tiene que resolver esto en el mal.
RK.
3
@Holger Hay una buena razón por la que no hacemos eso: entonces la gente podría codificar la cadena empaquetándola en caracteres Unicode grandes, que pueden almacenar información de varios bytes en un solo carácter. Ejemplo.
Martin Ender

Respuestas:

13

En realidad, 69 bytes

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)

Pruébalo en línea! (la alineación está un poco desordenada en el intérprete en línea)

Realmente tiene una GRAN ventaja aquí: todos los caracteres de dibujo de caja están en CP437, por lo que son solo un byte cada uno. Aunque cada carácter necesario podría codificarse teóricamente en 4 bits (dado que solo hay 9 caracteres únicos), los 31 bytes guardados al comprimir la cadena se perderían debido a las capacidades de procesamiento de cadena muy pobres de Actually. Esto también significa que cualquier configuración de 8x4 daría como resultado la misma puntuación. Dado que 8x4 parece ser la configuración más corta (verticalmente) posible, esta es óptima.

¡Gracias a Martin por 3 bytes!

¡Gracias a TimmyD por 4 bytes más!

Explicación:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)
"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+         push the individual lines, using string multiplication to shorten repeated sections
                                                              8r' j   push the string "0 1 2 3 4 5 6 7" (range(8), join on spaces)
                                                                   ;)  make a copy and move it to the bottom of the stack
Mego
fuente
1
Técnicamente, muchas de las otras respuestas podrían haber hecho uso de codificaciones de un solo byte simplemente usando cualquier codificación de un solo byte que su idioma admita (si corresponde), generando los mismos bytes que los suyos y diciendo "la salida está codificada en CP437" , pero parece que nadie se dio cuenta de eso. ¯ \ _ (ツ) _ / ¯
Martin Ender
21

PowerShell v2 +, 172 153 148 145 142 131 123 bytes (81 caracteres)

($a=""+0..7)
$b='┌┘'
"│$b$('┌┼─┘'*3)
└┼┐$('│└─┐'*3)
$b$('└┼─┐'*3)│
│ $($b*6)│"
$a

Jugué más el tejido, eliminando la necesidad de varias variables mediante el uso de bloques de código en línea. Esto es probablemente dentro de unos pocos bytes de óptimo.

Comenzamos estableciendo $aun rango igual al rango 0..7que se ha unido con espacios. Esto se debe a que el valor predeterminado $ofs(Separador de campo de salida) para una matriz es un espacio, por lo que cuando la matriz se encadena con ""+(con un operador como este, PowerShell intentará convertir implícitamente el objeto derecho como el objeto izquierdo), el resultado es el rango separado por espacios.

Eso está encapsulado en parens, lo que agrega el resultado a la tubería. Luego configuramos una variable auxiliar $b, seguida de cuatro líneas de salida con la variable apropiada en su lugar (dividida con nuevas líneas literales), y usando bloques de código en línea para las secciones repetidas, seguidas de $anuevo. Las cuatro líneas y $atambién se colocan en la tubería, y la salida está implícita al final.

PS C:\Tools\Scripts\golfing> .\visualize-bit-weaving.ps1
0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7
AdmBorkBork
fuente
1
Buen trabajo con ir y venir en la parte inferior. :)
Martin Ender
11

Javascript ES6, 168 167 bytes

Editar: Whoops, resultó que estaba usando el |char de tubería en lugar de U + 2502 en parte de la función, recuento de bytes actualizado.

_=>((n=`0 1 2 3 4 5 6 7 `)+[...`6452301`].map(i=>`${(d=n=>`│ `.repeat(n))(i)}└┐│ ${r=d(6)}┌┼┘ ${r}│└┐ ${d(6-i)}`).join``+n).match(/.{16}/g).join`
`

Devuelve una cadena.

Salida:

0 1 2 3 4 5 6 7 
│ │ │ │ │ │ └┐│ 
│ │ │ │ │ │ ┌┼┘ 
│ │ │ │ │ │ │└┐ 
│ │ │ │ └┐│ │ │ 
│ │ │ │ ┌┼┘ │ │ 
│ │ │ │ │└┐ │ │ 
│ │ │ │ │ └┐│ │ 
│ │ │ │ │ ┌┼┘ │ 
│ │ │ │ │ │└┐ │ 
│ │ └┐│ │ │ │ │ 
│ │ ┌┼┘ │ │ │ │ 
│ │ │└┐ │ │ │ │ 
│ │ │ └┐│ │ │ │ 
│ │ │ ┌┼┘ │ │ │ 
│ │ │ │└┐ │ │ │ 
└┐│ │ │ │ │ │ │ 
┌┼┘ │ │ │ │ │ │ 
│└┐ │ │ │ │ │ │ 
│ └┐│ │ │ │ │ │ 
│ ┌┼┘ │ │ │ │ │ 
│ │└┐ │ │ │ │ │ 
0 1 2 3 4 5 6 7 

Extra: Usando el método de @ TimmyD, tengo otra solución de 167 bytes:

(n=`0 1 2 3 4 5 6 7
`,a=`│┌┘ `,b=`└┼─┐`,d=`┌┼─┘`,f=` │└┐`)=>[n,a,a,a,a,`
`,b,b,b,`└┼┐
┌┘`,d,d,d,`│
│`,f,f,f,` │
`,n].join``
Dendrobium
fuente
8

JavaScript (ES6), 137134 bytes

f=
_=>`0
2525252
1 1 1 1
24242423525252 3 1 1 1 3 242424
0`.replace(/\d/g,d=>`0 1 2 3 4 5 6 7,└┼┐,┌┘,│
│,│ , │`.split`,`[d])  
;
o.textContent=f();
<pre id=o></pre>

Como campanero, inmediatamente reconocí esto como las dos primeras filas de Plain Hunt Major (tenga en cuenta que la imagen vinculada usa 1-8 en lugar de 0-7).

Neil
fuente
4

Pyth - 119 104 100 81 bytes

Extremadamente simple (Es realmente bytes esta vez).

js[KjdU8cX."sz¨ú¨ãÆhÆ?\ÕüÓ¼xFNøa"_G"│┌┘└┼─┐ "15K

Pruébelo en línea aquí .

También robé la salida de @ TimmyD:

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ │ │
└┼─┐└┼─┐└┼─┐└┐│
┌┘┌┼─┘ └┐│┌┼─┼┘
│ │└┐ ┌─┼┘│└┐└┐
0 1 2 3 4 5 6 7
Maltysen
fuente
3

Lote MS-DOS, 136 bytes

@echo 0 1 2 3 4 5 6 7
@echo ³ÚÙ ³ÚÙ ³ÚÙ ³ÚÙ
@echo ÀÅÄ¿ÀÅÄ¿ÀÅÄ¿ÀÅ¿
@echo ÚÙÚÅÄÙÚÅÄÙÚÅÄÙ³
@echo ³ ³À¿ ³À¿ ³À¿ ³
@echo 0 1 2 3 4 5 6 7

Usando la salida de @ TimmyD. Esto también podría funcionar en Windows Batch, pero mi página de códigos es CP850, no CP437.

Neil
fuente
También funciona en Windows, independientemente de si usa CP437 o CP850.
Holger
@ Holger Huh, supongo que debería haberlo intentado de todos modos, solo para ver
Neil
3

MATLAB / Octave, 112 109 bytes

a='0 1 2 3 4 5 6 7';d=['└┐│ ';'┌┼┘ ';'│└┐ '];e=repmat('│ ',3,1);[a;d d d d;e d d d e;a]

Salida:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Mi código se basa en los resultados de @Dendrobium y @Neil .

Marco
fuente
1
+1 para salida golfable
Erik the Outgolfer
Aviso: el comentario vinculado ha sido eliminado. Era el OP que decía que su salida es más golfable que la de @TimmyD.
Erik the Outgolfer
3

/// , 112 bytes (100 caracteres)

/8/0 1 2 3 4 5 6 7//9/│//A/└┐//B/┌┼┘/8/C/9 A9 A9 A9//D/9A 9A 9A 9/
AC
B B B B
DA
C 9
9 B B B 9
9 D
8

¡Gracias @MartinEnder por -3 bytes!
¡Gracias @MartinEnder por -9 bytes!
Gracias @MartinEnder (OP) por señalar la regla de 15 caracteres

Utiliza la salida de @ TimmyD's @ Marco

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Erik el Outgolfer
fuente
0

Python3, 209 bytes

lambda s="0 1 2 3 4 5 6 7\n":s+"│┌┘ │┌┘ │┌┘ │ │\n└┼─┐└┼─┐└┼─┐└┐│\n┌┘┌┼─┘ └┐│┌┼─┼┘\n│ │└┐ ┌─┼┘│└┐└┐\n"+s

Devuelve una cadena.

¡Gracias a @Mego por guardar 2 bytes!

¡Los créditos del cuerpo del personaje van a @TimmyD!

Yytsi
fuente
2
No necesita la a,parte, lo que también eliminará la necesidad de que se llame con un parámetro.
Mego
0

Sprects , 99 bytes (87 caracteres)

$8
AC
BE
DA
C 9
9E 9
9 D
8$E B B B$D9A 9A 9A 9$C9 A9 A9 A9$B┌┼┘$A└┐$9│$80 1 2 3 4 5 6 7

Utiliza la salida de @ Marco (reemplaza cada 16 caracteres con una nueva línea (expresión regular: (.{15}).-> \1\n)).

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Erik el Outgolfer
fuente
0

Bash + GNU sed, 140 bytes

sed 'h
s/$/nxxxacnb b b bnyyycanc xxxcnc b b b cnc yyyc/
:
s/x/ac /
s/y/ca /
s/a/└┐/
s/b/┌┼┘/
t
y/cn/│\n/
G'<<<'0 1 2 3 4 5 6 7'

Salida:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

Usando la salida de @ TimmyD : 142 bytes

sed 'h
s/$/npbcccnsurdddnbeeepnp bbbbbbp/
:
s/b/qt/
s/c/quot/
s/d/psor/
s/e/suor/
t
y/nopqrstu/\n─│┌┐└┘┼/
G'<<<'0 1 2 3 4 5 6 7'

Salida:

0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7
Marco
fuente
0

Tcl , 205 bytes

puts "[set B "0 1 2 3 4 5 6 7"]
│┌┘ │┌┘ │┌┘ └┐│
└┼┐ └┼─┐└┼──┐││
┌┘└─┐│ └┐│┌─┼┼┘
│ ┌─┼┘┌─┼┘│ │└┐
$B"

Pruébalo en línea!

salidas

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ └┐│
└┼┐ └┼─┐└┼──┐││
┌┘└─┐│ └┐│┌─┼┼┘
│ ┌─┼┘┌─┼┘│ │└┐
0 1 2 3 4 5 6 7
sergiol
fuente
0

SOGL V0.12 , 64 bytes

└┼─┐³
┘┌┼─┘²
┐│└─┐¹
┌┘┌┘┌┘⁰
│┌²┌┼─²¶└┼¹│└─¹¶┌┘³³³│¶│ ⁰⁰│”8δ@∑Q;O

Pruébalo aquí!

Patrón robado del PowerShell

dzaima
fuente