To jest kod golfowy. W przypadku tego wyzwania zaakceptuję metodę (nie potrzebujesz pełnego programu), ale podpis metody wlicza się do liczby bajtów i chcę zobaczyć pełny podpis (nie lamdba). Dane wejściowe dla metody to tablica liczb całkowitych z 81 elementami. Wartością wyjściową / zwracaną z metody jest ciąg znaków reprezentujący tablicę jako tablicę ascii sudoku.

Jeśli używasz ezoterycznego języka lub czegoś, co absolutnie nie ma metod, możesz się dostosować, ale jeśli język w ogóle to obsługuje, chcę zobaczyć, że coś może być faktycznie podłączone do „prawdziwego” programu bez golfa, nawet jeśli metoda sama w sobie jest uciążliwa. Wymaganie nie ma na celu blokowania języków takich jak Jelly lub 05AB1E, ale ułatwienie językom takim jak Java tworzenia czegoś, co ma sens dla tej platformy.

Dla danych wejściowych wartości całkowite 1-9 powinny mieć oczywiste znaczenie. Wartość 0 należy zawsze interpretować jako pustą komórkę. Możesz również interpretować wszystko inne poza zakresem 1-9 jako pustą komórkę, ale nie jest to wymagane. Pozycjonowanie od tablicy do układanki rozpoczyna się w lewym górnym rogu i wypełnia każdy rząd od lewej do prawej przed przejściem do następnego rzędu.

W przypadku pudeł chcę podwójne linie na zewnątrz i między każdym regionem 3x3 oraz pojedyncze linie między innymi komórkami. Powinny być narysowane przy pomocy znaków do rysowania linii (jeśli twój format I / O reprezentuje ciągi jako sekwencję bajtów zamiast sekwencji znaków, powinieneś je przedstawić w znanym kodowaniu, takim jak UTF-8 lub strona kodowa 347).

W przypadku tego wyzwania NIE proszę o wygenerowanie układanki sudoku. To jest dane wejściowe dla funkcji. Ja NIE prośbą, aby rozwiązać zagadkę. Po prostu proszę cię o napisanie ciągu, aby „narysować” to, co otrzymałeś (w jak najmniejszej liczbie bajtów).

Przykładowe dane wejściowe:

Wartości dla tablicy:

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

Wartości mogą wykorzystywać dowolny mechanizm naturalny dla Twojego języka: int [], ArrayList, sekwencję, krotkę, ciąg cyfr, cokolwiek, o ile masz wartość wejściową dla każdej komórki (brak map tylko dla zapełnionych komórek do pozycji ). Pamiętaj, że dane wejściowe są dostarczane ... nie są one częścią twojej liczby bajtów. Ale dane wejściowe mogą reprezentować dowolną łamigłówkę sudoku, a układanka może nawet nie mieć prawidłowego rozwiązania . Zakładasz, że puzzle można wydrukować. Na przykład nie dostaniesz czegoś z 82 elementami.

Możesz także założyć rozsądną czcionkę o stałej szerokości.

Odpowiadające wyniki:

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

Python 3 , 232 bajty

Dzięki tym, którzy pomogli w golfa.

Szyfrowanie w ramach szyfrowania ...

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

Wypróbuj online!

Do gry w golfa.

C (gcc) , 398 395 291 bajtów

Zaoszczędzono 3 bajty, pracując w odwróconym łańcuchu, a 104 (!) Bajtów dzięki 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);}

Wypróbuj online!

C (gcc) , 395 bajtów

Zatrzymam to tutaj, aby było bardziej oczywiste, jak działa program.

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

Wypróbuj online!

Praca z Unicode w C jest ... kosztowna. Pobiera dane wejściowe jak int*pokazano w łączu i specyfikacji.

Zobaczę, czy mogę zapisać bajty za pomocą magii liczb zamiast zakodować ciąg znaków.

PHP , 297 bajtów

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

Wypróbuj online!

Rozszerzony

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

używane funkcje dla obu wersji

vsprintf , strtr , str_pad , array_slice , array_chunk

PHP , 313 bajtów

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

Wypróbuj online!

T-SQL, 445 437 bajtów (381 znaków)

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

Wprowadzanie odbywa się za pomocą ciągu cyfr przechowywanych w kolumnie a wcześniej istniejącej tabeli t , zgodnie z zatwierdzonymi metodami .

Format i objaśnienie :

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

W górnym wierszu pętli otrzymuję kolejne 9 cyfr ciągu wejściowego z kolumny a istniejącej tabeli t .

Przekształcam ten ciąg cyfr na liczbę całkowitą i używam FORMATfunkcji .Net, aby wyświetlić je przy użyciu niestandardowego szablonu tekstowego '║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P'.

Następnie po prostu dołączam odpowiednią linię podziału i robię zamienniki oszczędzające bajty przed wyjściem.

Dane wyjściowe są wyświetlane w panelu wyników:

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

Wcześniej miałem dodatkowe zamienniki niektórych innych postaci rysunkowych, ale ostatecznie nie uratowały mnie bajty.

EDYCJA 1 : Zapisano 8 bajtów, zaczynając @rod zera zamiast 1 i usuwając niepotrzebne spacje.

Retina , 196 167 bajtów

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

Wypróbuj online! Pobiera dane wejściowe jako ciąg długości 81. Objaśnienie: Ponieważ znaki rysujące w ramce kosztują trzy bajty, punkty kodu Unicode ═-╬są reprezentowane w kodzie za pomocą =|#A-Z(nie wszystkie znaki są używane, ale przyleganie do zakresów oszczędza bajty). Dodatkowo wiersze są kompresowane za pomocą #znaków: a#bcd#erozwija się do abbbcbbbcbbbdbbbcbbbcbbbdbbbcbbbcbbbe.

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

Wkładki ╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣dla co trzeciego rzędu plus plus ║na początku każdej grupy 27.

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

Wstawia ╟───┼───┼───╫───┼───┼───╫───┼───┼───╢między innymi rzędami plus ║s na początku tych rzędów.

\d{3}
 $& |

Wstawia ║s po każdych trzech cyfrach. Wszystkie ║s zostały już wstawione.

\B\d
 │ $&

Wstawia |s między wszystkimi pozostałymi parami cyfr. (Ten jest faktyczną postacią rysującą pole, a nie potokiem. Niestety znaki ─│┼mają zbyt odległe od siebie kody i znaki podwójnego pola, aby było warto podczas używania symboli zastępczych).

^¶.*
B#=RT#E

Zmienia pierwszy wiersz na ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗(pozwala to zaoszczędzić 1 bajt bez dodawania pierwszego wiersza w pierwszej kolejności).

$
¶H#=UW#K

Dodaje ╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝po ostatnim wierszu.

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

Rozwija się a#bcd#enajpierw do a#bc#d#bc#d#bc#e, a następnie do a#b#c#b#c#b#d#b#c#b#c#b#d#b#c#b#c#b#e.

#(.)#
$1$1$1

Zmiany #b#na bbb. To kończy dekompresję.

T`0=|#L` ═-╬

Usuwa wszystkie wpisy zerowe i zastępuje symbole zastępcze znakami rysującymi ramki.

SOGL V0.12 , 174 172 164 160 158 bajtów

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

Zbyt długie wyjaśnienie:

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

Uruchomiony program:

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

gdzie są wszystkie oprócz ostatniej linii in the entire program replace occurrences of the last char of this line with the rest of this line. To jest powód, dla którego połowa znaków była po prostu losowa ascii (ale uzyskanie użytecznych spacji, myślników i cudzysłowów zajęło trochę czasu).

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

Wypróbuj tutaj!
Kod tłumacza online jest bardziej poprawny, ponieważ tabulatory nie działają z SE

-8 bajtów: zastąpienie brutalnej siły kompresowaniem całej tablicy, a następnie zastąpienie obcych znaków (do strony kodowej) ich punktami kodowymi. Wykonanie tego zajęło godzinę krócej niż stary program ...
-4 bajty: kompresowanie skompresowanego ciągu ...
-2 bajty: użycie zmiennej + łańcucha zamiast tablicy

JavaScript (ES6), 246 bajtów / 198 znaków

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

Dane wejściowe to tablica liczb całkowitych. Skończyło się na użyciu tych samych dwóch funkcji pomocnika, co odpowiedź Pythona Dziurawej Zakonnicy , więc idź tam.

W razie functionpotrzeby 263 bajtów / 215 znaków

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

Test Snippet

Obsługiwane jest wprowadzanie 81 liczb ( 1234, 1, 2, 3, 4. [1 2 3 4]Itd.). Najlepiej oglądać jako pełną stronę.

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>

Partia, 332 bajty

@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

Potrzebuje konsoli w wersji CP437. Jeśli nie jest to domyślne, możesz to zmienić za pomocą CHCP 437polecenia, jeśli w konsoli ustawiono czcionki TrueType. (Będzie działać tylko z czcionkami rastrowymi, jeśli CP437 jest już domyślną stroną kodową.) Tak wygląda kod w 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

Z pomysłami zebranymi na podstawie innych odpowiedzi:

C # (.NET Core) , 401 bajtów, 349 znaków

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

Nie golfowany:

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

Wypróbuj online!

Moja odpowiedź:

C # (.NET Core) , 509 430 418 bajtów, 328 znaków

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

Nie golfowany:

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

Wypróbuj online!

Chip , 3645 bajtów

^{... to nie literówka ...}

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

Wypróbuj online! , w pewnym sensie. Wersja TIO zawiera odcięcie około jednej trzeciej wejścia ( tpo 4. oooooo), więc powinno zakończyć się w mniej niż 60 sekund. Pełna wersja zajmuje około 1m25s na moim komputerze, a TIO wydaje się o połowę szybsze. Oznacza to również, że TIO pokazuje tylko pierwsze 7 linii wyjścia.

Mój pierwszy projekt ważył 19758 bajtów i zabrał mnie około 8m30. Ostatecznym rozwiązaniem, przed golfem, było szybkie 5980 bajtów, zajmujące tylko 2m07s.

Więc jak to działa?

Zajmuje to ciąg 82 bajtów, 81 cyfr, po których następuje terminator. \0lub \nnawet zrobi to inny numer. (Ta implementacja faktycznie sprawdza tylko pierwsze 81, ale wymaga co najmniej jeszcze jednego, ponieważ Chip skończy się, jeśli wyczerpałby swoje dane wejściowe. Jeśli jest to niedopuszczalne, -zmożna użyć flagi , która skutecznie dodaje nieskończoną liczbę \0bajtów do koniec danych wejściowych.) Skrócony kod TIO tak naprawdę nie dociera do wszystkich 81 bajtów, więc jest tam kwestia sporna.

Sposób, w jaki to zaimplementowałem, polega tylko na niskich 4 bitach danych wejściowych, więc wszystko może być „łamigłówką” sudoku, od surowych danych binarnych po mniej znane dzieła Szekspira. Każdy znak, którego wszystkie 4 małe bity są zerowe, pojawi się jako spacja (specjalny przypadek), do którego odwzorowane są wszystkie pozostałe znaki 123456789:;<=>?. (Tak więc kilka ostatnich nie jest cyframi, ale 10 nie jest poprawną liczbą w normalnym sudoku).

W przypadku znaków rysujących ramkę tworzy UTF-8, co odpowiada 3 bajtom każdy.

Co z faktyczną implementacją?

Chip to język 3D inspirowany układami scalonymi. Ma przewody, bramki logiczne i komórki pamięci. Większość rzeczy odbywa się na płaszczyznach 2D, ale płaszczyzny te mogą być układane jeden na drugim. Tak zbudowano ten program.

Linie, które zaczynają się, =to separatory warstw. Następnie warstwy są układane w stosy, wyrównując górną i lewą stronę. W o'S służyć jako kołki, dzięki czemu sygnały przechodzą z jednej warstwy do drugiej.

Każda warstwa tutaj ma swój cel, możesz myśleć o nich jak o funkcjach. Pierwsza warstwa kontroluje wszystko; „wywołuje” kolejno każdą z pozostałych warstw. Istnieje tutaj powtarzający się schemat od lewej do prawej. Ten wzór śledzi, który z 19 wierszy wydruku aktualnie drukujemy.

Druga warstwa jest raczej niewielka i ma bardzo drobną robotę. Ustawia 0x80bit dla wszystkich linii wyjściowych, z wyjątkiem linii zawierających liczby. hto element Chip, który odpowiada 0x80bitowi. (Dolny koniec alfabetu hpoprzez aokreślenie wszystkich ośmiu bitów wyjściowych.)

Warstwa trzecia to miejsce, w którym naprawdę docieramy do druku. Ta warstwa odpowiada za linię pierwszą. Wersja bez golfa ma osiem rzędów x„i )”, odwzorowujących na 0 i 1 dla każdego z ośmiu bitów każdego bajtu. Możemy jednak wykorzystać wzorce w bitach, aby wykonać to samo zadanie w mniejszej liczbie rzędów.

Warstwa czwarta jest bardzo podobna do trzeciej. Obsługuje poziome podwójne linie.

Warstwa piąta obsługuje ostatnią linię. Zauważ, że brakuje drutu wzdłuż góry, który mają inne warstwy. Jest tak, ponieważ nie musimy zwracać kontroli nad sekwencerem. Zamiast tego możemy po prostu zakończyć wykonywanie tutaj t.

Warstwa szósta obsługuje poziome pojedyncze linie.

W warstwie siódmej drukowane są liczby. Jest „wywoływany” dla każdej dziewięciu linii numerycznych. Zużywa 9 bajtów danych wejściowych w ramach wykonywania.

JavaScript (ES6), 222 bajty

Używając krótkiej składni dla funkcji ES6 - 174 znaków zakodowanych w utf8, 222 bajty ( https://mothereff.in/byte-counter ). Korzystanie function ...wymaga 16 dodatkowych bajtów.

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)

Mniej golfa

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 bajtów

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

Wypróbuj online!

Do liczenia bajtów użyj CP-437, który jest natywnie obsługiwany przez Javę jako IBM437(najnowsze API) lub Cp437(starsze API); więc użyj systemu, który ma ten zestaw znaków, który ma ten zestaw znaków jako domyślny zestaw znaków.

Ten kod jest zgodny z Javą 5 i nowszymi, ale został przetestowany tylko na Javie 8.

Wyjaśnienie

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 bajtów (295 znaków)

Bardzo naiwne podejście, ale musiałem to zrobić, nawet nie będąc zwycięzcą pod żadnym względem:

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

Wypróbuj online!