Escreva um programa ou uma função que aceite a lista de saídas de uma função lógica e emita o código LaTeX para sua tabela verdade.

As entradas devem ser rotuladas como letras minúsculas a-ze a saída deve ser rotulada como F. O comprimento da lista de entradas sempre será menor que 2^25, o que significa que o número de entradas sempre será menor que 25; portanto, você pode usar letras do alfabeto minúsculo para nomes de entrada.

Entrada

Um número nde entradas e uma lista do comprimento 2^ndos números binários que representam as saídas de uma função lógica.

Resultado

Código LaTeX que produz a tabela verdade para essa função. Os valores de entrada e saída devem ser centralizados em linhas. Deve haver uma linha entre o cabeçalho da tabela e seus valores e entre entradas e saída, portanto, o código deve ser semelhante ao abaixo.

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

Exemplo

Entrada:

2
[0, 0, 0, 1]

Resultado:

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

Que quando exibido no LaTeX mostra a seguinte tabela verdade

Regras gerais

• Isso é código-golfe , então a resposta mais curta em bytes vence.
• As brechas padrão são proibidas.

Carvão , 70 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

≔tabularζ

Salve essa sequência em uma variável para evitar duplicação.

\ζ{*θc|c}⸿

Imprima a \tabular{*2c|c}linha inicial (2 ou qualquer valor que a primeira entrada qtenha).

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

Obtenha as primeiras qletras da variável predefinida be insira &s entre elas; em seguida, acrescente &F\\e imprima \hlinena próxima linha.

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

Faça um loop sobre os caracteres na segunda entrada. Para cada um, seu índice é convertido em binário com comprimento q, o caractere é concatenado, o resultado é associado &a \\se anexado. As seqüências resultantes são impressas implicitamente em linhas separadas.

⁰\endζ

Imprima o \endtabular. (O ⁰é apenas um separador, como o deverbosifier perdoa para inserir a ¦.)

Python 2 , 153 bytes

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

Experimente online!

Saídas como

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

\tabulare \endtabularsão usados ​​como mais curtos \begin{tabular}e \end{tabular}, de acordo com esta dica de golfe LaTeX . O *2cé um atalho para definir 2 colunas.

Haskell, 164 155 bytes

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

Experimente 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' 

Editar: usando em \tabularvez de \begin{tabular}(roubado da resposta do @ xnor ).

Python 2 , 192 168 166 bytes

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

Experimente online!

Versão impressa bonita:

Python 2 , 234 229 218 209 205 203 bytes

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

Experimente online!

Próton , 142 bytes

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

Experimente online!

A saída está no formato LaTeX de golfe; graças ao xnor por esse truque!

Isso deve ser capaz de ser jogado para menos do que a resposta em Python do xnor, porque Proton nunca deveria, em teoria, perder para lol em Python (na prática, eu sou ruim em xD). Posso roubar alguns truques do xnor; P

Agora consegui ser mais curto, transformando algumas coisas em variáveis, o que acabei de perceber que o xnor também fazia: P

E lá vamos nós, -6 bytes, usando alguns truques de golfe Proton.

R , 196187 171 bytes

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="&")}

Experimente online!

Saída semelhante à resposta do carvão vegetal . expand.gridde esta resposta .

Para o registro, o uso xtabledo pacote eponym não é muito mais curto, pois é necessário especificar muitas opções para corresponder à especificação, além de incluir o pacote:

R , 187 bytes

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)

Experimente online!