Temel mantık kapılarını taklit eden bir program yapın.

Giriş: Tümüyle büyük harfli bir sözcük ve ardından boşluklarla ayrılmış 2 adet 1 basamaklı ikili sayı OR 1 0. Kapılar OR, AND, NOR, NAND, XOR, ve XNORihtiyaç vardır.

Çıktı: Girilen mantık geçidinin çıktısına iki sayı verilir: 1 veya 0.

Örnekler:
AND 1 0 olur 0
XOR 0 1olur 1
OR 1 1olur 1
NAND 1 1olur0

Bu kodgolf, bu yüzden en kısa kod kazanıyor.

Jöle , 13 10 bayt

OSị“ʋN’BŻ¤

Çevrimiçi deneyin!

Port Peter Taylor'ın cevabı.

Python 2 , 38 bayt

lambda s:sum(map(ord,s))*3%61%37%9%7%2

Çevrimiçi deneyin!

İyi bir ol 'modulo zinciri, giriş dizesinin ASCII değerlerinin toplamına uygulanmış ve sadece fazla uygun bir çözüm üretmiştir. Toplam ASCII değeri olanlar dışında, her bir olası girdi için farklıdır 0 1ve 1 0kullanılan tüm mantık kapıları simetrik olduğu için çalışır aynı sonucu vermek.

*3Sert mod zincir bölmek için bu yapmak için, sadece bit farklı girişler için, aksi takdirde komşu değerleri ayırır. Mod zincirindeki sayıların uzunluğu ve boyutu, 18 ikili çıkışa uyacak şekilde kabaca doğru miktarda entropi oluşturur.

hash(s)Veya kullanarak daha kısa bir çözüm kesinlikle mümkündür id(s), ancak bunlardan kaçındım çünkü sisteme bağımlılar.

Python 2 , 50 bayt

lambda s:'_AX0NRD'.find((s*9)[35])>>s.count('0')&1

Çevrimiçi deneyin!

Biraz daha ilkeli bir çözüm. Her mantık geçidi, girişteki her sıfır sayısı için farklı bir sonuç verir, 1'den 6'ya kadar üç bitlik bir sayı olarak kodlanabilir. Her olası mantık geçidi, (s*9)[35]hepsi farklı olan karşılık gelen sayıya eşlenir . İçin OR, bu parçalarından birine okuma rüzgarlar kadar karakter olabilir bu yüzden 0ya 1, ama buna olmadığını kontrol etmek işten çıkıyor 0ve 1doğru bir verecektir 1zaten sonucu.

JavaScript (ES6), 39 bayt

s=>341139>>parseInt(btoa(s),34)%86%23&1

Çevrimiçi deneyin!

Nasıl?

parseInt()Hangi tabanda çalıştığımız önemli değil , boşlukları ayrıştıramayız . Bu yüzden bunun yerine girdi dizesinin base-64 temsilini enjekte ediyoruz. Bu, =dolgu karakterleri oluşturabilir (bunlardan biriyle ayrıştırılamaz parseInt()), ancak bunların dizenin sonunda bulunacağı garanti edilir ve güvenli bir şekilde yok sayılabilir.

Baz olarak ayrıştırır ve aşağıdaki sonuçları veren bir modulo , ardından bir modulo uygularız . Bu, hassasiyet kaybından kaynaklanan yanlışlıkları da içerir. Nihai sonuç ve en yüksek doğruluk indeksi ve 19 bitlik bir arama bitmaskisine yol açar.$34$$86$$23$$[0..19]$$18$

 input      | to base-64     | parsed as base-34 | mod 86 | mod 23 | output
------------+----------------+-------------------+--------+--------+--------
 "AND 0 0"  | "QU5EIDAgMA==" |  1632500708709782 |   26   |    3   |    0
 "AND 0 1"  | "QU5EIDAgMQ==" |  1632500708709798 |   42   |   19   |    0
 "AND 1 0"  | "QU5EIDEgMA==" |  1632500708866998 |   34   |   11   |    0
 "AND 1 1"  | "QU5EIDEgMQ==" |  1632500708867014 |   50   |    4   |    1
 "OR 0 0"   | "T1IgMCAw"     |     1525562056532 |   52   |    6   |    0
 "OR 0 1"   | "T1IgMCAx"     |     1525562056533 |   53   |    7   |    1
 "OR 1 0"   | "T1IgMSAw"     |     1525562075028 |   58   |   12   |    1
 "OR 1 1"   | "T1IgMSAx"     |     1525562075029 |   59   |   13   |    1
 "XOR 0 0"  | "WE9SIDAgMA==" |  1968461683492630 |   48   |    2   |    0
 "XOR 0 1"  | "WE9SIDAgMQ==" |  1968461683492646 |   64   |   18   |    1
 "XOR 1 0"  | "WE9SIDEgMA==" |  1968461683649846 |   56   |   10   |    1
 "XOR 1 1"  | "WE9SIDEgMQ==" |  1968461683649862 |   72   |    3   |    0
 "NAND 0 0" | "TkFORCAwIDA=" | 61109384461626344 |   62   |   16   |    1
 "NAND 0 1" | "TkFORCAwIDE=" | 61109384461626350 |   70   |    1   |    1
 "NAND 1 0" | "TkFORCAxIDA=" | 61109384461665650 |   64   |   18   |    1
 "NAND 1 1" | "TkFORCAxIDE=" | 61109384461665656 |   72   |    3   |    0
 "NOR 0 0"  | "Tk9SIDAgMA==" |  1797025468622614 |   76   |    7   |    1
 "NOR 0 1"  | "Tk9SIDAgMQ==" |  1797025468622630 |    6   |    6   |    0
 "NOR 1 0"  | "Tk9SIDEgMA==" |  1797025468779830 |   84   |   15   |    0
 "NOR 1 1"  | "Tk9SIDEgMQ==" |  1797025468779846 |   14   |   14   |    0
 "XNOR 0 0" | "WE5PUiAwIDA=" | 66920415258533864 |    0   |    0   |    1
 "XNOR 0 1" | "WE5PUiAwIDE=" | 66920415258533870 |    8   |    8   |    0
 "XNOR 1 0" | "WE5PUiAxIDA=" | 66920415258573170 |    2   |    2   |    0
 "XNOR 1 1" | "WE5PUiAxIDE=" | 66920415258573176 |   10   |   10   |    1

CJam (13 bayt)

q1bH%86825Yb=

Girdinin son satırsonu olmadığını varsayar.

Çevrimiçi test takımı

Bu sadece 24 olası girişi 17 farklı ama tutarlı değere eşleyen ve daha sonra bunları sıkıştırılmış bir tabloda arayan basit bir hashtır.

Python 2 (36 bayt)

lambda s:76165>>sum(map(ord,s))%17&1

Bu sadece yukarıdaki CJam cevabının bir limanıdır. Xnor'un test çerçevesini kullanarak test takımı .

05AB1E , 13 12 10 8 bayt

ÇO₁*Ƶï%É

Port @mazzy'nin Powershell cevabı hakkındaki yorumunda ( *256%339%2yerine *108%143%2) belirtilen alternatif hesaplama .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

Ç            # Convert each character in the (implicit) input to a unicode value
 O           # Sum them together
  ₁*         # Multiply it by 256
    Ƶï%      # Then take modulo-339
        É    # And finally check if it's odd (short for %2), and output implicitly

Neden Ƶïolduğunu anlamak için bu 05AB1E ucuma bakın ( Büyük tamsayılar nasıl sıkıştırılır? Bölümü )339 .

Kömür , 32 bayt

§01÷⌕⪪”＆⌈4Ｙ⍘ＬH⦄vü|⦃³Ｕ}×▷” Ｓ∨⁺ＮＮ⁴

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama: Sıkıştırılmış dize, desteklenen işlemlerin listesine genişler, böylece verilen işlemin dizini daha sonra girdilere göre sağa kaydırılır ve böylece çıkarılan bit sonuç olur.

XOR     001
AND     010
OR      011
NOR     100
NAND    101
XNOR    110
inputs  011
        010

74 baytlık sürüm, keyfi olarak şu şekilde adlandırdığım 16 ikili işlemin tümü için çalışır: SIFIR VE DAHA AZ İKİNCİ BÜYÜK BÜYÜK İLK VEYA NOR XNOR NFIRST NGREATER NSECOND NLESS NAND NZERO.

§10÷÷⌕⪪”＆↖VρＳ´↥cj/v⊗J[Rf↓⪫？9ＫO↘Ｙ⦄;↙W´Ｃ>η=⁴⌕✳AＫＸIＢ｜⊖\`⊖:Ｂ�Ｊ/≧vF@$h⧴” Ｓ∨Ｎ²∨Ｎ⁴

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

Mathematica, 55 bayt

Symbol[ToCamelCase@#][#2=="1",#3=="1"]&@@StringSplit@#&

Saf fonksiyon. Bir dizeyi girdi ve döndürme Trueveya Falseçıktı olarak alır. Yana Or, And, Nor, Nand, Xor, ve Xnortüm yerleşik ins vardır, kullandığımız ToCamelCasePascal durumda operatörün değiştirmek için, eşdeğer sembole dönüştürün ve iki argüman uygulayın.

J , 21 bayt

2|7|9|37|61|3*1#.3&u:

Çevrimiçi deneyin!

Port XNOR Python 2 solüsyon .

J , 30 bayt

XNOR=:=/
NAND=:*:/
NOR=:+:/
".

Çevrimiçi deneyin!

Eval ile eğlenceli kısmı biraz ".ve standart kütüphanesinde (zaten doğru içerdiğinden AND, OR, XOR).

J , 41 bayt

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

Çevrimiçi deneyin!

Daha fazla J tarzı yaklaşım.

Nasıl çalışır

Burada çok genel bir J numarası gizlendi. Genellikle, istenen işlev "Bir girişte F yapın, diğerinde H yapın ve ardından her iki sonuçta G yapın." O zaman böyle çalışmalıdır (F x) G H y. Gizli formda, şuna eşittir (G~F)~H:

x ((G~F)~H) y
x (G~F)~ H y
(H y) (G~F) x
(H y) G~ F x
(F x) G H y

Eğer Gasimetrik bir ilkel, sadece hedef fonksiyonunun sağ ve sol argümanları takas ve bir bayt kaydedebilirsiniz.

Şimdi yukarıdaki cevaba geçelim:

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

1 i.~' XXNNA'E.~_2&}.  Processing right argument (X): the operation's name
                _2&}.  Drop two chars from the end
1 i.~' XXNNA'E.~       Find the first match's index as substring
                       Resulting mapping is [OR, XOR, XNOR, NOR, NAND, AND]

7 6 9 8 14 1 b./  Processing left argument (Y): all logic operations on the bits
7 6 9 8 14 1 b.   Given two bits as left and right args, compute the six logic functions
               /  Reduce by above

X{Y  Operation on both: Take the value at the index

Powershell, 36 34 bayt

Xnor'dan esinlenilmiştir , ancak sıra *108%143%2orijinalden daha kısadır*3%61%37%9%7%2

$args|% t*y|%{$n+=108*$_};$n%143%2

Test komut dosyası:

$f = {

 $args|% t*y|%{$n+=108*$_};$n%143%2
#$args|% t*y|%{$n+=3*$_};$n%61%37%9%7%2   # sequence by xnor

}

@(
    ,("AND 0 0", 0)
    ,("AND 0 1", 0)
    ,("AND 1 0", 0)
    ,("AND 1 1", 1)
    ,("XOR 0 0", 0)
    ,("XOR 0 1", 1)
    ,("XOR 1 0", 1)
    ,("XOR 1 1", 0)
    ,("OR 0 0", 0)
    ,("OR 0 1", 1)
    ,("OR 1 0", 1)
    ,("OR 1 1", 1)
    ,("NAND 0 0", 1)
    ,("NAND 0 1", 1)
    ,("NAND 1 0", 1)
    ,("NAND 1 1", 0)
    ,("NOR 0 0", 1)
    ,("NOR 0 1", 0)
    ,("NOR 1 0", 0)
    ,("NOR 1 1", 0)
    ,("XNOR 0 0", 1)
    ,("XNOR 0 1", 0)
    ,("XNOR 1 0", 0)
    ,("XNOR 1 1", 1)

) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $s=$r"
}

Çıktı:

True: AND 0 0=0
True: AND 0 1=0
True: AND 1 0=0
True: AND 1 1=1
True: XOR 0 0=0
True: XOR 0 1=1
True: XOR 1 0=1
True: XOR 1 1=0
True: OR 0 0=0
True: OR 0 1=1
True: OR 1 0=1
True: OR 1 1=1
True: NAND 0 0=1
True: NAND 0 1=1
True: NAND 1 0=1
True: NAND 1 1=0
True: NOR 0 0=1
True: NOR 0 1=0
True: NOR 1 0=0
True: NOR 1 1=0
True: XNOR 0 0=1
True: XNOR 0 1=0
True: XNOR 1 0=0
True: XNOR 1 1=1

Perl 6 , 20 bayt

*.ords.sum*108%143%2

Çevrimiçi deneyin!

Maddy'nin yaklaştığı bir liman . Alternatif olarak *256%339%2da çalışır.

Perl 6 , 24 bayt

*.ords.sum*3%61%37%9%7%2

Çevrimiçi deneyin!

Bir xnor cevabının limanı . Daha kısa olanı bulmaya çalışacağım, ama muhtemelen en iyisi olduğunu düşünüyorum.

JavaScript (Node.js) , 106 94 bayt

x=>([a,c,d]=x.split` `,g=[c&d,c^d,c|d]["OR".search(a.slice(1+(b=/N[^D]/.test(a))))+1],b?1-g:g)

Çevrimiçi deneyin!

Kod ve 24 durumun tümü için bağlantı.

+9 için XNOR durumunu eşleştirmeyi unuttum.

Java 10, 30 28 bayt

s->s.chars().sum()*108%143%2

Port @mazzy'nin Powershell cevabı .

Çevrimiçi deneyin.

JavaScript (Node.js) , 45 bayt

Xnor'ın muhteşem Python 2 cevabının sadece bir limanı rıza üzerine yayınlandı, lütfen bunun yerine bu cevapları oylayın.

x=>Buffer(x).reduce((a,b)=>a+b)*3%61%37%9%7%2

Çevrimiçi deneyin!

Ataşe , 55 bayt

{Eval!$"${Sum!Id''Downcase!SplitAt!_}${N=>__2}"}@@Split

Çevrimiçi deneyin!

Oldukça kaba bir çözüm. Girdiyi ilgili Ataşeleme komutuna dönüştürür ve değerlendirir. (Ataşenin 6 mantık geçidinin her biri için yerleşik özellikleri vardır.)

Ruby , 20 bayt

->s{76277[s.sum%17]}

Çevrimiçi deneyin!

Nasıl çalışır:

Temel olarak Peter Taylor'ın cevabı ile aynı, ancak Ruby bunu kolaylaştırıyor. Sihirli sayı farklı ama fikir aynıydı.