Napisz program lub funkcję, która akceptuje listę wyników funkcji logicznej i wyświetla kod LaTeX dla swojej tabeli prawdy.

Dane wejściowe powinny być oznaczone małymi literami a-z, a dane wyjściowe - F. Długość listy danych wejściowych zawsze będzie krótsza niż 2^25, co oznacza, że ​​liczba danych wejściowych zawsze będzie mniejsza niż 25, więc możesz używać liter z małych liter alfabetu do nazw danych wejściowych.

Wejście

Liczba ndanych wejściowych i lista długości 2^nliczb binarnych reprezentujących dane wyjściowe funkcji logicznej.

Wynik

Kod LaTeX, który tworzy tabelę prawdy dla tej funkcji. Wartości wejściowe i wyjściowe powinny być wyśrodkowane w rzędach. Między nagłówkiem tabeli a jej wartościami oraz między danymi wejściowymi i wyjściowymi musi znajdować się linia, więc kod powinien być podobny do poniższego.

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

Przykład

Wejście:

2
[0, 0, 0, 1]

Wynik:

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

Które wyświetlane w LaTeX pokazują następującą tabelę prawdy

Główne zasady

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
• Domyślne luki są zabronione.

Węgiel drzewny , 70 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

≔tabularζ

Zapisz ten ciąg w zmiennej, aby uniknąć powielania.

\ζ{*θc|c}⸿

Wydrukuj \tabular{*2c|c}wiersz początkowy (2 lub dowolną wartość, którą qma pierwsze wejście ).

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

Pobierz pierwsze qlitery ze wstępnie zdefiniowanej zmiennej bi wstaw &je między nimi, a następnie dodaj, &F\\a także wydrukuj \hlinew następnym wierszu.

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

Pętla nad znakami na drugim wejściu. Dla każdego z nich jego indeks jest konwertowany na dwójkowy o długości q, znak jest konkatenowany, wynik jest łączony &si i \\jest dołączany. Powstałe ciągi są domyślnie drukowane na osobnych wierszach.

⁰\endζ

Wydrukuj \endtabular. (Jest ⁰to tylko separator, ponieważ deverbosifier zapomniał wstawić a ¦.)

Python 2 , 153 bajty

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

Wypróbuj online!

Wyjścia jak

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

\tabulari \endtabularsą używane jako krótsze \begin{tabular}i \end{tabular}, zgodnie z tą wskazówką golfową LaTeX . *2cJest skrótem do zdefiniowania 2 kolumny.

Haskell, 164 155 bajtów

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

Wypróbuj 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' 

Edycja: za pomocą \tabularzamiast \begin{tabular}(skradziony z odpowiedzi @ xnor ).

Python 2 , 192 168 166 bajtów

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

Wypróbuj online!

Wersja dość drukowana:

Python 2 , 234 229 218 209 205 203 bajtów

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

Wypróbuj online!

Proton , 142 bajty

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

Wypróbuj online!

Dane wyjściowe są w postaci golfa LaTeX; dzięki xnor za tę sztuczkę!

To powinno być w stanie grać w golfa krótszą niż odpowiedź xnora na Python, ponieważ Proton teoretycznie nigdy nie powinien przegrać z Python lol (w praktyce jestem zły xD). Mogę ukraść niektóre sztuczki z Xnora; P

Udało mi się teraz być krótszym, zmieniając niektóre rzeczy w zmienne, co właśnie zauważyłem, że xnor też: P

I proszę, -6 bajtów, używając kilku sztuczek golfowych Proton.

R , 196 187 171 bajtów

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

Wypróbuj online!

Wyjście podobne do odpowiedzi na węgiel drzewny . expand.gridz tej odpowiedzi .

Dla przypomnienia, korzystanie xtablez pakietu eponimowego nie jest dużo krótsze, ponieważ oprócz określenia pakietu należy podać wiele opcji, aby dopasować specyfikację:

R 187 bajtów

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)

Wypróbuj online!