Disegna una tavola di sudoku usando i caratteri di disegno al tratto


20

Questo è il codice golf. Per questa sfida, accetterò un metodo (non è necessario un programma completo), ma la firma del metodo conta per il conteggio dei byte e voglio vedere la firma completa (non un lamdba). L'input per il metodo è un array intero con 81 elementi. Il valore output / return del metodo è una stringa che rappresenta l'array come una scheda sudi ascii.

Se stai usando un linguaggio esoterico o qualcosa che assolutamente non ha metodi, puoi adattarti, ma se il linguaggio lo supporta affatto, voglio vedere che qualcosa potrebbe effettivamente essere inserito in un "vero" programma non golfato, anche se il il metodo stesso è un dolore con cui lavorare. Il requisito non ha lo scopo di bloccare linguaggi come Jelly o 05AB1E, ma di rendere più semplice per linguaggi come Java creare qualcosa che abbia senso per quella piattaforma.

Per l'input, i valori interi 1-9 dovrebbero avere significati ovvi. Uno 0 deve sempre essere interpretato come una cella vuota. Puoi anche interpretare qualsiasi altra cosa al di fuori dell'intervallo 1-9 come una cella vuota, ma ciò non è necessario. Il posizionamento dalla matrice al puzzle inizia in alto a sinistra e riempie ogni riga da sinistra a destra prima di passare alla riga successiva.

Per le scatole, voglio linee doppie attorno all'esterno e tra ciascuna regione 3x3 e linee singole tra altre celle. Questi dovrebbero essere disegnati con caratteri di disegno al tratto (se il tuo formato I / O rappresenta le stringhe come una sequenza di byte anziché una sequenza di caratteri, dovresti rappresentarli in una codifica ben nota come UTF-8 o codepage 347).

Per questa sfida, NON ti sto chiedendo di generare il puzzle di sudoku. Questo è l'input per la funzione. NON ti sto chiedendo di risolvere il puzzle. Ti sto solo chiedendo di produrre una stringa per "disegnare" ciò che ti viene dato (nel minor numero di byte possibile).

Esempio di input:

Valori per l'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}

I valori possono usare qualsiasi meccanismo naturale per la tua lingua: int [], ArrayList, sequenza, tupla, stringa di cifre, qualunque cosa, purché tu abbia un valore nell'input per ogni cella (nessuna mappa per le sole celle popolate nelle posizioni ). Ricorda che l'ingresso è fornito ... non fa parte del conteggio dei byte. Ma l'input potrebbe rappresentare qualsiasi puzzle di sudoku e il puzzle potrebbe anche non avere una soluzione valida . Supponi che il puzzle sia stampabile. Non otterrai qualcosa con 82 elementi, per esempio.

Puoi anche assumere un carattere a larghezza fissa ragionevole.

Uscita corrispondente:

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

4
Sei sicuro della parte del metodo? Questo non ha senso per molte lingue (cioè lingue senza metodi).
Cyoce,

1
Per le lingue che non hanno metodi, puoi adattarti. Ma se lo fanno, sto cercando qualcosa che potrebbe effettivamente essere utile da inserire in un programma "reale". Lo aggiungerò alla domanda.
Joel Coehoorn,

2
Qual è il ragionamento per non consentire le lambda? Quelli potrebbero certamente essere inseriti in un programma "reale", nonché funzioni / metodi con nome
Julian Wolf,

2
Nitpicky ma importante: non esiste un "personaggio di disegno a scatola ASCII". ASCII copre i codici da 0 a 127, nessuno dei quali sono caratteri di disegno a scatola. In tempi recenti, Unicode è lo standard, ma ha diverse codifiche: UTF-8, UTF-16 ecc., Che utilizzano tutti più di 1 byte per carattere di box-boxing. Le codifiche precedenti come Codepage 437 supportano i caratteri di disegno della casella a byte singolo. Quando si utilizzano caratteri al di fuori dell'intervallo ASCII, è necessario specificare quali codifiche sono valide. en.wikipedia.org/wiki/Box-drawing_character en.wikipedia.org/wiki/Unicode
Level River St

2
"Metodo" dovrebbe probabilmente essere "funzione denominata" per ottenere l'equivalente più vicino possibile a un metodo in linguaggi non orientati agli oggetti. (Ad esempio, C, un linguaggio ampiamente utilizzato, non ha metodi ma ha funzioni con nome.) Nella maggior parte delle lingue di cui sono a conoscenza con metodi, sono l'equivalente di quella lingua con una funzione con nome. (L'eccezione più nota di cui sono a conoscenza è C ++, in cui l'utilizzo di una funzione con nome sarebbe molto più plausibile per questa attività rispetto all'utilizzo di un metodo, in quanto non è chiaro con quale tipo di oggetto associ il metodo .)

Risposte:


9

Python 3 , 232 byte

Grazie a coloro che hanno contribuito a giocare a golf.

Crittografia all'interno della crittografia ...

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

Provalo online!

Essere golfato.


Come non ho notato che ... è come l'intero motivo per cui ho usato Python 2, ma grazie.
Leaky Nun,

1
In realtà stai meglio usando Python 3 da allora non avrai bisogno della prima riga.
Erik the Outgolfer,

1
Puoi rimuovere più parentesi sull'ultima riga: tio
Conor O'Brien il

Rimuovi la definizione di f e definisci i come i=["╔"+(g+"╦")*2+g+"╗"]+d+2*(["╠"+(e+"╬")*2+e+"╣"]+d)+["╚"+(h+"╩")*2+h+"╝"]salva 4 byte
officialaimm il

7

C (gcc) , 398 395 291 byte

Hai salvato 3 byte lavorando attraverso la stringa invertita e 104 (!) Byte grazie a 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);}

Provalo online!

C (gcc) , 395 byte

Terrò questo qui così è più evidente su come funziona il programma.

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

Provalo online!

Lavorare con Unicode in C è ... costoso. Accetta input comeint* mostrato nel collegamento e nelle specifiche.

Vedrò se riesco a salvare byte usando un po 'di magia numerica invece di codificare la stringa.



@LeakyNun Huh, grazie! Sono 291 byte secondo TIO
Conor O'Brien il

TIO sta contando usando SBCS .
Leaky Nun,

6

PHP , 297 byte

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

Provalo online!

allargato

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

funzioni utilizzate per entrambe le versioni

vsprintf , strtr , str_pad , array_slice , array_chunk

PHP , 313 byte

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

Provalo online!


Come funziona?
Cyoce,

@Cyoce Ho aggiunto una spiegazione per la mia nuova versione
Jörg Hülsermann,

5

T-SQL, 445 437 byte (in 381 caratteri)

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

L'immissione avviene tramite una stringa di cifre memorizzate nella colonna a della tabella t preesistente , secondo i metodi approvati .

Formato e spiegazione :

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

Nella riga superiore del ciclo sto ricevendo le successive 9 cifre della stringa di input dalla colonna a della tabella t preesistente .

Converto quella stringa di cifre in un numero intero e utilizzo la FORMATfunzione .Net per visualizzarle utilizzando un modello di testo personalizzato '║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║ 0 │ 0 │ 0 ║P'.

Dopodiché aggiungo solo la riga divisoria appropriata ed eseguo alcune sostituzioni salvaspazio prima dell'output.

L'output viene visualizzato nel riquadro dei risultati:

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

In precedenza avevo alcune sostituzioni aggiuntive per alcuni degli altri personaggi di disegno, ma alla fine non mi hanno salvato byte.

EDIT 1 : salvato 8 byte iniziando @rda zero invece di 1 e rimuovendo alcuni spazi non necessari.


4

Retina , 196 167 byte

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

Provalo online! Accetta input come una stringa di lunghezza 81. Spiegazione: Poiché i caratteri di disegno della casella costano tre byte, i punti del codice unicode ═-╬sono rappresentati nel codice utilizzando =|#A-Z(non tutti i caratteri vengono utilizzati ma attenendosi agli intervalli si risparmiano byte). Inoltre, le righe vengono compresse mediante #segni: si a#bcd#eespande in abbbcbbbcbbbdbbbcbbbcbbbdbbbcbbbcbbbe.

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

Inserisce ╠═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══╣per ogni terza riga, più una all'inizio di ogni gruppo di 27.

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

Inserisce ╟───┼───┼───╫───┼───┼───╫───┼───┼───╢tra le altre righe, più s all'inizio di quelle righe.

\d{3}
 $& |

Inserisce s dopo ogni tre cifre. Tutti i messaggi sono stati ora inseriti.

\B\d
 │ $&

Inserisce |s tra tutte le restanti coppie di cifre. (Questo è l'effettivo personaggio del disegno della scatola piuttosto che una pipe. Sfortunatamente i personaggi ─│┼hanno codici troppo distanti tra loro e i caratteri della doppia scatola per renderlo utile quando si usano segnaposto.)

^¶.*
B#=RT#E

Cambia la prima riga in ╔═══╤═══╤═══╦═══╤═══╤═══╦═══╤═══╤═══╗(ciò consente di risparmiare 1 byte anziché aggiungere la prima riga in primo luogo).

$
¶H#=UW#K

Aggiunge ╚═══╧═══╧═══╩═══╧═══╧═══╩═══╧═══╧═══╝dopo l'ultima riga.

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

Si espande a#bcd#e, prima in a#bc#d#bc#d#bc#e, poi in a#b#c#b#c#b#d#b#c#b#c#b#d#b#c#b#c#b#e.

#(.)#
$1$1$1

Modifiche #b#a bbb. Questo completa la decompressione.

T`0=|#L` ═-╬

Elimina tutte le voci zero e sostituisce i segnaposto con i caratteri del riquadro.


Hai dimenticato di sostituire 0con lo spazio.
Leaky Nun,

Ha anche doppie linee attorno a ogni riga, piuttosto che solo il bordo e le regioni 3x3.
Joel Coehoorn,

@JoelCoehoorn Risolto, scusa.
Neil,

@LeakyNun Grazie, l'ho trascurato. (Inoltre, mi piace evitare le righe che terminano con, o soprattutto contengono solo, spazi, motivo per cui ho cercato un salvataggio alternativo a 2 byte.)
Neil

3

SOGL V0.12 , 174 172 164 160 158 byte

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

Spiegazione troppo lunga:

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

Il programma che viene eseguito:

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

dove tutti tranne l'ultima riga sono giusti in the entire program replace occurrences of the last char of this line with the rest of this line. Questo è il motivo per cui è stato possibile rendere la metà dei caratteri solo ascii casuali (ma ottenere in modo che gli spazi, i trattini e le virgolette vengano utilmente usati ci è voluto un po 'per capire)

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

Provalo qui!
Il codice dell'interprete online è più corretto perché le schede non funzionano con SE

-8 byte: sostituzione della forza bruta comprimendo l'intera scheda, quindi sostituendo i caratteri estranei (alla tabella codici) con i loro punti codice. Per fare ciò è occorsa un'ora in meno rispetto al vecchio programma ...
-4 byte: compressione della stringa compressa ...
-2 byte: utilizzo di una variabile + stringa anziché di matrice


2

JavaScript (ES6), 246 byte / 198 caratteri

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

L'input è un array di numeri interi. Finì per usare le stesse due funzioni di supporto della risposta Python di Leaky Nun , quindi il merito va lì.

Se functionnecessario, 263 byte / 215 caratteri

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 dello snippet

È supportato qualsiasi input di 81 numeri ( 1234, 1, 2, 3, 4. [1 2 3 4], Ecc.). Da vedere come pagina intera.

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

Lotto, 332 byte

@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

È necessario che la console sia in CP437. Se questo non è il tuo valore predefinito, puoi cambiarlo usando il CHCP 437comando se la tua console è impostata sui caratteri TrueType. (Funzionerà solo con caratteri raster se CP437 è già la tua tabella codici predefinita.) Ecco come appare il codice in 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 idee raccolte da altre risposte:

C # (.NET Core) , 401 byte, 349 caratteri

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

Provalo online!

La mia risposta:

C # (.NET Core) , 509 430 418 byte, 328 caratteri

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

Provalo online!


Devi contare ogni carattere di disegno come due byte?
BradC,

L'ho fatto, riparato ora. Avevo intenzione di affrontarlo in questione e contare i caratteri anziché i byte, a causa di quei personaggi, ma suppongo che ora sia troppo tardi.
Joel Coehoorn,

Sì, i byte sono più difficili, alcune sostituzioni ASCII salvano i byte ma non incidono sui caratteri (o addirittura danneggiano i caratteri). Sto lavorando su T-SQL e char vs nchar è una differenza abbastanza grande.
BradC,

1

Chip , 3645 byte

... non è un errore di battitura ...

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

Provalo online! , una specie di. La versione TIO contiene un cut-off di circa un terzo ( tdopo il 4 °oooooo ), in modo che dovrebbe terminare in meno di 60 secondi. La versione completa richiede circa 1m25s sulla mia macchina e TIO sembra circa la metà più veloce. Questo significa anche che il TIO mostra solo le prime 7 righe di output.

La mia prima bozza ha pesato su un enorme 19758 byte e mi ci sono voluti circa 8m30 per l'esecuzione. La soluzione finale, pre-golf, è stata una spry 5980 byte, prendendo solo 2m07s.

Allora, come funziona, allora?

Questo richiede una stringa di 82 byte, 81 cifre, seguita da un terminatore. \0o \no anche un altro numero farà. (Questa implementazione in realtà guarda solo al primo 81, ma ne richiede almeno un altro, poiché Chip terminerà se ha esaurito il suo input. Se questo è inaccettabile, il flag -zpuò essere usato, il che aggiunge effettivamente un numero infinito di \0byte al fine dell'input.) Il codice TIO abbreviato in realtà non arriva a tutti gli 81 byte, quindi il punto è discutibile lì.

Il modo in cui l'ho implementato, osserva solo i 4 bit bassi dell'input, quindi tutto, in realtà, può essere un "puzzle" di sudoku, dai dati binari grezzi alle opere meno conosciute di Shakespeare. Qualsiasi carattere i cui 4 bit bassi sono tutti zero apparirà come uno spazio (un caso speciale), tutti gli altri caratteri verranno mappati123456789:;<=>? . (Quindi, le ultime non sono cifre, ma neanche 10 è un numero valido nel sudoku normale).

Per i caratteri di disegno a scatola, produce UTF-8, equivalente a 3 byte ciascuno.

Che dire dell'attuazione effettiva?

Chip è un linguaggio 3D che si ispira ai circuiti integrati. Ha fili, porte logiche e celle di memoria. La maggior parte delle cose viene fatta su piani 2D, ma questi piani possono essere impilati uno sopra l'altro. Ecco come è costruito questo programma.

Le linee che iniziano con =sono i separatori di livello. Quindi, i livelli vengono impilati, con i lati superiore e sinistro allineati. Ilo 's fungono da perni, permettendo segnali di passare da un livello all'altro.

Ogni livello qui ha uno scopo, potresti pensarli come funzioni. Il primo livello controlla tutto; "chiama" ciascuno degli altri livelli a turno. C'è uno schema ripetuto da sinistra a destra qui. Questo modello tiene traccia di quale delle 19 linee di output che stiamo attualmente stampando.

Il secondo strato è piuttosto piccolo e ha un lavoro molto piccolo. Imposta il 0x80bit per tutte le righe di output tranne le righe che contengono numeri. hè l'elemento Chip che corrisponde al 0x80bit. (L'estremità inferiore dell'alfabeto hattraverso adefinisce tutti e otto i bit di uscita.)

Il terzo livello è dove entriamo davvero nella carne della stampa. Questo livello è responsabile della prima riga. La versione ungolfed ha otto file di x's e) ", che si mappano su 0 e 1 per ciascuno degli otto bit di ciascun byte. Tuttavia, possiamo sfruttare i modelli nei bit per eseguire la stessa attività in meno righe.

Il livello quattro è molto simile al terzo. Gestisce le doppie linee orizzontali.

Il livello cinque gestisce l'ultima riga. Nota che manca il filo lungo la parte superiore degli altri strati. Questo perché non è necessario restituire il controllo al sequencer. Invece, possiamo semplicemente terminare l'esecuzione qui con t.

Lo strato sei gestisce le singole linee orizzontali.

Il livello sette è dove vengono stampati i numeri. Viene "chiamato" per ciascuna delle nove linee numeriche. Consuma 9 byte di input come parte della sua esecuzione.


1

JavaScript (ES6), 222 byte

Utilizzo della sintassi breve per le funzioni ES6 - 174 caratteri codificati in utf8, 222 byte ( https://mothereff.in/byte-counter ). L'utilizzo function ...richiede 16 byte in più.

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)

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

Provalo online!

Per il conteggio dei byte, utilizzare CP-437, che è nativamente supportato da Java come IBM437(API recenti) o Cp437(API precedenti); quindi utilizzare un sistema che ha questo set di caratteri ha questo set di caratteri come set di caratteri predefinito.

Questo codice è compatibile da Java 5 in poi, ma è stato testato solo su Java 8.

Spiegazione

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 byte (295 caratteri)

Approccio molto ingenuo, ma ho dovuto farlo anche se non ero un vincitore sotto ogni punto di vista:

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

Provalo online!


sono 599 UTF-8 byte. Dovresti provare a riutilizzare i caratteri della casella comune per salvare i byte
dzaima,

@dzaima: lo so, posso fare quello che ho fatto su una tastiera così reale che puoi quasi
ASSAGGIARLO

@dzaima: è per questo che ho detto approccio molto ingenuo
sergiol,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.