Tulis program atau fungsi yang menerima daftar output dari fungsi logika dan output kode LaTeX untuk tabel kebenarannya.

Input harus diberi label sebagai huruf kecil a-z, dan outputnya harus diberi label F. Panjang daftar input akan selalu lebih pendek dari 2^25, yang berarti bahwa jumlah input akan selalu kurang dari 25, sehingga Anda dapat menggunakan huruf dari alfabet huruf kecil untuk nama input.

Memasukkan

Sejumlah ninput dan daftar panjang 2^nangka biner yang merepresentasikan output dari fungsi logis.

Keluaran

Kode LaTeX yang menghasilkan tabel kebenaran untuk fungsi itu. Nilai input dan output harus dipusatkan di baris. Harus ada garis antara header tabel dan nilai-nilainya serta antara input dan output, sehingga kode harus sama dengan yang di bawah ini.

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

Contoh

Memasukkan:

2
[0, 0, 0, 1]

Keluaran:

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

Yang ketika ditampilkan di LaTeX menunjukkan tabel kebenaran berikut

Aturan umum

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
• Celah default tidak diperbolehkan.

Arang , 70 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

≔tabularζ

Simpan string ini dalam variabel untuk menghindari duplikasi.

\ζ{*θc|c}⸿

Cetak \tabular{*2c|c}baris awal (2 atau nilai apa pun yang dimiliki input pertama q).

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

Dapatkan qhuruf pertama dari variabel yang telah ditentukan bdan masukkan &di antara mereka, lalu tambahkan &F\\dan juga cetak \hlinepada baris berikutnya.

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

Ulangi karakter dalam input kedua. Untuk masing-masing, indeksnya dikonversi menjadi biner dengan panjang q, karakter digabungkan, hasilnya digabungkan dengan &s dan \\ditambahkan. String yang dihasilkan dicetak secara implisit pada garis yang berbeda.

⁰\endζ

Cetak \endtabular . (Ini ⁰hanya pemisah karena deverbosifier lupa untuk memasukkan a ¦.)

Python 2 , 153 byte

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

Cobalah online!

Output seperti

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

\tabulardan \endtabulardigunakan sebagai lebih pendek \begin{tabular}dan \end{tabular}, sesuai dengan tip golf LaTeX ini . Ini *2cadalah singkatan untuk mendefinisikan 2 kolom.

Haskell, 164 155 byte

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

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

Sunting: menggunakan \tabularalih-alih \begin{tabular}(dicuri dari jawaban xnor ).

Python 2 , 192 168 166 byte

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

Cobalah online!

Versi tercetak cantik:

Python 2 , 234 229 218 209 205 203 byte

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

Cobalah online!

Proton , 142 byte

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

Cobalah online!

Output dalam bentuk golf LaTeX; terima kasih kepada xnor untuk trik itu!

Ini harus bisa di-golf menjadi lebih pendek daripada jawaban Python xnor karena secara teori Proton tidak pernah kalah dari Python lol (dalam prakteknya saya xD buruk). Saya dapat mencuri beberapa trik dari xnor; P

Berhasil sekarang menjadi lebih pendek dengan membuat beberapa hal menjadi variabel, yang saya perhatikan xnor juga lakukan: P

Dan kita mulai, -6 byte dengan menggunakan beberapa trik golf Proton.

R , 196 187 171 byte

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

Cobalah online!

Output mirip dengan jawaban Arang . expand.griddari jawaban ini .

Sebagai catatan, menggunakan xtabledari paket eponym tidak jauh lebih pendek karena kita harus menentukan banyak opsi agar sesuai dengan spesifikasi, selain termasuk paket:

R , 187 byte

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)

Cobalah online!