Dibuja un tablero de sudoku con personajes de dibujo lineal


20

Este es el código de golf. Para este desafío, aceptaré un método (no necesita un programa completo), pero la firma del método no cuenta para el recuento de bytes y quiero ver la firma completa (no una lamdba). La entrada para el método es una matriz entera con 81 elementos. El valor de salida / retorno del método es una cadena que representa la matriz como un tablero ascii sudoku.

Si está utilizando un lenguaje esotérico o algo que absolutamente no tiene métodos, puede adaptarse, pero si el lenguaje lo admite, quiero ver que algo podría estar conectado a un programa no real "real", incluso si el Es un dolor trabajar con el cuerpo del método. El requisito no está destinado a bloquear lenguajes como Jelly o 05AB1E, sino a facilitar que lenguajes como Java construyan algo que tenga sentido para esa plataforma.

Para la entrada, los valores enteros 1-9 deben tener significados obvios. Un 0 siempre debe interpretarse como una celda en blanco. También puede interpretar cualquier otra cosa fuera del rango 1-9 como una celda en blanco, pero esto no es obligatorio. La posición desde la matriz hasta el rompecabezas comienza en la parte superior izquierda y llena cada fila de izquierda a derecha antes de pasar a la siguiente fila.

Para los cuadros, quiero líneas dobles alrededor del exterior y entre cada región 3x3, y líneas simples entre otras celdas. Estos deben dibujarse con caracteres de dibujo lineal (si su formato de E / S representa cadenas como una secuencia de bytes en lugar de una secuencia de caracteres, debe representarlos en una codificación conocida como UTF-8 o página de códigos 347).

Para este desafío, NO te pido que generes el rompecabezas sudoku. Esa es la entrada para la función. NO te estoy pidiendo que resuelvas el rompecabezas. Solo le pido que produzca una cadena para "dibujar" lo que se le da (en la menor cantidad de bytes posible).

Entrada de ejemplo:

Valores para la matriz:

{ 8, 5, 0, 0, 0, 2, 4, 0, 0, 7, 2, 0, 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 0, 2, 3, 0, 5, 0, 0, 0, 9, 0, 0 ,0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 7, 0, 0, 1, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 0, 4, 0}

Los valores pueden usar cualquier mecanismo que sea natural para su idioma: int [], ArrayList, secuencia, tupla, cadena de dígitos, lo que sea, siempre que tenga un valor en la entrada para cada celda (no se asignan solo las celdas pobladas a las posiciones ) Recuerde que la entrada se proporciona ... no es parte de su recuento de bytes. Pero la entrada puede representar cualquier rompecabezas de sudoku, y el rompecabezas puede no tener una solución válida . Asumes que el rompecabezas es imprimible. No obtendrá algo con 82 elementos, por ejemplo.

También puede asumir una fuente razonable de ancho fijo.

Salida correspondiente:

╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗
║ 8 │ 5 │ ║ │ │ 2 ║ 4 │ │ ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 7 │ 2 │ ║ │ │ ║ │ │ 9 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ │ │ 4 ║ │ │ ║ │ │ ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║ │ │ ║ 1 │ │ 7 ║ │ │ 2 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 3 │ │ 5 ║ │ │ ║ 9 │ │ ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ │ 4 │ ║ │ │ ║ │ │ ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║ │ │ ║ │ 8 │ ║ │ 7 │ ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ │ 1 │ 7 ║ │ │ ║ │ │ ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ │ │ ║ │ 3 │ 6 ║ │ 4 │ ║
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝

44
¿Estás seguro de la parte del método? Eso no tiene sentido para muchos idiomas (es decir, idiomas sin métodos).
Cyoce

1
Para los idiomas que no tienen métodos, puede adaptarse. Pero si lo hacen, estoy buscando algo que realmente pueda ser útil para conectar a un programa "real". Agregaré eso a la pregunta.
Joel Coehoorn

2
¿Cuál es el razonamiento para no permitir lambdas? Esos sin duda podrían conectarse a un programa "real" así como a funciones / métodos con nombre
Julian Wolf

2
Nitpicky pero importante: no hay tal cosa como un "personaje de dibujo de cuadro ASCII". ASCII cubre los códigos del 0 al 127, ninguno de los cuales son caracteres de dibujo de recuadro. En los últimos tiempos, Unicode es el estándar, pero tiene varias codificaciones diferentes: UTF-8, UTF-16, etc., todas las cuales usan más de 1 byte por carácter de cuadro de dibujo. Las codificaciones anteriores, como la página de códigos 437, admiten caracteres de dibujo de cuadro de un solo byte. Cuando utiliza caracteres fuera del rango ASCII, debe especificar qué codificaciones son válidas. en.wikipedia.org/wiki/Box-drawing_character en.wikipedia.org/wiki/Unicode
Level River St

2
"Método" probablemente debería ser "función con nombre" para obtener el equivalente más cercano posible a un método en lenguajes no orientados a objetos. (Por ejemplo, C, un lenguaje muy utilizado, no tiene métodos pero tiene funciones con nombre). En la mayoría de los lenguajes que conozco que tienen métodos, son el equivalente de una función con nombre de ese lenguaje. (La excepción más conocida que conozco es C ++, donde usar una función con nombre sería mucho más plausible para esta tarea que usar un método, ya que no está claro con qué tipo de objeto asociaría el método .)

Respuestas:


9

Python 3, 232 bytes

Thanks to those who helped to golf this down.

Encryption within encryption...

q=lambda x,y:x+y+x+y+x
r=lambda a,b,c,d,e:a+q(q(b*3,c),d)+e+"\n"
print(((r(*"╔═╤╦╗")+q(q("║ %d │ %d │ %d "*3+"║\n",r(*"╟─┼╫╢")),r(*"╠═╪╬╣"))+r(*"╚═╧╩╝"))%eval(input())).replace(*"0 "))

Try it online!

To be golfed.


How did I not notice that... that's like the entire reason why I used Python 2, but thanks.
Leaky Nun

1
Actually you're better off using Python 3 since then you won't need the first line.
Erik the Outgolfer

1
You can remove more parens on the last line: tio
Conor O'Brien

Remove definition of f and define i as i=["╔"+(g+"╦")*2+g+"╗"]+d+2*(["╠"+(e+"╬")*2+e+"╣"]+d)+["╚"+(h+"╩")*2+h+"╝"] saves 4 bytes
officialaimm

7

C (gcc), 398 395 291 bytes

Saved 3 bytes by working through the string reversed, and 104 (!) bytes thanks to Leaky Nun.

#include<locale.h>
#define q(x,y) x y x y x
#define D L"╝"q(q("═══","╧"),"╩")"╚"q(q("\n║"q(q(" & ","│"),"║")"║","\n╢"q(q("───","┼"),"╫")"╟"),"\n╣"q(q("═══","╪"),"╬")"╠")"\n╗"q(q("═══","╤"),"╦")"╔"
i;f(int*t){setlocale(LC_ALL,"");for(i=721;i--;)wprintf(L"%lc",D[i]%19?D[i]:*t++?48+t[-1]:32);}

Try it online!

C (gcc), 395 bytes

I'll keep this here so its more evident as to how the program works.

#include<locale.h>
#define A L"\n╢───┼───┼───╫───┼───┼───╫───┼───┼───╟"
#define B L"\n║ & │ & │ & ║ & │ & │ & ║ & │ & │ & ║"
#define C L"\n╣═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╠"
#define E B A B A B
#define D L"╝═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╚"E C E C E L"\n╗═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╔"
i;f(int*t){setlocale(LC_ALL,"");for(i=721;i--;)wprintf(L"%lc",D[i]%19?D[i]:*t++?48+t[-1]:32);}

Try it online!

Working with unicode in C is... costly. Takes input as an int* as shown in the link and in the specification.

I'm going to see if I can save bytes using some number magic instead of hardcoding the string.



@LeakyNun Huh, thanks! It's 291 bytes according to TIO
Conor O'Brien

TIO is counting using SBCS.
Leaky Nun

6

PHP, 297 bytes

<?for(;$l<19;$l++)echo$l&1?strtr(vsprintf(str_pad("",67,"║ %d │ %d │ %d "),array_slice($_GET,9*($l/2^0)-9,9)),0," "):str_pad([╔,╟,╠,╚][$b=$l?$l<18?$l%6<1?2:1:3:0],108,strtr("11101110111".[╦,╫,╬,╩][$b],[[╤,═],[┼,─],[╪,═],[╧,═]][$b])).[╗,╢,╣,╝][$b],"
";

Try it online!

Expanded

for(;$l<19;$l++)  # loop thrpugh lines
  echo$l&1 # Output
    ?strtr(
        vsprintf(str_pad("",67,"║ %d │ %d │ %d ") # formated string for lines with numbers
        ,array_slice($_GET,9*($l/2^0)-9,9)) # nine items of the input array
      ,0," ") #replace zeros with space
    :str_pad([╔,╟,╠,╚][$b=$l?$l<18?$l%6<1?2:1:3:0] # start character non number lines and switch number four cases
      ,108 # fill too 108 bytes
      ,strtr("11101110111".[╦,╫,╬,╩][$b] # with string 
        ,[[╤,═],[┼,─],[╪,═],[╧,═]][$b]))  #replace ones and zero with the two character in array chosed 
    .[╗,╢,╣,╝][$b] # end row with chosen character
  ,"
    "; # end line with new line

used functions for both versions

vsprintf , strtr , str_pad , array_slice , array_chunk

PHP, 313 bytes

<?$r=($s=str_pad)(╔,108,($t=strtr)(($p=11101110111).╦,[╤,═])).╗;foreach(array_chunk($_GET,9)as$v)$r.=$t(vsprintf($s("
",68,"║ %d │ %d │ %d "),$v),0," ").(++$k%9?$k%3?$s("
╟",109,$t($p.╫,[┼,─])).╢:$s("
╠",109,$t($p.╬,[╪,═])).╣:"");echo$r.$s("
╚",109,$t($p.╩,[╧,═])).╝;

Try it online!


¿Como funciona esto?
Cyoce

@Cyoce He agregado una explicación para mi nueva versión
Jörg Hülsermann

5

T-SQL, 445 437 bytes (en 381 caracteres)

DECLARE @r INT=0,@ NVARCHAR(999)=N'╔=╤=╤=╦=╤=╤=╦=╤=╤=╗P'p:SELECT @+=FORMAT(CAST(SUBSTRING(a,@r*9+1,9)AS INT),N'║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P')FROM t
SET @r+=1IF @r=9SET @+=N'╚=╧=╧=╩=╧=╧=╩=╧=╧=╝P'ELSE IF @r%3=0SET @+=N'╠=╪=╪=╬=╪=╪=╬=╪=╪=╣P'ELSE SET @+=N'╟-┼-┼-╫-┼-┼-╫-┼-┼-╢P'IF @r<9GOTO p
PRINT REPLACE(REPLACE(REPLACE(REPLACE(@,'=',N'═══'),'-',N'───'),'0',' '),'P',CHAR(13))

La entrada es a través de una cadena de dígitos almacenados en la columna a de la tabla t existente , según los métodos aprobados .

Formato y explicación :

DECLARE @r INT=0, @ NVARCHAR(999)= N'╔=╤=╤=╦=╤=╤=╦=╤=╤=╗P'
p:
    SELECT @+= FORMAT(CAST(SUBSTRING(a, @r*9+1, 9) AS INT),
        N'║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P') FROM t
    SET @r+=1
    IF @r=9 SET @+= N'╚=╧=╧=╩=╧=╧=╩=╧=╧=╝P'
    ELSE IF @r%3=0 SET @+= N'╠=╪=╪=╬=╪=╪=╬=╪=╪=╣P'
    ELSE SET @+= N'╟-┼-┼-╫-┼-┼-╫-┼-┼-╢P'
IF @r<9 GOTO p
PRINT REPLACE(REPLACE(REPLACE(REPLACE(@, '=',N'═══'), '-',N'───'), '0',' '), 'P',CHAR(13))

En la línea superior del bucle, obtengo los siguientes 9 dígitos de la cadena de entrada de la columna a de la tabla preexistente t .

Convierto esa cadena de dígitos en un número entero, y uso la FORMATfunción .Net para mostrarlos usando una plantilla de texto personalizada '║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P'.

Después de eso, solo agrego la línea divisoria adecuada y hago algunos reemplazos para guardar bytes antes de la salida.

La salida se muestra en el panel de resultados:

╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗
║ 8 │ 5 │   ║   │   │ 2 ║ 4 │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 7 │ 2 │   ║   │   │   ║   │   │ 9 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │   │ 4 ║   │   │   ║   │   │   ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║   │   │   ║ 1 │   │ 7 ║   │   │ 2 ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║ 3 │   │ 5 ║   │   │   ║ 9 │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │ 4 │   ║   │   │   ║   │   │   ║
╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣
║   │   │   ║   │ 8 │   ║   │ 7 │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │ 1 │ 7 ║   │   │   ║   │   │   ║
╟───┼───┼───╫───┼───┼───╫───┼───┼───╢
║   │   │   ║   │ 3 │ 6 ║   │ 4 │   ║
╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝

Anteriormente tuve algunos reemplazos adicionales para algunos de los otros personajes de dibujo, pero finalmente no me ahorraron bytes.

EDITAR 1 : guardado 8 bytes comenzando @ren cero en lugar de 1, y eliminando algunos espacios innecesarios.


4

Retina , 196 167 bytes

.{27}
¶N#=XZ#Q¶|$&
\d{9}\B
$&¶M#─┼Y#P¶|
\d{3}
 $& |
\B\d
 │ $&
^¶.*
B#=RT#E
$
¶H#=UW#K
+`#([^#¶]+)([^#¶])#
#$1#$2#$1#$2#$1#
#(.)#
$1$1$1
T`0=|#L` ═-╬

Pruébalo en línea! Toma la entrada como una cadena de longitud 81. Explicación: Debido a que los caracteres de dibujo de recuadro cuestan tres bytes, los puntos de código Unicode ═-╬se representan en el código utilizando =|#A-Z(no todos los caracteres se utilizan, pero si se ajustan a rangos se ahorran bytes). Además, las filas se comprimen mediante #signos: se a#bcd#eexpande a abbbcbbbcbbbdbbbcbbbcbbbdbbbcbbbcbbbe.

.{27}
¶N#=XZ#Q¶|$&

Inserciones ╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣para cada tercera fila, más un al comienzo de cada grupo de 27.

\d{9}\B
$&¶M#─┼Y#P¶|

Inserta ╟───┼───┼───╫───┼───┼───╫───┼───┼───╢entre las otras filas, más s al comienzo de esas filas.

\d{3}
 $& |

Inserta s después de cada tres dígitos. Todos los s ahora se han insertado.

\B\d
 │ $&

Inserta |s entre todos los pares de dígitos restantes. (Este es el carácter de dibujo de caja real en lugar de una tubería. Desafortunadamente, los caracteres ─│┼tienen códigos demasiado separados entre sí y los caracteres de caja doble para que valga la pena al usar marcadores de posición).

^¶.*
B#=RT#E

Cambia la primera fila a ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗(esto ahorra 1 byte al no agregar la primera fila en primer lugar).

$
¶H#=UW#K

Agrega ╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝después de la última fila.

+`#([^#¶]+)([^#¶])#
#$1#$2#$1#$2#$1#

Se expande a#bcd#e, primero a a#bc#d#bc#d#bc#e, luego a a#b#c#b#c#b#d#b#c#b#c#b#d#b#c#b#c#b#e.

#(.)#
$1$1$1

Cambios #b#a bbb. Esto completa la descompresión.

T`0=|#L` ═-╬

Elimina todas las entradas cero y reemplaza los marcadores de posición con los caracteres de dibujo del cuadro.


Olvidaste reemplazarlo 0por espacio.
Leaky Nun

También tiene líneas dobles alrededor de cada fila, en lugar de solo el borde y las regiones 3x3.
Joel Coehoorn

@JoelCoehoorn Corregido, lo siento.
Neil

@LeakyNun Gracias, lo había pasado por alto. (Además, me gusta evitar las líneas que terminan con, o especialmente que contienen espacios, por eso busqué un ahorro alternativo de 2 bytes.)
Neil

3

SOGL V0.12 , 174 172 164 160 158 bytes

«ž#>]Wž²6√±_ΕΨ╥╬]v←ē⅓ZΗ⌡z∫◄‽q   §↑╗∑Ολ[Μ↕z↓/∆Yn⁄:Ο║χ≥¾▓g*≈]═+π℮─6⁽SE/⁷,0+►Ƨ⌡u\^⁄-▼0cΦ“╤─┼╬│║═╔╗╚╝”Φ⅜nΡ¡ΞΨīŗ(`½│uģ“ ╬ζ─{ζ} 6Δ¹∑A'⁄─{IaW}¹∑#¶ŗ3 ¶ŗ ”+Ƨøp+!!┌d0@ŗčŗ

Explicación demasiado larga:

...“                          push a big base-43 encoded number; will be used later. It's pushed here to save a byte on a quote
    ...”                      push "╤─┼╬│║═╔╗╚╝" - the chars in SOGLs encoding
        ...“                  push 679301851737965572513837476350078477
             ╬                push "╬"
              ζ               convert it to its codepoint (9580)
               ─              convert that number to an array of base-9580 numbers
                {ζ}           convert each number to a character (pushing each on the stack)
                    6Δ        push all ascii chars up to 6 (" !"#$%&'()*+,-./0123456")
                      ¹∑      join all the strings on the stack together ("╤─┼╬│║═╔╗╚╝╦╟╫╢╠╪╣╧╩ !"#$%&'()*+,-./0123456")
                        A     save on variable `A`. Now ontop of the stack is the 1st big number
                         '⁄─  onvert from base 43

{   }                           for each number do
 I                                increase
  aW                              get its position in the variable A
     ¹∑                         join all the strings ontop of the stack (the loop above pushed each char separately)
       #¶ŗ                      replace quote (") characters with newlines
          3 ¶ŗ                  replace 3s with "¶"
               ”+               append "”"
                 Ƨøp+           append "øp"
                     !!         execute the created code as SOGL
                       ┌        push "-"
                        d       push variable d - defaults to string input. In a full program could be set as an input
                         0@ŗ    replace zeroes with spaces
                            č   chop into an array
                             ŗ  replace ["-" with input chopped - so each iteratively]

El programa que se ejecuta:

───!#
 - $
¶%&¶'(
)╪)╪)+
)╤)╤),
)╧)╧).
┼#
+╬+/
0!╫0!1
,╦,2
.╩.4
5│$║&
#0
═══)
$│$5
║&&%
╠/╬+╣6'*
╟1╫0!╢(
(6
╔2╦,╗6'**╚4╩.╝”øp

donde todos menos la última línea son justos in the entire program replace occurrences of the last char of this line with the rest of this line. Esta es la razón por la que fue posible hacer que la mitad de los caracteres solo fueran ascii aleatorios (pero conseguir que los espacios, guiones y comillas se usen útilmente tomó un tiempo para darse cuenta)

...”    push the whole sudoku grid
    øp  print nothing (prevents bug that this code would already print and pop the result)

Pruébalo aquí!
El código de intérprete en línea es más correcto porque las pestañas no funcionan con SE

-8 bytes: reemplazo de fuerza bruta comprimiendo toda la placa, luego reemplazando caracteres extraños (a la página de códigos) con sus puntos de código. Hacer esto tomó una hora menos que el programa anterior ...
-4 bytes: comprimiendo la cadena comprimida ...
-2 bytes: usando una variable + cadena en lugar de una matriz


2

JavaScript (ES6), 246 bytes / 198 caracteres

(n,r=(x,y)=>x+y+x+y+x,q=s=>([u,w,x,y,z]=[...s[0]],u+r(r(w+w+w,x),y)+z+`
`))=>q`╔═╤╦╗`+n.reduce((o,v,i)=>o+"║││"[i++%3]+` ${v||" "} `+(i%9?e:`║
`+(i-27&&i-54?i<81?q`╟─┼╫╢`:e:q`╠═╪╬╣`)),e="")+q`╚═╧╩╝`

La entrada es una matriz de enteros. Terminé usando las mismas dos funciones de ayuda que la respuesta Python de Leaky Nun , por lo que el crédito va allí.

Si functiones necesario, 263 bytes / 215 caracteres

function g(n,r=(x,y)=>x+y+x+y+x,q=s=>([u,w,x,y,z]=[...s[0]],u+r(r(w+w+w,x),y)+z+`
`)){return q`╔═╤╦╗`+n.reduce((o,v,i)=>o+"║││"[i++%3]+` ${v||" "} `+(i%9?e:`║
`+(i-27&&i-54?i<81?q`╟─┼╫╢`:e:q`╠═╪╬╣`)),e="")+q`╚═╧╩╝`}

Fragmento de prueba

Se admite cualquier entrada de 81 números ( 1234, 1, 2, 3, 4. [1 2 3 4], Etc.). Mejor visto como página completa.

f=
(n,r=(x,y)=>x+y+x+y+x,q=s=>([u,w,x,y,z]=[...s[0]],u+r(r(w+w+w,x),y)+z+`
`))=>q`╔═╤╦╗`+n.reduce((o,v,i)=>o+"║││"[i++%3]+` ${v||" "} `+(i%9?e:`║
`+(i-27&&i-54?i<81?q`╟─┼╫╢`:e:q`╠═╪╬╣`)),e="")+q`╚═╧╩╝`

onload=I.oninput=_=>O.innerHTML=(m=I.value.match(/\d/g))&&m.length==81?f(m.map(x=>+x)):''
<textarea id=I rows=3 style="width:95%">8, 5, 0, 0, 0, 2, 4, 0, 0, 7, 2, 0, 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 7, 0, 0, 2, 3, 0, 5, 0, 0, 0, 9, 0, 0 ,0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 7, 0, 0, 1, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 0, 4, 0</textarea>
<pre id=O>


2

Lote, 332 bytes.

@echo off
set/ps=
set s=%s:0= %
call:l É Í Ñ Ë »
set t="Ç Ä Å × ¶"
for %%i in (%t% %t% "Ì Í Ø Î ¹" %t% %t% "Ì Í Ø Î ¹" %t% %t% "È Í Ï Ê ¼")do call:c %%~i
exit/b
:c
set t=º
for %%j in (³ ³ º ³ ³ º ³ ³ º)do call set t=%%t%% %%s:~,1%% %%j&call set s=%%s:~1%%
echo %t%
:l
set t=%2%2%2%3%2%2%2%3%2%2%2
echo %1%t%%4%t%%4%t%%5

Necesita que la consola esté en CP437. Si ese no es su valor predeterminado, puede cambiarlo usando el CHCP 437comando si su consola está configurada con fuentes TrueType. (Solo funcionará con fuentes ráster si CP437 ya es su página de códigos predeterminada). Así es como se ve el código en CP437:

@echo off
set/ps=
set s=%s:0= %
call:l ╔ ═ ╤ ╦ ╗
set t="╟ ─ ┼ ╫ ╢"
for %%i in (%t% %t% "╠ ═ ╪ ╬ ╣" %t% %t% "╠ ═ ╪ ╬ ╣" %t% %t% "╚ ═ ╧ ╩ ╝")do call:c %%~i
exit/b
:c
set t=║
for %%j in (│ │ ║ │ │ ║ │ │ ║)do call set t=%%t%% %%s:~,1%% %%j&call set s=%%s:~1%%
echo %t%
:l
set t=%2%2%2%3%2%2%2%3%2%2%2
echo %1%t%%4%t%%4%t%%5

2

Con ideas cosechadas de otras respuestas:

C # (.NET Core) , 401 bytes, 349 caracteres

string s(string x){Func<string,string,string>q=(m,n)=>m+n+m+n+m;var a="╔"+q(q("=","╤"),"╦")+"╗";for(var i=0;i<9;) {a+=int.Parse(x.Substring(i*9,9)).ToString("\n║"+q(q(" 0 ","│"),"║")+"║\n")+(i++<8?(i%3>0?"╟"+q(q("-","┼"),"╫")+"╢":"╠"+q(q("=","╪"),"╬")+"╣"):"╚"+q(q("=","╧"),"╩")+"╝");}return a.Replace("=","═══").Replace("-","───").Replace("0"," ");}

Sin golf:

static public string s(string x)
{
    Func<string,string,string>q=(m,n)=>m+n+m+n+m;
    var a="╔"+q(q("=","╤"),"╦")+"╗";
    for (var i=0;i<9;) //once per row
    {
        //parse that row to an int, then spit out a formatted string
        a += int.Parse(x.Substring(i*9,9)).ToString("\n║"+q(q(" 0 ","│"),"║")+"║\n") 
          // as well as a trailing row for the box
          + (i++<8?(i%3>0?"╟"+q(q("-","┼"),"╫")+"╢":"╠"+q(q("=","╪"),"╬")+"╣"):"╚"+q(q("=","╧"),"╩")+"╝");
    }
    //expand placeholder characters before returning
    return a.Replace("=","═══").Replace("-","───").Replace("0"," ");
}

Pruébalo en línea!

Mi respuesta:

C # (.NET Core) , 509430418 bytes, 328 caracteres

string b(string x){var a="╔=╤=╤=╦=╤=╤=╦=╤=╤=╗\n║";for(int i=0,j=0,k,l,m;j<3;j++)for(k=0;k<3;k++){for(l=0;l<3;l++)for(m=0;m<3;)a+=" "+x[i++]+(m++<2?" │":" ║");a+=i<80?(k<2?"\n╟-┼-┼-╫-┼-┼-╫-┼-┼-╢\n║":"\n╠=╪=╪=╬=╪=╪=╬=╪=╪=╣\n║"):"\n╚=╧=╧=╩=╧=╧=╩=╧=╧=╝";}return a.Replace("=","═══").Replace("-","───").Replace("0"," ");}

Sin golf:

public string s(string x)
{
    var a = "╔=╤=╤=╦=╤=╤=╦=╤=╤=╗\n║";
    for (int i=0,j=0,k,l,m;j<3;j++)
    {
        for (k = 0; k < 3;k++)
        {
            for (l = 0; l < 3; l++)
            {
                for (m = 0; m < 3;)
                    a += " " + x[i++] + (m++ < 2 ? " │" : " ║");
            }
            a += i < 80 ? (k < 2 ? "\n╟-┼-┼-╫-┼-┼-╫-┼-┼-╢\n║": "\n╠=╪=╪=╬=╪=╪=╬=╪=╪=╣\n║") 
                        : "\n╚=╧=╧=╩=╧=╧=╩=╧=╧=╝";
        }
    }
    return a.Replace("=", "═══").Replace("-","───").Replace("0"," ");
}

I also looked at using a lambda for the `for` loops here, but it actually cost me one byte (saved 10 bytes per loop, with 41 bytes of overhead).

Pruébalo en línea!


¿Necesita contar cada carácter de dibujo como dos bytes?
BradC

Lo hice, arreglado ahora. Tenía la intención de abordar eso en cuestión y contar caracteres en lugar de bytes, debido a esos caracteres, pero supongo que ya es demasiado tarde.
Joel Coehoorn

Sí, los bytes son más difíciles, algunas sustituciones ascii ahorran bytes pero no afectan a los caracteres (o incluso a los caracteres dañados). Estoy trabajando en T-SQL, y char vs nchar es una gran diferencia.
BradC

1

Chip , 3645 bytes

... eso no es un error tipográfico ...

ooooooZZ-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-).
|`xxxx-x--(x---x---x---x---x-v-x---x---x---x---x---x-.`K-)-K-)-K-)-K-).
|b|`xx-x--(x-v-x---x-v-x---x-x-x---x-v-x---x-v-x---x-x-x---x-v-x---x-.`K-).
|>xd`x-x(v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-v-x-x-x-.|
||`--x-x-x(x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x/.
|`--z',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\',/\','
`-. |,< >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.| >.|
*-x-/xZ/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ^/xZ'
Z~' |`'|`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`' |`','`'
    `)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)-K-)'
=
oooooo).h
`)))--^M^Zh
=
oooooo
|    `(--------------------------------------------------------------------------------------------------------va
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ^cg
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx-xKZvvZ
xxxxxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx-Kxxxx}e
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)x))xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)x))xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)x)b`feac
  c
=
oooooo
,'   `(--------------------------------------------------------------------------------------------------------.cba
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ^x^^)v--.
xx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx-xK-'f e`.
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx-x-K-+Z+Z}e
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxK^}b gac
xxxxxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx-K^d
=
oooooo
,-'
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZtabgfv------.
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx-xK^^x-Zv-vZ}e
xxxxxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxxK^---^}cade,]b
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)-K----^-^^~'
,v'
db
=
oooooo
,--' `(--------------------------------------------------------------------------------------------------------v-.,-v-ZZZZZZZZZZZZf
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ'a{x.df
)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xx)xxKx-xxv+Zc
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)x-KZx+bge
xx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxx)xxxxxxxxxxxx---K\--^c
 a^b
=
oooooo
,---'`(--------------------------------------------------.
KZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ'gf
)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xxxxx)xx-^KZc
)xxxxx)x)xxx)x)xxx)xxxxx)x)xxx)x)xxx)xxxxx)x)xxx)x)xxx)xxbahKZ\ZZZ
x))xxxxxxxxxxxxxxxx))xxxxxxxxxxxxxxxx))xxxxxxxxxxxxxxxx))-K-eh|fff
 ,--K-v-v-K--v-vK-v---K-----K-----K-----K-----K-----K `--Z-Z--'
A/ab/B/e/C/cd/D/-e/A
*}s

Pruébalo en línea! , algo así como. La versión TIO contiene un límite de aproximadamente un tercio del camino (elt después del 4to.oooooo ), por lo que debe terminar en menos de 60 segundos. La versión completa tarda aproximadamente 1m25s en mi máquina, y TIO parece casi la mitad de rápido. Esto también significa que el TIO solo muestra las primeras 7 líneas de salida.

Mi primer borrador pesaba unos 19758 bytes masivos, y me llevó unos 8m30s para ejecutar. La solución final, antes del golf, fue un veloz 5980 bytes, con solo 2m07s.

Entonces, ¿cómo funciona?

Esto toma una cadena de 82 bytes, 81 dígitos, seguida de un terminador. \0o \nincluso otro número servirá. (Esta implementación en realidad solo mira los primeros 81, pero requiere al menos uno más, ya que Chip terminará si ha agotado su entrada. Si esto es inaceptable, -zse puede usar el indicador , que efectivamente agrega un número infinito de \0bytes al final de la entrada.) El código TIO acortado en realidad no llega a los 81 bytes, por lo que el punto es discutible allí.

La forma en que he implementado esto, solo mira los 4 bits bajos de la entrada, por lo que cualquier cosa, realmente, puede ser un 'rompecabezas' de sudoku, desde datos binarios en bruto, hasta los trabajos menos conocidos de Shakespeare. Cualquier carácter cuyos 4 bits bajos sean todos cero aparecerá como un espacio (un caso especial), en el que se asignarán todos los demás caracteres 123456789:;<=>?. (Entonces, los últimos pocos no son dígitos, pero tampoco es 10 un número válido en sudoku normal).

Para los caracteres de dibujo de caja, produce UTF-8, que equivale a 3 bytes cada uno.

¿Qué pasa con la implementación real?

Chip es un lenguaje 3D inspirado en los circuitos integrados. Tiene cables, puertas lógicas y celdas de memoria. La mayoría de las cosas se hacen en planos 2D, pero estos planos pueden apilarse uno encima del otro. Así es como se construye este programa.

Las líneas que comienzan con =son los separadores de capas. Luego, las capas se apilan, con los lados superior e izquierdo alineados. loso sirven como pines, permitiendo que las señales pasen de una capa a otra.

Cada capa aquí tiene un propósito, podría pensar en ellas como funciones. La primera capa controla todo; 'llama' a cada una de las otras capas a su vez. Aquí hay un patrón repetitivo de izquierda a derecha. Ese patrón realiza un seguimiento de cuál de las 19 líneas de salida que estamos imprimiendo actualmente.

La segunda capa es bastante pequeña y tiene un trabajo muy pequeño. Establece el 0x80bit para todas las líneas de salida, excepto las líneas que contienen números. hes el elemento Chip que corresponde al 0x80bit. (El extremo inferior del alfabeto a htravés dea definir los ocho bits de salida.)

La capa tres es donde realmente nos metemos en la carne de la impresión. Esta capa está a cargo de la línea uno. La versión sin golf tiene ocho filas de x's y) ' s, asignadas a 0 y 1 para cada uno de los ocho bits de cada byte. Sin embargo, podemos aprovechar los patrones en los bits para realizar la misma tarea en menos filas.

La capa cuatro es muy parecida a la tercera. Maneja las líneas dobles horizontales.

La capa cinco maneja la última línea. Tenga en cuenta que le falta el cable a lo largo de la parte superior que tienen las otras capas. Esto se debe a que no necesitamos devolver el control al secuenciador. En cambio, podemos terminar la ejecución aquí con t.

La capa seis maneja las líneas simples horizontales.

La capa siete es donde se imprimen los números. Se 'llama' para cada una de las nueve líneas numéricas. Consume 9 bytes de entrada como parte de su ejecución.


1

JavaScript (ES6), 222 bytes

Uso de sintaxis corta para funciones ES6: 174 caracteres codificados en utf8, 222 bytes ( https://mothereff.in/byte-counter ). El uso function ...requiere 16 bytes más.

F=v=>[1,...v].map((x,i)=>'│║│'[i%3]+` ${x||' '} `+(i%9?'':`║
${[h,r,s,u,t]=i%27?'─╟╫┼╢':i>80?'═╚╩╧╝':i?'═╠╬╪╣':'═╔╦╤╗',r+(s=(u=(h+=h+h)+u+h+u+h)+s)+s+u+t}
`)).join``.slice(6)

Menos golf

F=v=>{
   // horizontal lines are appended after each 9th element
   // so I need to prepend a dummy first element to draw the top horizontal line
   v = [1, ...v];
   return v.map( (x,i) => 
     '│║│'[i % 3] + ` ${x||' '} ` // left bar and cell value
     + ( i % 9 ? '' // add horizontal line after each 9th element
       // the line drawing characters are chosen according to the value of i
       : `║\n${ [h, r, s, u, t] = 
         i % 27 != 0
         ? '─╟╫┼╢'
         : i > 80 
           ? '═╚╩╧╝' // i==81, bottom row
           : i != 0
             ? '═╠╬╪╣'
             : '═╔╦╤╗', // i==0, top row
         r + (s = (u = (h += h + h) + u + h + u + h) + s) + s + u + t
         }\n`
       )
   ).join``
   .slice(6) // cut the first cell (the dummy element)
}

F=v=>[1,...v].map((x,i)=>'│║│'[i%3]+` ${x||' '} `+(i%9?'':`║
${[h,r,s,u,t]=i%27?'─╟╫┼╢':i>80?'═╚╩╧╝':i?'═╠╬╪╣':'═╔╦╤╗',r+(s=(u=(h+=h+h)+u+h+u+h)+s)+s+u+t}
`)).join``.slice(6)

function go() {
  var i=I.value
  i = i.match(/\d+/g).map(x => +x); // convert strings to numbers
  O.textContent = F(i)
}
#I { width: 90% }
<input id=I value='8 5 0 0 0 2 4 0 0 7 2 0 0 0 0 0 0 9 0 0 4 0 0 0 0 0 0 0 0 0 1 0 7 0 0 2 3 0 5 0 0 0 9 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0 8 0 0 7 0 0 1 7 0 0 0 0 0 0 0 0 0 0 3 6 0 4 0'>
<button onclick='go()'>go</button>
<pre id=O></pre>


1

Java (OpenJDK 8) , 279 bytes

String f(int[]a){String P="0121213121213121214",R[]={"╔═╤╦╗","║ │║║x","╟─┼╫╢","╠═╪╬╣","╚═╧╩╝"},r="";for(int X:P.getBytes()){for(int x:P.replace("1",R[X-=48].length()>5?"151":"111").getBytes())r+=R[X].charAt(x-48);r+="\n";}for(int i:a)r=r.replaceFirst("x",i>0?""+i:" ");return r;}

Pruébalo en línea!

Para el recuento de bytes, use CP-437, que es compatible de forma nativa con Java como IBM437(API recientes) oCp437 (API más antiguas); utilice un sistema que tenga este juego de caracteres que tenga este juego de caracteres como juego de caracteres predeterminado

Este código es compatible desde Java 5 en adelante, pero se probó solo en Java 8.

Explicación

String f(int[]a){
  String P="0121213121213121214",                         // Both lines and rows are repeated according to this pattern.
         R[]={"╔═╤╦╗","║ │║║x","╟─┼╫╢","╠═╪╬╣","╚═╧╩╝"},  // Characters found on each line.
                                                          //   (note the 'x')
         r="";                                            // The string under construction
  for (int X: P.getBytes()) {                             // For each line,
    for (int x:                                           //  For each character in the pattern,
         P.replace("1",R[X-=48].length()>5?"151":"111")   //    *but* with a cell width of 3,
                                                          //    and with an optional character ('x')
         .getBytes())
      r+=R[X].charAt(x-48);                               //   append the real mapped character
    r+="\n";                                              //  then append a new line
  }
  for(int i:a)                                            // For each number in the input
    r = r.replaceFirst("x",i>0?""+i:" ");                 //  replace the first 'x' with that number.
                                                          //    (or space if zero)
  return r;                                               // Return the constructed string.
}

1

Tcl , 599 bytes (295 caracteres)

Enfoque muy ingenuo, pero solo tenía que hacerlo aunque no fuera un ganador en ninguna medida:

puts ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗
set r ║ 
lmap x $L {if !$x {set x \ }
set r $r\ $x\ [expr [incr i]%3?"│":"║"]
if ![expr $i%9] {puts $r\n[expr $i%27?"╟───┼───┼───╫───┼───┼───╫───┼───┼───╢":$i<72?"╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣":"╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝"]
set r ║}}

Pruébalo en línea!


eso es 599 bytes UTF-8. Debería intentar reutilizar los caracteres del cuadro común para guardar bytes
dzaima

@dzaima: lo sé, puedo hacer lo que hice en un teclado tan real que casi puedes PROBARLO
sergiol

@dzaima: Por eso dije un enfoque muy ingenuo
sergiol
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.