이것은 코드 골프입니다. 이 도전을 위해 메소드를 수락하지만 (전체 프로그램이 필요하지는 않습니다) 메소드 서명은 바이트 수로 계산되며 전체 서명 (lamdba 아님)을보고 싶습니다. 메소드의 입력은 81 개의 요소가있는 정수 배열입니다. 메소드의 출력 / 반환 값은 배열을 ASCII 스도쿠 보드로 나타내는 문자열입니다.

난해한 언어 나 방법이없는 것을 사용하는 경우, 적응할 수 있지만, 언어가 전혀 지원하지 않으면 실제로 "goal"ungolfed 프로그램에 연결되어 있는지 확인하고 싶습니다. 메소드 본문 자체는 작업하기가 쉽지 않습니다. 요구 사항은 Jelly 또는 05AB1E와 같은 언어를 차단하기위한 것이 아니라 Java와 같은 언어가 해당 플랫폼에 적합한 것을 쉽게 빌드 할 수 있도록하기위한 것입니다.

입력의 경우 정수 값 1-9는 명백한 의미를 가져야합니다. 0은 항상 빈 셀로 해석해야합니다. 1-9 범위 밖의 다른 것을 빈 셀로 해석 할 수도 있지만 필수는 아닙니다. 배열에서 퍼즐까지의 위치는 왼쪽 상단에서 시작하여 다음 행으로 이동하기 전에 왼쪽에서 오른쪽으로 각 행을 채 웁니다.

상자의 경우 외부와 각 3x3 영역 사이에 이중선을, 다른 셀 사이에 단일 선을 원합니다. 선 그리기 문자로 그려야합니다 (I / O 형식이 문자열을 문자 시퀀스가 ​​아닌 바이트 시퀀스로 나타내는 경우 UTF-8 또는 코드 페이지 347과 같은 잘 알려진 인코딩으로 표시해야 함).

이 도전 을 위해 스도쿠 퍼즐을 생성하도록 요구 하지 않습니다 . 이것이 함수의 입력입니다. 난 당신이 퍼즐을 해결하도록 요구 하지 않습니다 . 나는 당신이 주어진 것을 (가능한 한 적은 바이트로) "그리기"위해 문자열을 생성하도록 요구하고 있습니다.

입력 예 :

배열 값 :

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

모든 셀에 대한 입력 값이있는 한 값은 언어에 자연스러운 메커니즘을 사용할 수 있습니다 : int [], ArrayList, 시퀀스, 튜플, 문자열 등 ). 입력이 제공된다는 것을 기억하십시오. 그것은 바이트 수의 일부가 아닙니다. 그러나 입력은 스도쿠 퍼즐을 나타낼 수 있으며 퍼즐 에는 유효한 솔루션이 없을 수도 있습니다 . 당신은 퍼즐 이 있다고 가정 인쇄 . 예를 들어 82 개의 요소가있는 것은 없습니다.

또한 합리적인 고정 너비 글꼴을 사용해야합니다.

해당 출력 :

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

파이썬 3 , 232 바이트

이 골프를 도와 주신 분들께 감사드립니다.

암호화 내 암호화 ...

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

온라인으로 사용해보십시오!

골프하기.

C (GCC) , 398 (395) 291 바이트

Leaky Nun 덕분에 문자열을 반대로하여 3 바이트를 절약하고 104 (!) 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

C (gcc) , 395 바이트

나는 이것을 프로그램의 작동 방식에 대해 더 분명하게 유지하도록하겠습니다.

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

온라인으로 사용해보십시오!

C에서 유니 코드로 작업하는 것은 비용이 많이 듭니다. int*링크 및 사양에 표시된 대로 입력을 받습니다.

문자열을 하드 코딩하는 대신 숫자 마법을 사용하여 바이트를 저장할 수 있는지 확인하겠습니다.

PHP , 297 바이트

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

온라인으로 사용해보십시오!

넓히는

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

두 버전 모두에 사용 된 기능

vsprintf , strtr , str_pad , array_slice , array_chunk

PHP , 313 바이트

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

온라인으로 사용해보십시오!

T-SQL, 445 437 바이트 (381 자)

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

입력 열 저장 자릿수의 문자열 경유 기존 테이블의 t , 승인 된 방법에 따라 .

형식과 설명 :

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

루프의 맨 위 줄에서 기존 테이블 t 의 열 a 에서 입력 문자열의 다음 9 자리를 얻습니다 .

해당 자릿수를 정수로 변환하고 .Net FORMAT함수를 사용하여 사용자 정의 텍스트 템플릿을 사용하여 표시합니다 '║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P'.

그런 다음 적절한 구분선을 추가하고 출력 전에 바이트 절약 교체를 수행하십시오.

결과가 결과 창에 표시됩니다.

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

이전에 다른 드로잉 문자 중 일부를 대체하는 추가 기능이 있었지만 결국에는 바이트를 절약하지 못했습니다.

EDIT 1 : 1@r 대신 0에서 시작 하여 불필요한 공백을 제거하여 8 바이트를 절약했습니다 .

망막 , 196167 바이트

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

온라인으로 사용해보십시오! 입력을 길이 81의 문자열로 사용합니다. 설명 : 상자 그리기 문자의 비용은 3 바이트이므로 유니 코드 코드 포인트 ═-╬는 코드를 사용하여 코드에 표시됩니다 =|#A-Z(모든 문자가 사용되는 것이 아니라 범위를 고수하면 바이트가 절약 됨). 또한 행은 #부호를 사용하여 압축 a#bcd#e됩니다 abbbcbbbcbbbdbbbcbbbcbbbdbbbcbbbcbbbe.

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

╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣세 번째 행마다 삽입 하고 ║27 개 그룹마다 시작 부분에 a 를 더합니다.

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

╟───┼───┼───╫───┼───┼───╫───┼───┼───╢다른 행 사이에 삽입 하고 ║해당 행의 시작 부분에 s를 더합니다.

\d{3}
 $& |

║세 자리마다 s를 삽입합니다 . 모든 ║s가 삽입되었습니다.

\B\d
 │ $&

|나머지 모든 숫자 쌍 사이에 s를 삽입합니다 . (이것은 파이프가 아닌 실제 상자 그리기 문자입니다. 불행히도 문자 ─│┼는 자리 표시자를 사용할 때 가치가 있도록 코드가 서로 너무 멀리 떨어져 있고 이중 상자 문자가 있습니다.)

^¶.*
B#=RT#E

첫 번째 행을로 변경합니다 (처음에 첫 번째 행을 ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗추가하지 않고 1 바이트를 절약 함).

$
¶H#=UW#K

╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝마지막 행 뒤에 추가합니다 .

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

을 a#bcd#e먼저 확장 a#bc#d#bc#d#bc#e한 다음로 확장 합니다 a#b#c#b#c#b#d#b#c#b#c#b#d#b#c#b#c#b#e.

#(.)#
$1$1$1

로 변경 #b#되었습니다 bbb. 이것으로 감압이 완료됩니다.

T`0=|#L` ═-╬

모든 0 항목을 삭제하고 자리 표시자를 상자 그리기 문자로 바꿉니다.

SOGL V0.12 , 174 172 164 160 158 바이트

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

지나치게 긴 설명 :

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

실행 된 프로그램 :

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

마지막 행을 제외한 모든 행은 그냥 in the entire program replace occurrences of the last char of this line with the rest of this line있습니다. 이것이 문자의 절반을 임의의 ASCII로 만드는 것이 가능한 이유입니다 (그러나 공백, 대시 및 따옴표가 유용하게 사용되도록 파악하는 데 시간이 걸렸습니다)

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

여기 사용해보십시오!
탭이 SE에서 작동하지 않기 때문에 온라인 인터프리터 코드가 더 정확합니다.

-8 바이트 : 보드 전체를 압축 한 무차별 대입 교체 후 외부 문자 (코드 페이지로)를 코드 포인트로 대체합니다. 이 작업을 수행하면 이전 프로그램보다 1 시간이 덜 걸렸습니다 ...
-4 바이트 : 압축 문자열 압축 ...
-2 바이트 : 배열 대신 variable + string 사용

자바 스크립트 (ES6), 246 바이트 / 198 자

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

입력은 정수 배열입니다. 같은 두 가지 도우미 기능을 사용하여 종료되었습니다.Leaky Nun의 Python answer 크레딧이 생겼습니다.

만약 function 필요, 263 바이트 / 215 문자

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

테스트 스 니펫

81 개의 숫자를 입력 할 수 있습니다 ( 1234, 1, 2, 3, 4. [1 2 3 4]등). 전체 페이지로 가장 잘 보입니다.

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>

배치, 332 바이트

@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

CP437에 콘솔이 필요합니다. 이것이 기본값이 아닌 CHCP 437경우 콘솔이 트루 타입 글꼴로 설정된 경우 명령을 사용하여 변경할 수 있습니다 . CP437이 이미 기본 코드 페이지 인 경우 래스터 글꼴로만 작동합니다. 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

다른 답변에서 얻은 아이디어로 :

C # (. NET 코어) , 401 바이트, 349 자

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

언 골프 드 :

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

온라인으로 사용해보십시오!

내 답변 :

C # (. NET 코어) , 509430418 바이트, 328 자

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

언 골프 드 :

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

온라인으로 사용해보십시오!

칩 , 3645 바이트

^{... 오타가 아닙니다 ...}

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

온라인으로 사용해보십시오! , 일종의. TIO 버전에는 3 분의 1 정도의 컷오프가 포함되어 있습니다.t 4 번째 이후 oooooo) 있으므로 60 초 이내에 종료해야합니다. 풀 버전은 내 컴퓨터에서 약 1m25를 차지하며 TIO는 약 절반 정도 빠릅니다. 이것은 또한 TIO가 처음 7 줄의 출력 만 표시한다는 것을 의미합니다.

첫 초안의 무게는 19758 바이트에 달했고 약 8m30 초가 걸렸습니다. 프리 골프 (pre-golfing)의 최종 솔루션은 5mbyte의 spry로 2m07 만 사용했습니다.

그렇다면 어떻게 작동합니까?

여기에는 82 바이트, 81 자리의 문자열, 종결자가 필요합니다. \0또는 \n다른 번호로도 가능합니다. (이 구현은 실제로 처음 81 개만 보지만 입력이 소진되면 칩이 종료되기 때문에 적어도 하나 이상이 필요합니다. 수용 할 수없는 경우 플래그 -z가 사용될 수 있습니다.\0 . 단축 된 TIO 코드는 실제로 모든 81 바이트에 도달하지 않으므로 문제가 발생합니다.

내가 구현 한 방식은 입력의 낮은 4 비트 만 보므로 실제로 바이너리 바이너리 데이터에서 덜 알려진 셰익스피어 작품에 이르기까지 스도쿠 '퍼즐'이 될 수 있습니다. 하위 4 비트가 모두 0 인 문자는 공백 (특별한 경우)으로 표시되며 다른 모든 문자는로 매핑됩니다 123456789:;<=>?. (마지막 스도쿠에서 마지막 몇 자리는 숫자가 아니지만 10은 유효한 숫자입니다).

상자 그리기 문자의 경우 UTF-8을 생성하여 각각 3 바이트와 동일합니다.

실제 구현은 어떻습니까?

칩은 집적 회로에서 영감을 얻은 3D 언어입니다. 와이어, 로직 게이트 및 메모리 셀이 있습니다. 대부분의 작업은 2D 평면에서 수행되지만 이러한 평면은 서로 쌓일 수 있습니다. 이것이이 프로그램이 만들어지는 방식입니다.

로 시작하는 선 =은 레이어 구분 기호입니다. 그런 다음 상단과 왼쪽이 정렬되어 레이어가 쌓입니다. 그만큼o 핀 역할을하여 신호가 한 레이어에서 다른 레이어로 전달 될 수 있도록합니다.

여기의 각 레이어에는 목적이 있습니다. 함수로 생각할 수 있습니다. 첫 번째 레이어는 모든 것을 제어합니다. 다른 레이어를 차례로 '호출'합니다. 여기에는 왼쪽에서 오른쪽으로 반복되는 패턴이 있습니다. 이 패턴은 현재 인쇄중인 19 줄의 출력을 추적합니다.

두 번째 레이어는 다소 작으며 매우 작은 작업입니다. 0x80숫자가 포함 된 줄을 제외한 모든 출력 줄의 비트를 설정합니다 . 비트에 h해당하는 칩 요소입니다 0x80. (알파벳 저가형 h까지는 a여덟 개 출력 비트를 정의한다.)

레이어 3은 인쇄의 고기에 들어가는 곳입니다. 이 레이어는 라인 1을 담당합니다. ungolfed 버전에는 8 개의 행 x과) 의 매핑과 0의 각 바이트의 8 비트의 각각의 하나를. 그러나 비트 수의 패턴을 활용하여 더 적은 행으로 동일한 작업을 수행 할 수 있습니다.

레이어 4는 세 번째와 매우 비슷합니다. 가로 이중선을 처리합니다.

레이어 5는 마지막 줄을 처리합니다. 다른 레이어의 상단을 따라 와이어가 누락되었습니다. 시퀀서로 제어를 되돌릴 필요가 없기 때문입니다. 대신 여기서로 실행을 종료 할 수 있습니다 t.

레이어 6은 가로 단일 라인을 처리합니다.

7 층은 숫자가 인쇄되는 곳입니다. 9 개의 숫자 라인마다 '호출'됩니다. 실행의 일부로 9 바이트의 입력을 사용합니다.

자바 스크립트 (ES6), 222 바이트

ES6 함수에 짧은 구문 사용-utf8, 222 바이트로 인코딩 된 174 자 ( https://mothereff.in/byte-counter ). 사용 function ...에는 16 바이트가 더 필요합니다.

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)

덜 골프

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>

자바 (OpenJDK 8) , 279 바이트

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

온라인으로 사용해보십시오!

바이트 수의 경우 CP-437을 사용하십시오. CP-437 은 Java에서 기본적 으로 IBM437(최근 API) 또는Cp437 (이전 API) . 이 문자 집합이있는 시스템을 사용하면이 문자 집합이 기본 문자 집합으로 설정됩니다.

이 코드는 Java 5부터 호환되지만 Java 8에서만 테스트되었습니다.

설명

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 바이트 (295 자)

매우 순진한 접근 방식이지만, 어떤 방법으로도 승자가되지 않은 경우에도 수행해야했습니다.

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

온라인으로 사용해보십시오!