Kilise Boole'ları


33

Kilise Boole'ları

Bir Kilise Boole işlevi için ilk argüman olan ve işlevin ikinci argümanı olan xdoğru ve yyanlış için geri dönen bir işlevdir. Diğer fonksiyonlar temsil eden bu fonksiyonlardan meydana gelebilir ve mantıksal işlemleri.xyand not or xorimplies

Meydan okuma

Kilise Boolean ve Construct and not or xorve impliessizin seçtiğiniz bir dilde kilise kapıları. and orve xoriki işlevde (Kilise boolenlerini temsil eden) almalı ve bir işlev döndürmelidir (başka bir Kilise boolenini temsil eden). Aynı şekilde, notaldığı fonksiyonu tersine çevirmeli ve impliesgeçit booleanı gerçekleştirmeli, ilk argümanın impliesikinci olduğu mantık anlamına gelir .

puanlama

Tüm kod toplam uzunluğu Kilisesi'ni yapmak için gerekli trueve falsekendi dilinizde ve and not or xorve impliesKilisesi işlevin adını hariç kapıları. (örneğin, false=lambda x,y:yPython'da 13 bayt olacaktır). Bu isimleri daha sonra kodunuzda tekrar kullanarak, bu geçidin toplam baytına 1 bayt sayarak kullanabilirsiniz.

Sahte kod Örnekler:

Yarattığınız fonksiyonlar daha sonra kodunuzda aranabilmelidir.

true(x, y) -> x
false(x, y) -> y
and(true, true)(x, y) -> x
and(true, false)(x, y) -> y
# ... etc

2
İşlev girişlerini (veya en yakın yerine geçenleri) kara kutu işlevleri olarak mı ele almalıyız, yoksa içindeki kodu inceleyebilir miyiz? Mantıksal işlemlerin dönüş değerleri, daha önce Kilise booleanları ile tanımlanan işlevlerle aynı mı olmalı yoksa aynı şeyi yapan başka bir şey olabilir mi?
İlişkisiz Dize

1
@JonathanAllan Ben düzeltdim böylece doğru. İstemi şimdi olması gerektiği gibidir.
Ryan Schaefer

2
Listeleri argüman olarak alabilir miyiz (örn true([x, y]). and([true, true])([x, y]))?
ar4093

2
@RyanSchaefer Argümanların sıralı bir listede olmasına izin vermeyi yeniden düşünmelisiniz, çünkü argümanlar çözümlerin başında basitçe sarılabilir. Buna ihtiyaç duymanın bu zorluğu gidermek için bir şey yaptığını sanmıyorum (aslında ilginç golf potansiyelini sınırladığını düşünüyorum). Tabii ki, bu sadece benim görüşüm ve kabul etmemeniz iyi.
FryAmTheEggman

1
Puanlama oldukça kafa karıştırıcı. İnsanların adsız işlevler sunmasına izin vermek daha iyi olmaz mıydı, ancak diğer bölümlerde de kullanırlarsa, her zamanki gibi onları atamak zorunda kalırlar
Jo King,

Yanıtlar:


14

İkili Lambda Hesabı , 13.875 12.875 bayt (103 bit)

İkili Lambda Hesap Dili (BLC) John Tromp tarafından temelde lamda hesap için verimli bir seri hale getirme formatıdır. Kilise notasyonu bile BLC'de booleanlarla çalışmanın "aptalca" yolu olduğundan, bu görev için çok uygun.

Bazı Haskell cevabından kopyaladığım ve golf oynadığım birleştiriciler için aşağıdaki lambda fonksiyonlarını kullandım : Her dava için 20 β azaltma kanıtı sınırlı kapsamlı bir arama sonucu bulunan. Bu mümkün olan en kısa sürede iyi bir şans var.

True:  (\a \b a)
False: (\a \b b)
Not:   (\a \b \c a c b)
And:   (\a \b b a b)
Or:    (\a a a)
Xor:   (\a \b b (a (\c \d d) b) a)
Impl:  (\a \b a b (\c \d c))

Bunlar, aşağıdaki (ikili) BLC kod dizilerine tercüme eder:

 bits |  name | BLC
------+-------+---------
    7 | True  | 0000 110
    6 | False | 0000 10
   19 | Not   | 0000 0001 0111 1010 110
   15 | And   | 0000 0101 1011 010
    8 | Or    | 0001 1010
   28 | Xor   | 0000 0101 1001 0111 0000 0101 0110
   20 | Impl  | 0000 0101 1101 0000 0110

Yukarıdaki işlevler toplam 111 bit uzunluğunda (13.875 bayt) 103 bit uzunluğunda (12.875 bayt). Bir programda kullanılacak bayt sınırlarına hizalanmaları gerekmez, bu nedenle kesirli baytları saymak mantıklıdır.

Birleştiriciler arasında yeniden kullanım kodu yoktur, çünkü BLC'de değişkenler / referanslar / adlar yoktur - her şeyin kopyalanması gerekiyordu. Yine de, kodlamanın etkinliği, oldukça özlü bir gösterim sağlar.


1
Blc bilmiyorum ama işe And: (\a \b a b a)yarayacak mı?
tsh

Evet çalışıyor. Aslında bu formülü kod dizilerim için kullandım. Karşılık gelen lambda işlevini güncellemeyi unuttum (şimdi düzeltildi). Eşdeğer işlevi Or: için çalışır \a \b a a b. Yine de BLC'de kullandığımdan daha uzun.
Pavel Potoček

25

Haskell , 50 - 6 = 44 bayt

Khuldraeseth na'Barya sayesinde -1 bayt ve Christian Sievers sayesinde -1 bayt.

t=const
f=n t
n=flip
a=n n f
o=($t)
x=(n>>=)
i=o.n

Çevrimiçi deneyin!


2
Yan Not: Tanımlayabileceğiniz Showiçin örneklerini constve const iddoğrudan kilise boole yazdırın. Çevrimiçi deneyin! .
nimi


4
Neden kimse kullanmıyor f=n t?
Christian Sievers,

3
Sen kullanarak bir bayt kaydedebilirsiniz t=pureyerine t=const.
Joseph Sible

4
@JosephSible Başlangıçta denedim. Ne yazık ki, t=purehataya neden olur ben uygulamaya çalıştığınızda a, o,x , veya ibuna. tBu maliyetleri düzeltmenin türünü yalnızca kullanmaktan daha fazla bayt olarak bildirmek t=const.
Nitrodon

9

Python 2 , (-3?)  101  95 bayt

David Beazley kalbini ye!

-6 Chas Brown sayesinde (tekrarlananları bir araya :getirme metnine taşıdım >. <)

exec'=lambda x,y=0:'.join('F y;T x;N x(F,T);A x(y,F);O x(T,y);X x(N(y),y);I O(y,N(x))'.split())

Çevrimiçi deneyin!

Bunun olabileceğini düşünüyorum 95 - 3ben fonksiyonlarını tekrar kullanmayın çünkü A, Xya Iama tek kullanmak =(önünde atama için lambda). Belki hiçbirini kaldıramıyorum; belki 3.5 bile çıkarabilirim?


@Ryan Schaefer üç tane kaldırabilir miyim yoksa execortalama kullanmam yapamaz mı? Her iki şekilde de gidebildiğini görebiliyorum - A, X veya tekrar kullanmıyorum ama kod onlarsız çalışmayacak. (Belki 3.5 bile kaldırılsın mı ?!)
Jonathan Allan


@Chas teşekkürler! Ağın içinden geçen kolon :) -1 BTW yerine iyi iş çıkardın
Jonathan Allan

7

JavaScript (Node.js) , 92 86 83 - 7 = 76 bayt

t=p=>q=>p
f=t(q=>q)
n=p=>p(f)(t)
a=p=>n(p)(f)
o=p=>p(t)
x=p=>p(n)(f())
i=p=>n(p)(t)

Çevrimiçi deneyin! Link, temel test durumlarını içerir. Düzenleme: @tsh sayesinde 6 9 bayt kaydedildi.


1
beri olduğu gibi -7 bu iddia edemez görünüyor t, f, nkullanılır.
tsh,

1
@tsh Puanlama sistemini böyle anlamadım; kullanımdaki isim 1 byte olmasına rağmen tanımdaki ismi açıkça dışlar.
Neil

Eğer (kodunuz tarafından denir fonksiyon adları için bayt indirim talep edemez @Neil t, fve nsenin durumunda).
asgallant

2
@ asgallant no. Daha sonra kullanıldığında ad ve 1 bayt için bayt yoktur. 'T mex i' byte değil, daha sonra kullanıldığında 1 byte. Okunabilirliği artırmak istedim ama şimdi farkına vardım ki tamamen golf oynamaya başladım ve şimdi değiştirmek için çok geç
Ryan Schaefer

@RyanSchaefer bu kural nerede? Daha önce hiç böyle görmemiştim.
asgallant

6

Python 2 , 133 - 6 = 127 94 bayt

exec"t!u;f!v;n!u(f,t);a!u(v,f);o!u(t,v);x!u(n(v),v);i!o(v,n(u))".replace('!','=lambda u,v=0:')

Çevrimiçi deneyin!

Jonathan Allan'ın cevabının arkasındaki sinsi fikri utanmadan çalmak ; hiçbir bayt olsa düşülmez.


Kendi soruma cevap gönderecektim ama buna izin verilip verilmediğinden emin değildim ve bunun onun ruhuna aykırı olduğunu düşünüyorum. Sanırım onun yerine seni yönlendireceğim. Listeleri kullanmak yerine, kendileri için girilen işlevleri ve girişlerini döndürdüğü şekliyle kodu kısaltmak için kullanabiliyor musunuz?
Ryan Schaefer

Cevap evet olsa da Python'da oldukça uzun olacağına bahse girerim.
İlişkisiz Dize

Düzeltilmiş duruyorum
İlişkisiz Dize

@ Mr.Xcoder haklısınız, örnek fonksiyon için yanlış sayıda bayt vardı. İşlevlerin adları için olsa bile 6 bayt kaldırabilirlerdi.
Ryan Schaefer

@Bay. Xcoder: Gözlemlerin başına göre değiştirildi.
Chas Brown

4

J , 67 bayt - 7 = 60

t=.[
f=.]
n=.~
a=.2 :'u v]'
o=.2 :'[u v'
x=.2 :'u~v u'
i=.2 :'v u['

Çevrimiçi deneyin!

Kayda değer:

Yüksek dereceli işlevler J'de işlevsel bir dilden farklı şekilde çalışır. Mevcut 1 veya 2 fiilden yeni bir fiil oluşturmak için, bir zarf (1 durumunda) veya bir kombinasyon (2 durumunda) kullanmanız gerekir.

Sözdizimsel olarak, zarflar fiilden sonra gelir ve kavşaklar aralarında gider. Böylece "değil" bir fiil için fyapmanız f nve "ve" fiiller için fve g, sen f a g.


4

Wolfram Dili (Mathematica) , 61-7 = 54 bayt

t=#&
f=#2&
a=#2~#~f&
o=t~#~#2&
n=f~#~t&
x=n@#~#2~#&
i=#2~#~t&

Çevrimiçi deneyin!

un-golfed: Wikipedia'dan esinlenerek ,

t[x_, y_] := x
f[x_, y_] := y
and[x_, y_] := x[y, f]
or[x_, y_] := x[t, y]
not[x_] := x[f, t]
xor[x_, y_] := y[not[x], x]
imply[x_, y_] := x[y, t]

İşlev tanımlarını ayırmak için yeni satırların gerekli olduğundan emin olun. Ayrıca, tf ve n'ye diğer fonksiyon tanımlarında referans veriyorsunuz, bu sayıları çıkaramazsınız, yani 61-4 = 57.
Jonathan Allan

@JonathanAllan Puanlama talimatlarını tekrar okudum ve yeni satırların sayılması gerektiğini kabul ediyorum, teşekkürler. İkinci bölümünüzle aynı fikirde değilim: isimleri tekrar kullandığımda, onları gerçekten 1-byte isimlerini kullandığımda kapalı olan "o geçidin toplam baytına 1 bayt" olarak sayıyorum. Talimatlarımı okuduğumda, onları orijinal tanımın toplamına karşı bir bayt olarak saymaktan da söz etmiyoruz. Bu yüzden N-7 bayt ile gidiyorum. Ayrıca OP'nin bir başka yorumu şöyle açıklıyor: "Daha sonra kullanıldığında isim için bayt değil ve 1 bayt."
Roman

Başka bir işlevde kullanımın bir bayt maliyeti anlamına gelmesi için "1 bayt sonra" okurum. Bu, diğerlerinin de puanlamalarıyla aynı hizada.
Jonathan Allan

@JonathanAllan Exegesis ile daha az ilgileniyorum ve kod golf ile daha fazla ilgileniyorum 😀
Roman

4

Düşük yük , 56 52 bayt

(~!)(!)((~)~*):((!)~^)*(:^)(~(!)~^(~)~*)(()~(~)~^~*)

Çevrimiçi deneyin! (programın bölümlerini tanımlayan bir testsuite ve metin içerir)

Bu çok düşük seviye bir esolang için şaşırtıcı derecede iyi puanlar. (Kilise rakamları, Church booleans, vb. Bu nedenle Underload'da çok yaygın olarak kullanılır; dilin yerleşik sayıları ve boole'ları yoktur ve bu onları simüle etmenin en kolay yollarından biridir. Boole'ları 0 ve 1 Kilisesi rakamları olarak kodlayın.)

Kafası karışan herkes için: Düşük yük, yeniden kullanılabilir işlevleri tanımlamanıza izin verir, ancak normal şekilde adlandırmanıza izin vermez, yalnızca argüman yığında kayarlar. tanımladıysanız, beş argüman alan ve beşincisini çağıran yeni bir fonksiyon yazmanız gerekir, ardından yetersiz argümanlarla çağırınız, böylece kullanmak için yedek argümanlar arar). Onları çağırmak, varsayılan olarak onları yok eder, ancak aramayı tahribatsız hale getirecek şekilde değiştirebilirsiniz (basit durumlarda, kopyalara aradığınızdan emin olmanız gerekir, çünkü karmaşık durumlar daha yaygındır). yığında yolunuzu alamadım), bu nedenle Underload'ın işlev desteği sorudan ihtiyacımız olan tüm gereksinimleri içeriyor.

açıklama

doğru

(~!)
(  )  Define function:
 ~      Swap arguments
  !     Delete new first argument (original second argument)

Bu oldukça basittir; istemediğimiz argümandan kurtuluyoruz ve istediğimiz argüman sadece orada kalıyor, dönüş değeri olarak hizmet ediyor.

yanlış

(!)
( )   Define function:
 !      Delete first argument

Bu daha basit.

değil

((~)~*)
(     )  Define function:
    ~*     Modify first argument by pre-composing it with:
 (~)         Swap arguments

Bu eğlenceli: not argümanını hiç çağırmıyor, sadece bir fonksiyon kompozisyonu kullanıyor. Bu, Underload'da, verilerinizi hiç denetlemediğiniz, hünerlerini önceden oluşturup yazdıktan sonra işleyiş biçimini değiştirdiğiniz ortak bir numaradır. Bu durumda, çalıştırmadan önce argümanlarını değiştirme fonksiyonunu değiştiririz ki bu, bir Kilise rakamını açıkça olumsuzlar.

ve

:((!)~^)*
 (     )   Define function:
     ~^      Execute its first argument with:
  (!)          false
               {and implicitly, our second argument}
        *  Edit the newly defined function by pre-composing it with:
:            {the most recently defined function}, without destroying it

Soru, fonksiyonların diğer fonksiyonlar açısından tanımlanmasına izin verir. "Ve" sıradakileri tanımlarız, çünkü en yakın zamanda "değil" tanımlanırsa, onu kullanmak daha kolay olur. (Bu bizim puanımızdan çıkarılmaz, çünkü biz hiç "değil" olarak adlandırmıyoruz, ancak tanımı tekrar yazarken baytları kurtarıyor. ancak en son tanımlananlar çok fazla bayta mal olur.)

Buradaki tanım and x y = (not x) false y. Başka bir deyişle, eğer not xöyleyse geri döneriz false; Aksi takdirde geri döneriz y.

veya

(:^)
(  )  Define function:
 :      Copy the first argument
  ^     Execute the copy, with arguments
          {implicitly, the original first argument}
          {and implicitly, our second argument}

@Nitrodon, yorumlardan or x y = x x ynormalde daha kısa or x y = x true yve Underload'da da doğru çıktığını belirtti. Bunun saf bir uygulaması olacaktır (:~^), ancak orijinal ilk argümanı mı yoksa bir kopyasını da mı çalıştırdığımızın bir önemi olmadığını belirterek ek bir bayttan golf oynayabiliriz, sonuç her iki şekilde de aynıdır.

Düşük yük aslında normal anlamda körelmeyi desteklemez, ancak bunun gibi tanımlamalar göründüğü gibi görünmesini sağlar! (İşin püf noktası, tüketilmeyen argümanların etrafta sadık kalmasıdır, bu nedenle çağırdığınız işlev onları kendi argümanları olarak yorumlar.)

ima

(~(!)~^(~)~*)
(           )  Define function:
 ~               Swap arguments
     ~^          Execute the new first (original second) argument, with argument:
  (!)              false
                   {and implicitly, our second argument}
       (~)~*     Run "not" on the result

Burada kullanılan tanım implies x y = not (y false x). Y Bu basitleştirir, doğruysa not falseyani true. Eğer y yanlış ise, bu basitleştirir not x, böylece bize istediğimiz doğruluk tablosunu verir.

Bu durumda, notbu kez referans vermek yerine kodunu yeniden yazarak tekrar kullanıyoruz . Doğrudan (~)~*etrafına parantez olmadan yazılmıştır , bu nedenle tanımlanmak yerine çağrılır.

xor

(()~(~)~^~*)
(          )  Define function:
   ~   ~^       Execute the first argument, with arguments:
    (~)           "swap arguments"
 ()               identity function
         ~*     Precompose the second argument with {the result}

Bu sefer iki argümanımızdan sadece birini değerlendiriyoruz ve ikinci argüman üzerinde ne yazacağımızı belirlemek için kullanıyoruz. Underload, arity ile hızlı ve gevşek oynamanıza izin veriyor, bu yüzden iki iki argüman iki dönüşlü fonksiyon arasında seçim yapmak için ilk argümanı kullanıyoruz; ikisini de ancak tam tersi sırayla döndüren argüman değişkeni ve ikisini de aynı sırayla döndüren kimlik işlevi.

İlk argüman doğruysa, bu nedenle çalıştırmadan önce argümanlarını değiştiren, yani "takas argümanları" ile önceden oluşturulan, yani ikinci argümanın düzenlenmiş bir versiyonunu üretiyoruz not. Yani gerçek bir birinci argüman not, ikinci argümanı döndürdüğümüz anlamına gelir . Öte yandan, sahte bir ilk argüman, kimlik işlevi ile oluşturduğumuz anlamına gelir, yani hiçbir şey yapmazsınız. Sonuç bir uygulamasıdır xor.


or x y = x x ybazı baytları kaydeder or x y = x true y.
Nitrodon

Düşük yük, değişmezleri yeniden kullanılan değişkenlerle değiştirmek söz konusu olduğunda, çoğu zaman karşı sezgiseldir, ancak bu durumda, dönüşüm beklenenden daha az bayttan daha çok bayt tasarrufu sağlar. Gelişme için teşekkürler!
ais523


3

Java 8, skor: 360 358 319 271 233 (240-7) bayt

interface J<O>{O f(O x,O y,J...j);}J t=(x,y,j)->x;J f=(x,y,j)->y;J n=(x,y,j)->j[0].f(y,x);J a=(x,y,j)->j[0].f(j[1].f(x,y),y);J o=(x,y,j)->j[0].f(x,j[1].f(x,y));J x=(x,y,j)->j[0].f(j[1].f(y,x),j[1].f(x,y));J i=(x,y,j)->j[0].f(j[1].f(x,y),x);

Bu başladığımda düşündüğümden çok daha zordu. Özellikle implies. Neyse, işe yarıyor .. Muhtemelen biraz burada ve orada golf olabilir. EDIT: Tamam, işlevleri yeniden kullanmak değil, sadece aynı yaklaşımı kopyalamak, Java için bayt sayısı açısından çok daha ucuzdur. Ve aynı zamanda, herhangi bir işlevi kullanmamak için tam -7 bonus kazanıyorum.

Çevrimiçi deneyin.

Açıklama:

// Create an interface J to create lambdas with 2 Object and 0 or more amount of optional
// (varargs) J lambda-interfaces, which returns an Object:
interface J<O>{O f(O x,O y,J...j);}

// True: with parameters `x` and `y`, always return `x`
J t=(x,y,j)->x;
// False: with parameters `x` and `y`, always return `y`
J f=(x,y,j)->y;

// Not: with parameters `x`, `y`, and `j` (either `t` or `f`), return: j(y, x)
J n=(x,y,j)->j[0].f(y,x);

// And: with parameters `x`, `y`, and two times `j` (either `t` or `f`), return:
//      j1(j2(x,y), y);
J a=(x,y,j)->j[0].f(j[1].f(x,y),y);

// Or: with parameters `x`, `y`, and two times `j` (either `t` or `f`), return:
//     j1(x, j2(x,y))
J o=(x,y,j)->j[0].f(x,j[1].f(x,y));

// Xor: with parameters `x`, `y`, and two times `j` (either `t` or `f`), return:
//      j1(j2(y,x), j2(x,y))
J x=(x,y,j)->j[0].f(j[1].f(y,x),j[1].f(x,y));

// Implies: with parameters `x`, `y`, and two times `j` (either `t` or `f`), return:
//          j1(j2(x,y), x)
J i=(x,y,j)->j[0].f(j[1].f(x,y),x);

2

C ++ 17, 207−49 = 158 195 - 58 = 137 bayt

Çizgiler gereksizdir (ilk ikisinden farklı).

#define A auto
#define D(v,p)A v=[](A x,A y){return p;};
D(true_,x)
D(false_,y)
A not_=[](A f){return f(false_,true_);};
D(and_,x(y,false_))
D(or_,x(true_,y))
D(xor_,x(not_(y),y))
D(implies,x(y,true_))

Çevrimiçi deneyin!

Aşağıdaki gibi iddialarla birim olarak test edilmiştir:

static_assert('L' == true_('L', 'R'));
static_assert('R' == not_(true_)('L', 'R'));
static_assert('L' == and_(true_, true_)('L', 'R'));
static_assert('L' == or_(true_, true_)('L', 'R'));
static_assert('R' == xor_(true_, true_)('L', 'R'));
static_assert('L' == implies(true_, true_)('L', 'R'));

GÜNCELLEME: önceden vardı

A not_=[](A f){return[f](A x,A y){return f(y,x);};};

ancak Roman'ın cevabı kısa sürüme giden yolu işaret etti. Şimdi not_(std::plus<>)kötü biçimlendirilmiş olduğuna, eskiden eşdeğeri olduğuna dikkat edin std::plus<>; fakat std::plus<>"bir Kilise Boole'sini" temsil etmediğinden, bence her iki davranış da kurallara uymuyor.


"İlki dışında" "ilk ikisi dışında" olarak güncellenmeli mi?
LF

@ LF: Kesinlikle doğru. Güncellenmiş. :)
Quuxplusone

2

İleri (gforth) , 133 bayt - 7 = 126 122

: j execute ;
: t drop ;
: f nip ;
: n ['] f ['] t rot j ;
: a dup j ;
: o over j ;
: x 2dup a n -rot o a ;
: m over n -rot a o ;

Çevrimiçi deneyin!

Quuxplusone sayesinde -4 bayt

Öncelikle, makrolar ve değişmezler gibi şeyleri göz önünde bulundurarak bunu çok fazla abarttım, fakat sonra doğru ve yanlış (eğer ilk başta yapmam gerektiği gibi) gibi şeyleri tanımlarsam çok daha kolaylaştığını fark ettim.

Kod açıklaması

\ Helper function to save some bytes
: j        \ define a new word
  execute  \ execute the word at the provided address
;          \ end word definition

\ True
: t        \ define a new word
  drop     \ drop the second argument
;          \ end the word

\ False
: f        \ define a new word
  nip      \ drop the first argument
;          \ end the word

\ Not - The "hardest" one because we have to reference true and false directly
: n        \ define a new word
  ['] f    \ get address of false
  ['] t    \ get the address of true
  rot      \ stick the input boolean back on the top of the stack
  j        \ call the input boolean, which will select the boolean to return
;          \ end the word

\ And 
: a        \ define a new word
  dup      \ duplicate the 2nd input value
  j        \ call the 2nd input on the first and second input
;          \ end the word

\ Or
: o        \ define a new word
  over     \ duplicate the 1st input value
  j        \ call the 1st input on the first and second input
;          \ end the word

\ Xor
: x        \ define a new word
  2dup     \ duplicate both of the inputs
  a n      \ call and, then not the result (nand)
  -rot     \ move the result behind the copied inputs
  o a      \ call or on the original inputs, then call and on the two results
;          \ end the word

\ Implies
: m        \ define a new word
  over     \ duplicate the 1st input value
  n        \ call not on the 1st input value
  -rot     \ move results below inputs
  a o      \ call and on the two inputs, then call or on the two results
;          \ end the word

1
Uzun kelimeyi executeüç defa tekrarlıyorsunuz . Stenoyu tanımlamak : j execute ;size 4 byte kazandırır.
Quuxplusone

1

SKI-calculus + C birleştiricisi, 36 bayt

true=K
false=SK
not=C
and=CC(SK)
or=CIK
xor=C(CIC)I
implies=CCK

Bunu kullanarak test etmek zorunda Aslında sen öncekilerin açısından ek combinators tanımlamanızı sağlar herhangi tercümanın bilmiyorum http://ski.aditsu.net/ istenen combinators örn içinde yapıştırarak CCKK(SK)pqçıkışları qgösteren, Kanlamına gelmez SK.


1

Julia 1.0 , 36 bayt

(b::Bool)(x,y)=b ? x : y;i(x,y)=!x|y

Bu sayılır mı bilmiyorum, aslında sadece yerel Booltürünü çağrılabilir olması için aşırı yüklüyorum, bu yüzden mantık kapılarının çoğunu bedavaya alıyorum. Ne yazık ki, Julia'nın implieskapısı yok, bu yüzden kendi işlevimi yazmak zorunda kaldım.

Çevrimiçi deneyin!


Sanırım gönderiminize aşırı yüklenmiş operatörleri dahil etmeniz gerekiyor ... ama puanlar onları saymıyor, çünkü sadece isimler. Yani bu yeni satırlardan +6 bayt olur . Skorlamanın bu mücadeleyle nasıl çalıştığından emin değilim
Jo King,

Nasıl çalıştığını da% 100 emin değilim, ama kelimenin tam anlamıyla hiçbir şey yapmayan bir kod eklemek zorunda olmak bana bir şey ifade etmiyor.
user3263164

Kod zaten bildirilmiş olsa bile, yine de eklemeniz gerekir, aksi takdirde diğer tüm golf dili gönderimi sıfır bayt olur. Sadece hiçbir şeye atamanıza gerek yok
Jo King


1

C ++ 17, 202−49 = 153 193 - 58 = 135 bayt

Zaten 2-li fonksiyonu olarak neyi sayılarının comment-tartışma esinlenerek burada var Körili önceki C ++ 17 çözeltinin sürümü. Aslında daha kısa çünkü not_diğer tüm fonksiyonları tanımlamak için aynı makroyu kullanabiliriz !

#define D(v,p)auto v=[](auto x){return[=](auto y){return p;};};
D(true_,x)
D(false_,y)
D(not_,x(false_)(true_)(y))
D(and_,x(y)(false_))
D(or_,x(true_)(y))
D(xor_,x(not_(y))(y))
D(implies,x(y)(true_))

Çevrimiçi deneyin!

Bu bir gibi iddialarla test edilir

static_assert('R' == and_(true_)(false_)('L')('R'));
static_assert('L' == or_(true_)(false_)('L')('R'));

Uyarı or_etkin bir şekilde tanımlanır

auto or_=[](auto x){return[=](auto y){return x(true_)(y);};};

or_Daha "özlü" olarak tanımlayabiliriz

auto or_=[](auto x){return x(true_);};

ama bu bize mal olacak çünkü Dartık makroyu kullanamayız .


C ++ büyük küçük harfe duyarlı olduğundan, Trueve Falseyerine true_ve kullanmaya ne dersiniz false_? Ve diğer operatörler için benzer. Bu 12 bayt kurtaracak.
G. Sliepen

@ G.Sliepen: OP'nin puanlama algoritması, tanımlayıcıların etkili bir karakter uzunluğunda olduğunu zaten göz önünde bulunduruyor. Alıntı: "Church'ü kendi dilinizde doğru ve yanlış yapmak için gereken tüm kodun toplam uzunluğu ve xor değil veya xor ve bu fonksiyonun ismi hariç Church gates anlamına gelir . (Örneğin, false = lambda x, y: y Python'da bu baytları daha sonra kodunuzda tekrar kullanarak bu geçidin toplam baytına 1 bayt sayarak tekrar kullanabilirsiniz . "
Quuxplusone

Ah, onu özledim.
G. Sliepen

0

APL (dzaima / APL) , 47 bayt SBCS

Jonah'ın J çözümüne dayanıyor .

trueve falseinfix işlevleridir, notbir sonek operatörüdür ve geri kalanı infix operatörleridir.

true←⊣
false←⊢
and←{⍺(⍶⍹false)⍵}
not←⍨
or←{⍺(true⍶⍹)⍵}
xor←{⍺(⍶not⍹⍶)⍵}
implies←{⍺(⍹⍶true)⍵}

OP'ye göre her satırın sonundan başlayarak her şeyi sayar ve her çağrıyı önceki bir tanımı tek bayt olarak sayar.

Çevrimiçi deneyin!

doğru ve yanlış, sol ve sağ kimlik işlevleridir.

not sadece operand işlevinin argümanlarını değiştirir.

Gerisi karar ağacını uygular:

and sağ işlevi kullanır true işlevinin sonucunu seçmek sonucunu seçmekfalse .

or soldaki işlevi kullanır truetrue ise sağ el işlevinin sonucunu seçmek .

xortrue işlevini ⍶not, aksi halde sol işlevinin sonucunu seçmek için sol işlevinin olumsuzlanan sonucunu seçmek için sağ işlevi kullanır .

impliestrue işlevinin sonucunu seçmek için sol işlevini , sağ işlev işlevinin sonucunu seçmek için kullanır .true


0

Stax , 34 bayt

¿S£↓♣└²≡é♫Jíg░EèΩRΦ♂°┤rà╝¶πï╡^O|Θà

Koşun ve staxlang.xyz de hata ayıklayın!

Bir yığın bloğu yığına iter. Her blok yığında son argümanını bekler, ardından geri kalanı ters sırada izler.

Ambalajsız (41 bayt):

{sd}Y{d}{y{d}a!}X{ya!}{b!}{cx!sa!}{sx!b!}

Her çift { }bir bloktur. İki kayıt X ve Y'yi tutmak için kullandım trueve notböylece daha sonra kolayca erişebildim. Ne yazık ki, falsebasitçe no-op olamazdı, çünkü yığını yığılmış olarak bırakır ve tek bir XOR kasasını karıştırır.

Test paketi, yorum yaptı

false
{sd}    stack:   x y
 s      swap:    y x
  d     discard: y

true
{d}    stack:   x y
 d     discard: x

not
{y{d}a!}    stack:  p
 y{d}       push:   p f t
     a      rotate: f t p
      !     apply:  p(f,t)

and
{ya!}    stack:  p q
 y       push:   p q f
  a      rotate: q f p
   !     apply:  p(q,f)

or
{b!}    stack:  p q
 b      copies: p q p q
  !     apply:  p q(q,p)

xor
{cx!sa!}    stack:  p q
 c          copy:   p q q
  x!        not:    p q nq
    s       swap:   p nq q
     a      rotate: nq q p
      !     apply:  p(nq,q)

implies
{sx!b!}    stack:  p q
 s         swap:   q p
  x!       not:    q np
    b      copies: q np q np
     !     apply:  q np(np,q)

0

Befunge-98 , 105 77 65 bayt

İşlevsiz dillerde "işlev" kavramıyla daha da oynamak ... işte Church booleanlarının Befunge-98 versiyonu!

Befunge-98'in bu sınırlı lehçesinde, bir program, her biri >x = 0 sütununda (Go Right) komutuyla başlayan bir dizi "satır" veya "işlev" den oluşur . Her "fonksiyon", satır numarası ile tanımlanabilir (y-koordinatı). İşlevler, her zaman olduğu gibi Befunge'nin yığını üzerinden girdi alabilir .

Satır 0 özeldir, çünkü (0,0) başlangıç ​​IP'sidir. Satır L'yi çalıştıran bir program yapmak için, çalıştırma sırasında, komut göstergesini (x = L, y = 0) konumuna getiren yönergeleri 0 satırına koymanız yeterlidir.

Büyü 1. satırda gerçekleşir. 1. satır, yürütüldüğünde Lyığından bir sayı çıkar ve satır numarasına atlar.L . (Bu satır daha önce > >>0{{2u2}2}$-073*-\xherhangi bir satıra "mutlak atlayabilen" olmuştu ; ancak fark ettim ki, bu satırın 1. satırda sabitlendiğini bildiğimden, L-1çok daha az kodlu satırlarda "göreceli atlayabiliyoruz" ).

Satır 2, Kilisesi temsil eder FALSE. Yürütüldüğünde, iki sayı çıkar tvef yığından çıkar ve ardından satır numarasına gider f.

Satır 3, Kilisesi temsil eder TRUE. Yürütüldüğünde, iki sayı çıkar tvef yığından çıkar ve ardından satır numarasına gider t.

Church'ü temsil eden 6. satır XORyenilikçidir. Yürütüldüğünde, iki sayı ave byığından çıkar ve ardından ayığın girişiyle aynı çizgide uçar NOT EXEC b. Öyleyse, eğer aKilisesi temsil ederse TRUE, sonucu a NOT EXEC bolacaktır NOT b; ve eğer aKilisesi'ni temsil FALSE, sonucunu a NOT EXEC bolacakEXEC b .


İşte test emniyet kemerli ungolfed versiyonu. 0 satırında, yığını girişinizle ayarlayın. Örneğin, 338anlamına gelir IMPLIES TRUE TRUE. Kapanmanın xtam olarak (x, y) = (0,15) göründüğünden emin olun, aksi takdirde hiçbir şey işe yaramaz! Ayrıca yığın kurulumunuzun ile başladığından emin olunba , böylece program gerçekte bir çıktıyla sonlanır.

Çevrimiçi deneyin!

>  ba 334  0f-1x
> >>1-0a-\x             Line 1: EXEC(x)(...) = goto x
> $^< <            <    Line 2: FALSE(t)(f)(...) = EXEC(f)(...)
> \$^                   Line 3: TRUE(t)(f)(...) = EXEC(t)(...)
> 3\^                   Line 4: OR(x)(y)(...) = EXEC(x)(TRUE)(y)(...)
> 3\2\^                 Line 5: NOT(x)(...) = EXEC(x)(FALSE)(TRUE)(...)
> 1\5\^                 Line 6: XOR(x)(y)(...) = EXEC(x)(NOT)(EXEC)(...)
> 2>24{\1u\1u\03-u}^    Line 7: AND(x)(y)(...) = EXEC(x)(y)(FALSE)(...)
> 3^                    Line 8: IMPLIES(x)(y)(...) = EXEC(x)(y)(TRUE)(...)

> "EURT",,,,@
> "ESLAF",,,,,@

İşte baytları saydığım sürüm.

>>>1-0a-\x
>$^<< }u-30\<
>\$^
>3\^\
>3\2^
>1\5^
>2>24{\1u\1u^
>3^

Bu lehçede bir işlev tanımlamak için isminden hiç bahsetmediğinize dikkat edin; "adı" kaynak konumuna göre belirlenir. Bir işlevi çağırmak için onun "ismini" belirtirsiniz; örneğin, XOR( 6) NOTve EXEC( 5ve 1) terimleriyle tanımlanır . Ancak tüm "fonksiyon isimlerim" zaten temsil etmek için sadece bir bayt kullanıyor. Yani bu çözüm puanlama ayarlaması yapmaz.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.