Bir mantık işlevinden çıkış listesini kabul eden ve doğruluk tablosu için LaTeX kodunu çıkaran bir program veya işlev yazın.

Girişler küçük harf a-z, çıkış ise etiketlenmelidir F. Giriş listesinin uzunluğu her zamankinden daha kısa olacaktır 2^25, yani giriş sayısı her zaman 25'ten az olacaktır, böylece giriş adları için küçük harfli alfabe harfleri kullanabilirsiniz.

Giriş

Mantıksal bir fonksiyonun çıkışlarını temsil eden bir dizi ngiriş ve 2^nikili sayıların uzunluk listesi .

Çıktı

Bu işlev için doğruluk tablosunu üreten LaTeX kodu. Giriş ve çıkış değerleri satırlar halinde ortalanmalıdır. Tablo üstbilgisi ve değerleri ile girişler ve çıktılar arasında bir çizgi bulunmalıdır, bu nedenle kod aşağıdakine benzer olmalıdır.

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

Misal

Giriş:

2
[0, 0, 0, 1]

Çıktı:

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

LaTeX'te görüntülendiğinde aşağıdaki doğruluk tablosunu gösterir

Genel kurallar

• Bu kod golf , bayt en kısa cevap kazanır.
• Varsayılan Loopholes yasaktır.

Kömür , 70 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

≔tabularζ

Çoğaltmayı önlemek için bu dizeyi bir değişkene kaydedin.

\ζ{*θc|c}⸿

İlk \tabular{*2c|c}satırı yazdırın (2 veya ilk girişin değeri ne olursa olsun q).

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

İlk alın qönceden tanımlanmış değişken harf bve insert &aralarında ler, daha sonra ekleme &F\\ve ayrıca baskı \hlinesonraki satırda.

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

İkinci girişteki karakterlerin üzerine gelin. Her biri için, dizini uzunluk ile ikiliye dönüştürülür q, karakter birleştirilir, sonuç &s ile birleştirilir ve \\eklenir. Ortaya çıkan dizeler dolaylı olarak ayrı satırlara yazdırılır.

⁰\endζ

Yazdırın \endtabular. ( ⁰Deverbosifier a eklemeyi unuttuğundan sadece bir ayırıcıdır ¦.)

Python 2 , 153 bayt

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

Çevrimiçi deneyin!

Gibi çıktılar

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

\tabularve \endtabulardaha kısa olarak kullanılır \begin{tabular}ve \end{tabular}gereği, bu LaTeX golf ucu . Bu *2c, 2 sütun tanımlamak için kullanılan bir kısayoldur.

Haskell, 164155 bayt

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

Çevrimiçi deneyin!

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' 

Düzenleme: ( @ xnor yanıtından çalındı) \tabularyerine kullanarak .\begin{tabular}

Python 2 , 192 168 166 bayt

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

Çevrimiçi deneyin!

Oldukça basılı versiyonu:

Python 2 , 234 229 218 209 205 203 bayt

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

Çevrimiçi deneyin!

Proton , 142 bayt

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

Çevrimiçi deneyin!

Çıktı golf LaTeX biçimindedir; Bu numara için xnor'a teşekkürler!

Proton teorik olarak asla Python lol kaybetmek gerekir çünkü bu xnor Python cevap daha kısa golf olabilir olmalıdır (pratikte ben kötü xD). Xnor'dan bazı numaralar çalabilirim; P

Değişkenlere bazı şeyler yaparak daha kısa olmayı başardım, ki xnor'ın da yaptığını fark ettim: P

Ve işte, bazı Proton golf hileleri kullanarak -6 bayt.

R , 196 187 171 bayt

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

Çevrimiçi deneyin!

Kömür cevabına benzer çıktı . expand.griddan bu cevap .

Kayıt için, xtableeponym paketinden kullanmak çok daha kısa değildir, çünkü pakete dahil olmanın yanı sıra, spesifikasyona uygun birçok seçenek belirtmek zorundadır:

R , 187 bayt

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)

Çevrimiçi deneyin!