Viết chương trình hoặc hàm chấp nhận danh sách đầu ra từ hàm logic và xuất mã LaTeX cho bảng chân lý của nó.

Các đầu vào phải được dán nhãn là chữ thường a-zvà đầu ra phải được dán nhãn là F. Độ dài của danh sách đầu vào sẽ luôn ngắn hơn 2^25, điều đó có nghĩa là số lượng đầu vào sẽ luôn nhỏ hơn 25, vì vậy bạn có thể sử dụng các chữ cái từ bảng chữ cái chữ thường cho tên đầu vào.

Đầu vào

Một số nđầu vào và danh sách độ dài 2^ncủa số nhị phân đại diện cho đầu ra của hàm logic.

Đầu ra

Mã LaTeX tạo ra bảng chân lý cho hàm đó. Giá trị đầu vào và đầu ra nên được tập trung trong các hàng. Phải có một dòng giữa tiêu đề bảng và các giá trị của nó và giữa đầu vào và đầu ra, vì vậy mã phải tương tự như dưới đây.

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

Thí dụ

Đầu vào:

2
[0, 0, 0, 1]

Đầu ra:

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

Mà khi hiển thị trong LaTeX hiển thị bảng chân lý sau

Quy tắc chung

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
• Lỗ hổng mặc định bị cấm.

Than , 70 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔tabularζ

Lưu chuỗi này trong một biến để tránh trùng lặp.

\ζ{*θc|c}⸿

In \tabular{*2c|c}dòng ban đầu (2 hoặc bất kỳ giá trị nào mà đầu vào đầu tiên qcó).

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

Lấy các qchữ cái đầu tiên từ biến được xác định trước bvà chèn &s giữa chúng, sau đó nối thêm &F\\và cũng in \hlinetrên dòng tiếp theo.

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

Lặp lại các ký tự trong đầu vào thứ hai. Đối với mỗi một, chỉ mục của nó được chuyển đổi thành nhị phân có độ dài q, ký tự được nối, kết quả được nối với &s và \\được nối thêm. Các chuỗi kết quả được in ngầm trên các dòng riêng biệt.

⁰\endζ

In \endtabular. (Đây ⁰chỉ là một dấu phân cách vì deverbosifier tha thứ để chèn 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

Hãy thử trực tuyến!

Đầu ra như

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

\tabularvà \endtabularđược sử dụng ngắn hơn \begin{tabular}và \end{tabular}, theo mẹo chơi gôn LaTeX này . Đây *2clà một tốc ký để xác định 2 cột.

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

Hãy thử trực tuyến!

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' 

Chỉnh sửa: sử dụng \tabularthay vì \begin{tabular}(bị đánh cắp từ câu trả lời của @ 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)])))

Hãy thử trực tuyến!

Phiên bản in đẹp:

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Đầu ra ở dạng LaTeX được đánh gôn; cảm ơn xnor vì mánh khóe đó!

Điều này sẽ có thể được đánh golf ngắn hơn câu trả lời Python của xnor vì về lý thuyết, Proton không bao giờ thua Python lol (trong thực tế tôi xấu xD). Tôi có thể ăn cắp một số thủ thuật từ xnor; P

Bây giờ được quản lý ngắn hơn bằng cách biến một số thứ thành các biến, điều mà tôi chỉ nhận thấy xnor cũng đã làm: P

Và ở đó chúng tôi đi, -6 byte bằng cách sử dụng một số thủ thuật chơi gôn 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="&")}

Hãy thử trực tuyến!

Đầu ra tương tự như câu trả lời Char than . expand.gridtừ câu trả lời này .

Đối với bản ghi, việc sử dụng xtabletừ gói từ đồng nghĩa không ngắn hơn nhiều vì người ta phải chỉ định rất nhiều tùy chọn để khớp với thông số kỹ thuật, ngoài việc bao gồm gói:

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)

Hãy thử trực tuyến!