Tablas de verdad de LaTeX

11

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

Mesa de la verdad

Reglas generales

drobilc
fuente
3
¿Este desafío requiere exactamente la misma salida o cualquier salida que pueda producir lo mismo en TeX?
tsh
2
Cualquier salida que produzca lo mismo en TeX
drobilc
2
Algo que encuentro complicado aquí sin conocer TeX tan bien es que podría haber otras formas más cortas de escribir la tabla formateando el código TeX, o incluso alguna otra forma (¿paquete?) De producir la tabla. Independientemente del idioma que use, TeX golf es parte del desafío. ¿Existe un intérprete en línea para TeX por conveniencia, y tal vez para hacer inequívoca la implementación exacta?
xnor
1
Consejo: El código TeX parece funcionar con todos los espacios y líneas nuevas eliminados.
xnor
1
Cualquiera que no sepa cómo hacerlo en LaTeX, siga el ejemplo de salida anterior. Si n = 5, poner simple en ccccclugar de cc, pero dejar |csolo ... Y sí, en esta tabla, todos los espacios y las nuevas líneas son opcionales, pero evitaría las líneas en blanco.
Heimdall el

Respuestas:

10

Carbón de leña , 70 bytes

≔tabularζ\ζ{*θc|c}⸿⪫✂β⁰Iθ¹&⁰&F\\⸿\hline⸿Eη⁺⪫⁺⮌EIθI﹪÷κX²λ²⟦ι⟧&¦\\⁰\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 ).

⪫✂β⁰Iθ¹&⁰&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.

Eη⁺⪫⁺⮌EIθI﹪÷κX²λ²⟦ι⟧&¦\\

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

Neil
fuente
2
Es un poco impresionante que el carbón sea actualmente el ganador, dado que este desafío no es realmente para lo que está diseñado.
Erik the Outgolfer
6

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.

xnor
fuente
5

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

nimi
fuente
3

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!

TFeld
fuente
2

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.

Hiperneutrino
fuente
1

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!

JayCe
fuente