Escriba un programa o una función que acepte la lista de resultados de una función lógica y genere el código LaTeX para su tabla de verdad.

Las entradas deben etiquetarse como letras minúsculas a-z, y la salida debe etiquetarse como F. La longitud de la lista de entradas siempre será menor que 2^25, lo que significa que el número de entradas siempre será menor que 25, por lo que puede usar letras del alfabeto en minúsculas para los nombres de entrada.

Entrada

Un número nde entradas y una lista de longitud 2^nde números binarios que representa las salidas de una función lógica.

Salida

Código LaTeX que produce la tabla de verdad para esa función. Los valores de entrada y salida deben centrarse en filas. Debe haber una línea entre el encabezado de la tabla y sus valores y entre las entradas y las salidas, por lo que el código debe ser similar al siguiente.

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

Ejemplo

Entrada:

2
[0, 0, 0, 1]

Salida:

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

Que cuando se muestra en LaTeX muestra la siguiente tabla de verdad

Reglas generales

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
• Las lagunas predeterminadas están prohibidas.

Carbón de leña , 70 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔tabularζ

Guarde esta cadena en una variable para evitar la duplicación.

\ζ{*θc|c}⸿

Imprima la \tabular{*2c|c}línea inicial (2 o cualquier valor que qtenga la primera entrada ).

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

Obtenga las primeras qletras de la variable predefinida be inserte &s entre ellas, luego agregue &F\\y también imprima \hlineen la siguiente línea.

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

Recorre los caracteres en la segunda entrada. Para cada uno, su índice se convierte a binario con longitud q, el carácter se concatena, el resultado se une con &sy \\se agrega. Las cadenas resultantes se imprimen implícitamente en líneas separadas.

⁰\endζ

Imprime el \endtabular. (El ⁰es solo un separador ya que el desverbosificador no se inserta 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

Pruébalo en línea!

Salidas como

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

\tabulary \endtabularse usan como más cortos \begin{tabular}y \end{tabular}, según este consejo de golf de LaTeX . El *2ces una abreviatura para definir 2 columnas.

Haskell, 164155 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"]

Pruébalo en línea!

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 en \tabularlugar de \begin{tabular}(robado de la respuesta de @ 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)])))

Pruébalo en línea!

Versión bastante impresa:

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

Pruébalo en línea!

Protón , 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

Pruébalo en línea!

La salida está en forma de Golf LaTeX; gracias a xnor por ese truco!

Esto debería poder jugarse más corto que la respuesta de Python de xnor porque Proton en teoría nunca debería perder ante Python lol (en la práctica, soy malo xD). Puedo robarle algunos trucos a xnor; P

Se las arregló para que ahora sea más corto al convertir algunas cosas en variables, lo que acabo de notar que xnor también hizo: P

Y ahí vamos, -6 bytes usando algunos trucos de golf Proton.

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

Pruébalo en línea!

Salida similar a la respuesta de carbón . expand.grida partir de esta respuesta .

Para el registro, el uso xtabledel paquete de epónimo no es mucho más corto ya que uno tiene que especificar muchas opciones para que coincida con la especificación, además de incluir el paquete:

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)

Pruébalo en línea!