Das ist Code Golf. Für diese Herausforderung akzeptiere ich eine Methode (Sie benötigen kein vollständiges Programm), aber die Methodensignatur wird für die Byteanzahl gezählt, und ich möchte die vollständige Signatur sehen (keine Lamdba). Die Eingabe für die Methode ist ein Integer-Array mit 81 Elementen. Der Ausgabe- / Rückgabewert der Methode ist eine Zeichenfolge, die das Array als ASCII-Sudoku-Karte darstellt.

Wenn Sie eine esoterische Sprache verwenden oder etwas, das absolut keine Methoden hat, können Sie sich anpassen, aber wenn die Sprache dies überhaupt unterstützt, möchte ich sehen, dass tatsächlich etwas in ein "echtes" ungolfed Programm eingesteckt wird, selbst wenn das Der Methodenkörper selbst ist ein Schmerz, mit dem man arbeiten muss. Die Anforderung soll nicht Sprachen wie Jelly oder 05AB1E blockieren, sondern es Sprachen wie Java erleichtern, etwas zu erstellen, das für diese Plattform sinnvoll ist.

Für die Eingabe sollten die ganzzahligen Werte 1 bis 9 offensichtliche Bedeutungen haben. Eine 0 sollte immer als leere Zelle interpretiert werden. Sie können auch alles andere außerhalb des Bereichs von 1 bis 9 als leere Zelle interpretieren, dies ist jedoch nicht erforderlich. Die Positionierung vom Array zum Puzzle beginnt oben links und füllt jede Zeile von links nach rechts, bevor zur nächsten Zeile übergegangen wird.

Für die Felder möchte ich doppelte Linien um die Außenseite und zwischen jeder 3x3-Region und einzelne Linien zwischen anderen Zellen. Diese sollten mit Strichzeichen gezeichnet werden (wenn Ihr E / A-Format Zeichenfolgen als Folge von Bytes und nicht als Folge von Zeichen darstellt, sollten Sie sie in einer bekannten Codierung wie UTF-8 oder Codepage 347 darstellen).

Für diese Herausforderung bitte ich Sie NICHT , das Sudoku-Puzzle zu generieren. Das ist der Eingang für die Funktion. Ich bitte Sie NICHT , das Rätsel zu lösen. Ich bitte Sie nur, eine Zeichenfolge zu erstellen, um zu "zeichnen", was Sie erhalten (in so wenigen Bytes wie möglich).

Beispiel Eingabe:

Werte für das Array:

{ 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}

Die Werte können den für Ihre Sprache natürlichen Mechanismus verwenden: int [], ArrayList, sequence, tuple, string of digits, was auch immer, solange Sie für jede Zelle einen Wert in der Eingabe haben (keine Zuordnungen nur für bestückte Zellen zu Positionen) ). Denken Sie daran, dass die Eingabe bereitgestellt wird ... sie ist nicht Teil Ihrer Byteanzahl. Die Eingabe kann jedoch ein beliebiges Sudoku-Puzzle darstellen, und das Puzzle hat möglicherweise nicht einmal eine gültige Lösung . Sie bekommen davon ausgehen , dass Puzzle ist bedruckbar. Sie werden zum Beispiel mit 82 Elementen nichts bekommen.

Sie können auch von einer angemessenen Schriftart mit fester Breite ausgehen.

Entsprechende Ausgabe:

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

Python 3 , 232 Bytes

Vielen Dank an diejenigen, die geholfen haben, das Golf zu spielen.

Verschlüsselung innerhalb der Verschlüsselung ...

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 "))

Probieren Sie es online!

Golf spielen.

C (gcc) , 398 395 291 Bytes

Durch umgekehrtes Durcharbeiten der Zeichenfolge wurden 3 Byte und durch Leaky Nun 104 (!) Byte eingespart.

#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);}

Probieren Sie es online!

C (gcc) , 395 Bytes

Ich werde das hier beibehalten, damit klarer wird, wie das Programm funktioniert.

#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);}

Probieren Sie es online!

Die Arbeit mit Unicode in C ist ... kostspielig. Nimmt Eingaben alsint* im Link und in der Spezifikation gezeigt vor.

Ich werde sehen, ob ich mit etwas Zahlenmagie Bytes speichern kann, anstatt die Zeichenfolge hart zu codieren.

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

Probieren Sie es online!

Erweitert

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

verwendete Funktionen für beide Versionen

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.╩,[╧,═])).╝;

Probieren Sie es online!

T-SQL, 445 437 Bytes (in 381 Zeichen)

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

Eingang über eine Folge von Ziffern in der Spalte gespeichert a vorbestehender Tabelle t , pro anerkannten Methoden .

Format und Erklärung :

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

In der obersten Zeile der Schleife erhalte ich die nächsten 9 Stellen der Eingabezeichenfolge aus der Spalte a der bereits vorhandenen Tabelle t .

Ich konvertiere diese Ziffernfolge in eine Ganzzahl und verwende die .Net- FORMATFunktion, um sie mithilfe einer benutzerdefinierten Textvorlage anzuzeigen '║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P'.

Danach hänge ich einfach die entsprechende Trennlinie an und ersetze sie vor der Ausgabe bytesparend.

Die Ausgabe wird im Ergebnisbereich angezeigt:

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

Ich hatte vorher einige zusätzliche Ersetzungen für einige der anderen Zeichen, aber sie haben mir letztendlich keine Bytes erspart.

BEARBEITEN 1 : 8 Bytes werden gespeichert, indem @rbei Null anstelle von 1 begonnen und nicht benötigte Leerzeichen entfernt werden.

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

Probieren Sie es online! Wird als Zeichenfolge mit der Länge 81 eingegeben. Erläuterung: Da die Zeichen in der Box drei Bytes kosten, werden die Unicode-Codepunkte ═-╬im Code mit dargestellt =|#A-Z(nicht alle Zeichen werden verwendet, aber es werden Bytes gespeichert, wenn Bereiche eingehalten werden). Zusätzlich werden die Zeilen mit #Vorzeichen komprimiert : a#bcd#eerweitert um abbbcbbbcbbbdbbbcbbbcbbbdbbbcbbbcbbbe.

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

Einfügungen ╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣für jede dritte Reihe sowie ein ║am Anfang jeder Gruppe von 27.

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

Fügt ╟───┼───┼───╫───┼───┼───╫───┼───┼───╢zwischen den anderen Zeilen plus ║s am Anfang dieser Zeilen ein.

\d{3}
 $& |

Fügt ║s nach jeweils drei Ziffern ein. Alle ║s wurden nun eingefügt.

\B\d
 │ $&

Fügt |s zwischen alle verbleibenden Ziffernpaare ein. (Dies ist das eigentliche Boxzeichen und keine Pipe. Leider haben die Zeichen ─│┼Codes, die zu weit voneinander entfernt sind, und die Doppelboxzeichen, um Platzhalter zu verwenden.)

^¶.*
B#=RT#E

Ändert die erste Zeile in ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗(dies spart 1 Byte, wenn die erste Zeile nicht an erster Stelle hinzugefügt wird).

$
¶H#=UW#K

Fügt ╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝nach der letzten Zeile hinzu.

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

Erweitert a#bcd#esich zuerst zu a#bc#d#bc#d#bc#e, dann zu a#b#c#b#c#b#d#b#c#b#c#b#d#b#c#b#c#b#e.

#(.)#
$1$1$1

Änderungen #b#an bbb. Damit ist die Dekomprimierung abgeschlossen.

T`0=|#L` ═-╬

Löscht alle Null-Einträge und ersetzt die Platzhalter durch die Zeichen der Kastenzeichnung.

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@ŗčŗ

Zu lange Erklärung:

...“                          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]

Das ausgeführte Programm:

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

wo alle bis auf die letzte Zeile gerade sind in the entire program replace occurrences of the last char of this line with the rest of this line. Dies ist der Grund, warum es möglich war, die Hälfte der Zeichen als zufällige ASCII-Zeichen zu definieren.

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

Probieren Sie es hier aus!
Der Online-Interpretercode ist korrekter, da Tabs mit SE nicht funktionieren

-8 Bytes: Brute-Force-Ersatz, der das gesamte Board komprimiert und dann fremde Zeichen (zur Codepage) durch ihre Codepunkte ersetzt. Dies dauerte eine Stunde weniger als das alte Programm ...
-4 Bytes: Komprimieren der komprimierten Zeichenfolge ...
-2 Bytes: Verwenden einer Variablen + Zeichenfolge anstelle eines Arrays

JavaScript (ES6), 246 Byte / 198 Zeichen

(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`╚═╧╩╝`

Die Eingabe ist ein Array von Ganzzahlen. Endete mit den gleichen zwei Hilfsfunktionen wie die Python-Antwort von Leaky Nun verwendet , also geht das Verdienst dahin.

Ob function erforderlich, 263 Byte / 215 Zeichen

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`╚═╧╩╝`}

Testschnipsel

Jede Eingabe von 81 Nummern wird unterstützt ( 1234, 1, 2, 3, 4. [1 2 3 4], Etc). Am besten als ganze Seite betrachtet.

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>

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

Die Konsole muss sich im CP437 befinden. Wenn dies nicht Ihre Standardeinstellung ist, können Sie sie mit dem CHCP 437Befehl ändern, wenn Ihre Konsole auf TrueType-Schriftarten eingestellt ist. (Es funktioniert nur mit Raster-Schriftarten, wenn CP437 bereits Ihre Standard-Codepage ist.) So sieht der Code in CP437 aus:

@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

Mit Ideen aus anderen Antworten:

C # (.NET Core) , 401 Byte, 349 Zeichen

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"," ");}

Ungolfed:

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"," ");
}

Probieren Sie es online!

Meine Antwort:

C # (.NET Core) , 509 430 418 Byte, 328 Zeichen

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"," ");}

Ungolfed:

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).

Probieren Sie es online!

Chip , 3645 Bytes

^{... das ist kein Tippfehler ...}

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

Probieren Sie es online! irgendwie. Die TIO - Version enthält einen Cutoff von ungefähr einem Drittel des Weges in (thet nach dem 4oooooo ), sodass die in weniger als 60 Sekunden erfolgen sollte. Die Vollversion benötigt auf meinem Computer ungefähr 1: 25 Minuten, und TIO scheint ungefähr halb so schnell zu sein. Dies bedeutet auch, dass der TIO nur die ersten 7 Ausgabezeilen anzeigt.

Mein erster Entwurf wog bei massiven 19758 Bytes und brauchte ungefähr 8:30 Minuten, um zu rennen. Die endgültige Lösung, das Pre-Golfing, war ein Spry von 5980 Bytes, der nur 2m07s benötigte.

Wie funktioniert es dann?

Dies dauert eine Zeichenfolge von 82 Bytes, 81 Ziffern, gefolgt von einem Abschlusszeichen. \0oder \noder sogar eine andere Nummer reicht aus. (Diese Implementierung betrachtet eigentlich nur die ersten 81, benötigt aber mindestens eine weitere, da Chip beendet wird, wenn seine Eingabe erschöpft ist. Wenn dies nicht akzeptabel ist, kann das Flag -zverwendet werden, das effektiv eine unendliche Anzahl von anhängt\0 Bytes an das Ende der Eingabe.) Der verkürzte TIO-Code erreicht nicht alle 81 Bytes, daher ist der Punkt dort umstritten.

In der Art, wie ich das implementiert habe, werden nur die niedrigen 4 Bits der Eingabe betrachtet, sodass alles, was wirklich ist, ein Sudoku-Puzzle sein kann, von rohen Binärdaten bis hin zu den weniger bekannten Werken von Shakespeare. Jedes Zeichen, dessen niedrige 4 Bits alle Null sind, wird als Leerzeichen angezeigt (ein Sonderfall), alle anderen Zeichen werden zugeordnet 123456789:;<=>?. (Die letzten Ziffern sind also keine Ziffern, aber 10 ist auch keine gültige Zahl im normalen Sudoku).

Für die Box-Zeichen wird UTF-8 erzeugt, was jeweils 3 Bytes entspricht.

Was ist mit der tatsächlichen Implementierung?

Chip ist eine 3D-Sprache, die von integrierten Schaltkreisen inspiriert ist. Es hat Drähte, Logikgatter und Speicherzellen. Die meisten Aufgaben werden in 2D-Ebenen ausgeführt, aber diese Ebenen können übereinander gestapelt werden. So wird dieses Programm aufgebaut.

Die Zeilen, die mit beginnen, =sind die Ebenentrennzeichen. Dann werden die Schichten gestapelt, wobei die obere und die linke Seite ausgerichtet sind. Daso 's dienen als Stifte, die es ermöglichen, dass Signale von einer Schicht zur anderen gelangen.

Jede Ebene hier hat einen Zweck, man könnte sie sich als Funktionen vorstellen. Die erste Ebene steuert alles; es ruft nacheinander jede der anderen Schichten auf. Hier gibt es ein sich wiederholendes Muster von links nach rechts. Dieses Muster verfolgt, welche der 19 Ausgabezeilen gerade gedruckt werden.

Die zweite Schicht ist ziemlich winzig und hat eine sehr kleine Aufgabe. Es setzt das 0x80Bit für alle Ausgabezeilen mit Ausnahme der Zeilen, die Zahlen enthalten. hist das Chip-Element, das dem 0x80Bit entspricht. (Das untere Ende des Alphabets hdurcha definiert alle acht Ausgangsbits.)

In Schicht drei kommen wir wirklich in das Fleisch des Druckens. Diese Schicht ist verantwortlich für Zeile eins. Die ungolfed-Version hat acht Zeilen mit x's und )' s, die für jedes der acht Bits jedes Bytes mit 0 und 1 verknüpft sind . Wir können jedoch die Muster in den Bits nutzen, um die gleiche Aufgabe in weniger Zeilen auszuführen.

Die vierte Schicht ist der dritten sehr ähnlich. Es behandelt die horizontalen Doppellinien.

Die fünfte Ebene behandelt die letzte Zeile. Beachten Sie, dass der Draht an der Oberseite der anderen Schichten fehlt. Dies liegt daran, dass wir die Steuerung nicht an den Sequenzer zurückgeben müssen. Stattdessen können wir hier mit nur die Ausführung beenden t.

Die sechste Ebene behandelt die horizontalen Einzellinien.

In Schicht sieben werden die Zahlen gedruckt. Es wird für jede der neun numerischen Zeilen "aufgerufen". Es verbraucht 9 Bytes an Eingaben als Teil seiner Ausführung.

JavaScript (ES6), 222 Byte

Verwenden der Kurzsyntax für ES6-Funktionen - 174 Zeichen in utf8, 222 Byte ( https://mothereff.in/byte-counter ). Für die Verwendung function ...sind 16 weitere Bytes erforderlich.

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)

Weniger golfen

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>

Java (OpenJDK 8) , 279 Byte

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;}

Probieren Sie es online!

Verwenden Sie für die Byteanzahl CP-437, das von Java als IBM437(aktuelle APIs) oder nativ unterstützt wirdCp437 (ältere APIs) unterstützt wird. Verwenden Sie daher ein System mit diesem Zeichensatz, das diesen Zeichensatz als Standardzeichensatz verwendet.

Dieser Code ist ab Java 5 kompatibel, wurde jedoch nur auf Java 8 getestet.

Erläuterung

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.
}

Tcl , 599 Bytes (295 Zeichen)

Sehr naive Herangehensweise, aber ich musste es einfach tun, auch wenn es in keiner Weise ein Gewinner war:

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 ║}}

Probieren Sie es online!