Schreiben Sie ein Programm oder eine Funktion, die die Liste der Ausgaben einer Logikfunktion akzeptiert und den LaTeX-Code für ihre Wahrheitstabelle ausgibt.

Die Eingaben sollten als Kleinbuchstaben a-zund die Ausgabe als gekennzeichnet sein F. Die Länge der Liste der Eingaben ist immer kürzer als 2^25, was bedeutet, dass die Anzahl der Eingaben immer weniger als 25 beträgt, sodass Sie für Eingabenamen Buchstaben aus dem Kleinbuchstaben verwenden können.

Eingang

Eine Anzahl nvon Eingaben und eine Liste der Länge 2^nvon Binärzahlen, die die Ausgaben einer logischen Funktion darstellt.

Ausgabe

LaTeX-Code, der die Wahrheitstabelle für diese Funktion erstellt. Eingabe- und Ausgabewerte sollten in Zeilen zentriert sein. Zwischen dem Tabellenkopf und seinen Werten sowie zwischen Ein- und Ausgängen muss eine Zeile stehen, daher sollte der Code dem folgenden ähnlich sein.

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

Beispiel

Eingang:

2
[0, 0, 0, 1]

Ausgabe:

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

Was in LaTeX angezeigt wird, zeigt die folgende Wahrheitstabelle

Allgemeine Regeln

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
• Standardschlupflöcher sind verboten.

Holzkohle , 70 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

≔tabularζ

Speichern Sie diese Zeichenfolge in einer Variablen, um Doppelungen zu vermeiden.

\ζ{*θc|c}⸿

Drucken Sie die erste \tabular{*2c|c}Zeile (2 oder einen beliebigen Wert, den die erste Eingabe qhat).

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

Holen Sie sich die ersten qBuchstaben aus der vordefinierten Variablen bund fügen Sie &s dazwischen ein. Fügen Sie dann die hinzu &F\\und drucken Sie \hlinein der nächsten Zeile.

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

Schleife über die Zeichen in der zweiten Eingabe. Für jeden wird sein Index mit seiner Länge in eine Binärdatei konvertiert q, das Zeichen wird verkettet, das Ergebnis wird mit &s verbunden und \\angehängt. Die resultierenden Zeichenfolgen werden implizit in separaten Zeilen gedruckt.

⁰\endζ

Drucken Sie die \endtabular. (Das ⁰ist nur ein Trennzeichen, da der Deverbosifier vergisst, a einzufügen ¦.)

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

Probieren Sie es online aus!

Ausgänge wie

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

\tabularund \endtabularwerden als kürzer \begin{tabular}und \end{tabular}gemäß diesem LaTeX-Golftipp verwendet . Das *2cist eine Abkürzung zum Definieren von 2 Spalten.

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

Probieren Sie es online aus!

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' 

Bearbeiten: Verwenden \tabularstatt \begin{tabular}(gestohlen aus der Antwort von @ 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)])))

Probieren Sie es online aus!

Hübsche gedruckte Version:

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

Probieren Sie es online aus!

Proton , 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

Probieren Sie es online aus!

Die Ausgabe erfolgt in Golf-LaTeX-Form. danke an xnor für diesen trick!

Dies sollte in der Lage sein, kürzer als die Python-Antwort von xnor zu spielen, da Proton theoretisch niemals gegen Python lol verlieren sollte (in der Praxis bin ich schlecht xD). Ich kann xnor einige Tricks stehlen; P.

Es ist mir gelungen, jetzt kürzer zu werden, indem einige Dinge zu Variablen gemacht wurden, was mir gerade aufgefallen ist. Xnor hat es auch getan: P.

Und los geht's, -6 Bytes mit einigen Proton-Golf-Tricks.

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

Probieren Sie es online aus!

Ausgabe ähnlich der Antwort von Charcoal . expand.gridaus dieser Antwort .

Für die Aufzeichnung ist die Verwendung xtableaus dem Eponym-Paket nicht viel kürzer, da neben dem Einschließen des Pakets viele Optionen angegeben werden müssen, die der Spezifikation entsprechen:

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)

Probieren Sie es online aus!