Écrivez un programme ou une fonction qui accepte la liste des sorties d'une fonction logique et sort le code LaTeX pour sa table de vérité.

Les entrées doivent être étiquetées comme des lettres minuscules a-zet la sortie doit être étiquetée comme F. La longueur de la liste des entrées sera toujours inférieure à 2^25, ce qui signifie que le nombre d'entrées sera toujours inférieur à 25, vous pouvez donc utiliser des lettres de l'alphabet minuscule pour les noms des entrées.

Contribution

Un certain nombre nd'entrées et une liste de longueur 2^nde nombres binaires qui représentent les sorties d'une fonction logique.

Production

Code LaTeX qui produit la table de vérité pour cette fonction. Les valeurs d'entrée et de sortie doivent être centrées sur des lignes. Il doit y avoir une ligne entre l'en-tête du tableau et ses valeurs et entre les entrées et les sorties, le code doit donc être similaire à celui ci-dessous.

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

Exemple

Contribution:

2
[0, 0, 0, 1]

Production:

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

Qui, affiché dans LaTeX, montre la table de vérité suivante

Règles générales

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
• Les failles par défaut sont interdites.

Fusain , 70 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

≔tabularζ

Enregistrez cette chaîne dans une variable pour éviter la duplication.

\ζ{*θc|c}⸿

Imprime la \tabular{*2c|c}ligne initiale (2 ou quelle que soit la valeur de la première entrée q).

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

Obtenez les premières qlettres de la variable prédéfinie bet insérez des &s entre elles, puis ajoutez le &F\\et imprimez également \hlinesur la ligne suivante.

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

Faites une boucle sur les caractères de la deuxième entrée. Pour chacun, son index est converti en binaire de longueur q, le caractère est concaténé, le résultat est joint à &s et \\est ajouté. Les chaînes résultantes sont implicitement imprimées sur des lignes distinctes.

⁰\endζ

Imprimez le \endtabular. (Le ⁰n'est qu'un séparateur car le déverbosificateur oublie d'insérer un ¦.)

Python 2 , 153 octets

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

Essayez-le en ligne!

Sorties comme

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

\tabularet \endtabularsont utilisés comme plus courts \begin{tabular}et \end{tabular}, selon cette astuce de golf LaTeX . Le *2cest un raccourci pour définir 2 colonnes.

Haskell, 164155 octets

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

Essayez-le en ligne!

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' 

Modifier: utiliser à la \tabularplace de \begin{tabular}(volé dans la réponse de @ xnor ).

Python 2 , 192 168 166 octets

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

Essayez-le en ligne!

Jolie version imprimée:

Python 2 , 234 229 218 209 205 205 203 octets

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

Essayez-le en ligne!

Proton , 142 octets

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

Essayez-le en ligne!

La sortie est sous forme de LaTeX golfée; merci à xnor pour cette astuce!

Cela devrait être plus court que la réponse Python de xnor car Proton ne devrait en théorie jamais perdre contre Python lol (en pratique, je suis mauvais xD). Je peux voler des astuces à xnor; P

Géré pour être plus court en transformant certaines choses en variables, ce que je viens de remarquer que xnor a également fait: P

Et voilà, -6 octets en utilisant quelques astuces de golf Proton.

R , 196 187 171 octets

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

Essayez-le en ligne!

Sortie similaire à la réponse au charbon . expand.gridde cette réponse .

Pour mémoire, l'utilisation à xtablepartir du package éponyme n'est pas beaucoup plus courte car il faut spécifier beaucoup d'options pour correspondre à la spécification, en plus d'inclure le package:

R , 187 octets

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)

Essayez-le en ligne!