Scrivi un programma o una funzione che accetta l'elenco di uscite da una funzione logica e genera il codice LaTeX per la sua tabella di verità.

Gli input devono essere etichettati come lettere minuscole a-ze l'output deve essere etichettato come F. La lunghezza dell'elenco di input sarà sempre inferiore a 2^25, il che significa che il numero di input sarà sempre inferiore a 25, quindi è possibile utilizzare le lettere dell'alfabeto minuscolo per i nomi degli input.

Ingresso

Un numero ndi input e un elenco di lunghezza 2^ndi numeri binari che rappresentano gli output di una funzione logica.

Produzione

Codice LaTeX che produce la tabella di verità per quella funzione. I valori di input e output devono essere centrati in righe. Deve esserci una linea tra l'intestazione della tabella e i suoi valori e tra input e output, quindi il codice dovrebbe essere simile a quello qui sotto.

\begin{tabular}{c * <NUMBER OF INPUTS>|c}
<INPUTS>&F\\
\hline
<INPUT VECTOR i>&<OUTPUT>\\
\end{tabular}

Esempio

Ingresso:

2
[0, 0, 0, 1]

Produzione:

\begin{tabular}{cc|c}
a & b & F \\
\hline
0 & 0 & 0 \\
0 & 1 & 0 \\
1 & 0 & 0 \\
1 & 1 & 1 \\
\end{tabular}

Che quando viene visualizzato in LaTeX mostra la seguente tabella di verità

Regole generali

• Questo è code-golf , quindi vince la risposta più breve in byte.
• Le scappatoie predefinite sono vietate.

Carbone , 70 byte

≔tabularζ\ζ{*θc|c}⸿⪫✂β⁰Ｉθ¹&⁰&F\\⸿\hline⸿Ｅη⁺⪫⁺⮌ＥＩθＩ﹪÷κＸ²λ²⟦ι⟧&¦\\⁰\endζ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔tabularζ

Salvare questa stringa in una variabile per evitare la duplicazione.

\ζ{*θc|c}⸿

Stampa la \tabular{*2c|c}riga iniziale (2 o qualunque valore abbia il primo input q).

⪫✂β⁰Ｉθ¹&⁰&F\\⸿\hline⸿

Prendi le prime qlettere dalla variabile predefinita be inseriscile &tra loro, quindi aggiungi &F\\e stampa anche \hlinesulla riga successiva.

Ｅη⁺⪫⁺⮌ＥＩθＩ﹪÷κＸ²λ²⟦ι⟧&¦\\

Scorri i caratteri nel secondo input. Per ognuno, il suo indice viene convertito in binario con lunghezza q, il carattere viene concatenato, il risultato è unita &s e \\viene aggiunto. Le stringhe risultanti vengono implicitamente stampate su righe separate.

⁰\endζ

Stampa il \endtabular. ( ⁰È solo un separatore poiché il deverbosificatore dimentica di inserire un ¦.)

Python 2 , 153 byte

lambda n,l:r'\tabular{*%dc|c}%s&F\\\hline%s\endtabular'%(n,q(map(chr,range(97,97+n))),r'\\'.join(q(bin(2**n+i)[3:]+x)for i,x in enumerate(l)))
q='&'.join

Provalo online!

Uscite come

\tabular{*2c|c}a&b&F\\\hline0&0&0\\0&1&0\\1&0&0\\1&1&1\endtabular

\tabulare \endtabularsono usati come più corti \begin{tabular}e \end{tabular}, come da questa punta da golf LaTeX . La *2cè una scorciatoia per definire 2 colonne.

Haskell, 164 155 byte

s%f=((:"&")=<<s)++f:"\\\\"
n#r=unlines$("\\tabular{"++('c'<$[1..n])++"|c}"):take n['a'..]%'F':"\\hline":zipWith(%)(mapM id$"01"<$[1..n])r++["\\endtabular"]

Provalo online!

unlines                               -- take a list of strings and join it with NL.
                                      -- the strings are:
   "\\tabular{"++('c'<$[1..n])++"|c}" -- tabular definition with n times 'c'
   take n['a'..]%'F'                  -- table header
   "\\hline"                          -- hline
   zipWith(%)(mapM id$"01"<$[1..n])r  -- table content
   ["\\endtabular"]                   -- end of tabular definition

Table header and content are built via function '%'

s%f=                                  -- take a string 's' and a char 'f'
    ((:"&")=<<s)                      -- append a "&" to each char in 's'
    ++f:"\\\\"                        -- and append 'f' and two backslashes

Table header:

take n['a'..] % 'F'                   -- s: the first n letters from the alphabet
                                      -- f: char 'F'
Table content:

zipWith(%)                            -- apply '%' pairwise to
    mapM id$"01"<$[1..n]              -- all combinations of '0' and '1' of length n
    r                                 -- and the string 'r' 

Modifica: usando \tabularinvece di \begin{tabular}(rubato dalla risposta di @ xnor ).

Python 2 , 192 168 166 byte

lambda n,l:r'\begin{tabular}{*%dc|c}%s\end{tabular}'%(n,r'\\'.join(map('&'.join,[map(chr,range(97,97+n))+[r'F\\\hline']]+[bin(2**n+i)[3:]+l[n]for i in range(2**n)])))

Provalo online!

Versione piuttosto stampata:

Python 2 , 234 229 218 209 205 203 byte

n,l=input()
print'\\begin{tabular}{'+'c'*n+'|c}\n'+' & '.join(chr(i+97)for i in range(n)+[-27]),'\\\\\n\hline'
i=0
for r in l:print' & '.join(bin(i)[2:].rjust(n,'0')+`r`),r'\\';i+=1
print'\\end{tabular}'

Provalo online!

Proton , 142 byte

n=>x=>"\\tabular*#{n}c|c#{j(map(chr,97..97+n))}&F\\\\\hline"+'\\\\'.join(j(bin(i)[2to].zfill(n)+x[i])for i:0..len(x))+"\\endtabular"j="&".join

Provalo online!

L'output è in forma LaTeX golfizzata; grazie a xnor per quel trucco!

Questo dovrebbe essere in grado di essere golfato più breve della risposta Python di xnor perché in teoria Proton non dovrebbe mai perdere con Python lol (in pratica sono cattivo xD). Potrei rubare alcuni trucchi da Xnor; P

Riesco ad essere più breve trasformando alcune cose in variabili, cosa che ho appena notato anche xnor: P

Ed eccoci, -6 byte usando alcuni trucchi del golf Proton.

R , 196 187 171 byte

function(m,n){cat("\\tabular{*",n,"c|c}")
write(c(letters[1:n],"F\\\\\\hline",rbind(t(rev(expand.grid(rep(list(0:1),n)))),paste0(m,"\\\\")),"\\endtabular"),1,n+1,sep="&")}

Provalo online!

Uscita simile alla risposta al carbone . expand.gridda questa risposta .

Per la cronaca, l'utilizzo xtabledal pacchetto eponimo non è molto più breve poiché si devono specificare molte opzioni per abbinare le specifiche, oltre a includere il pacchetto:

R , 187 byte

function(m,n){u=rbind(apply(expand.grid(rep(list(0:1),n)),1,rev),m)
rownames(u)=c(letters[1:n],"F")
print(xtable(t(u),dig=0,align=c(rep("c",n+1),"|c}")),hl=0,include.r=F)}
library(xtable)

Provalo online!