교회 부울

교회 부울 반환하는 함수 x진실과 y거짓에 대한 어디 x함수의 첫 번째 인수하고 y함수의 두 번째 인수입니다. 논리 기능 and not or xor과 implies논리 연산 을 나타내는 이러한 기능으로 추가 기능을 구성 할 수 있습니다 .

도전

교회 부울 및 구축 and not or xor하고 implies사용자가 선택한 언어로 교회 문을. and or그리고 xor교회 부울을 나타내는 두 가지 기능을 취하고 다른 교회 부울을 나타내는 함수를 반환해야합니다. 마찬가지로, not필요한 기능을 반전시키고 implies게이트가 부울을 수행해야한다는 것은 첫 번째 인수 implies가 두 번째 인수 인 논리를 의미 합니다.

채점

모든 코드의 총 길이는 교회하도록 요구 true하고 false당신의 언어와 and not or xor와 implies교회 함수의 이름을 제외 게이트. (예를 들어, false=lambda x,y:y파이썬에서는 13 바이트입니다). 이 이름은 나중에 게이트에서 총 바이트 수를 1 바이트로 계산하여 코드에서 재사용 할 수 있습니다.

의사 코드 예 :

생성 한 함수는 나중에 코드에서 호출 할 수 있어야합니다.

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

이진 람다 미적분 , 13.875 12.875 바이트 (103 비트)

John Tromp의 바이너리 람다 미적분 언어 (BLC)는 기본적으로 람다 미적분에 대한 효율적인 직렬화 형식입니다. 교회 표기법은 BLC에서 부울을 다루는 "아이디 오 매틱"방식이기 때문에이 작업에 매우 적합합니다.

나는 콤비 네이터에 대해 다음과 같은 람다 함수를 사용 했는데 , 그 중 일부는 Haskell 답변에서 복사하고 골프를 쳤습니다 . 각 사례에 대해 증명 한계가 20 β 감소하는 철저한 검색으로 발견되었습니다. 가장 짧은 가능성이 있습니다.

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

이들은 다음 (이진) BLC 코드 시퀀스로 변환됩니다.

 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

위의 기능은 총계입니다 111 비트 길이 (13.875 바이트) 103 비트 길이 (12.875 바이트)입니다. 프로그램 내에서 사용하기 위해 바이트 경계에 정렬 될 필요가 없으므로 소수 바이트를 계산하는 것이 좋습니다.

BLC에는 변수 / 참조 / 이름이 없기 때문에 결합기간에 코드를 재사용 할 수 없습니다. 모든 것이 복사되어야했습니다. 그럼에도 불구하고 인코딩의 효율성은 상당히 간결한 표현을 만듭니다.

하스켈 , 50-6 = 44 바이트

Khuldraeseth na'Barya 덕분에 -1 바이트, Christian Sievers 덕분에 -1 바이트.

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

온라인으로 사용해보십시오!

파이썬 2 , (-3?)  101  95 바이트

데이비드 비즐리는 마음을 먹고!

Chas Brown 덕분에 -6 (반복 :텍스트로 반복 이동 >. <)

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

온라인으로 사용해보십시오!

나는 할 수 있다고 생각 95 - 3나는 기능을 다시 사용하지 않기 때문에 A, X또는 I,하지만 난 하나를 사용 =(앞에 지정을 위해 lambda). 어쩌면 나는 어떤 것도 제거 할 수 없다. 어쩌면 나는 3.5를 제거 할 수 있습니까?

자바 스크립트 (Node.js) , 92 86 83-7 = 76 바이트

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)

온라인으로 사용해보십시오! 기본 테스트 사례가 포함되어 있습니다. 편집 : @ tsh 덕분에 6 9 바이트가 절약되었습니다.

파이썬 2 , 133-6 = 127 94 바이트

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:')

온라인으로 사용해보십시오!

조나단 앨런 (Jonathan Allan)의 대답 뒤에 숨어있는 비열한 아이디어를 뻔뻔스럽게 훔친다 . 바이트가 공제되지 않았습니다.

J, 67 bytes - 7 = 60

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

Try it online!

Worth noting:

Higher order functions work differently in J than in a functional language. To create a new verb from 1 or 2 existing verbs, you need to use either an adverb (in the case of 1) or a conjunction (in the case of 2).

Syntactically, adverbs come after a verb, and conjunctions go between them. Thus to "not" a verb f you do f n, and to "and" verbs f and g, you f a g.

Wolfram Language (Mathematica), 61-7=54 bytes

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

Try it online!

un-golfed: inspired by Wikipedia,

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]

Underload, 56 52 bytes

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

Try it online! (includes a testsuite and text identifying parts of the program)

This scores surprisingly well for a very low-level esolang. (Church numerals, Church booleans, etc. are very commonly used in Underload for this reason; the language doesn't have numbers and booleans built in, and this is one of the easier ways to simulate them. That said, it's also common to encode booleans as the Church numerals 0 and 1.)

For anyone who's confused: Underload lets you define reusable functions, but doesn't let you name them in the normal way, they just sort of float around on the argument stack (so if you define five functions and then want to call the first one you defined, you need to write a new function that takes five arguments and calls the fifth of them, then call it with insufficiently many arguments so that it looks for spare arguments to use). Calling them destroys them by default but you can modify the call to make it non-destructive (in simple cases, you just need to add a colon to the call, although the complex cases are more common because you need to make sure that the copies on the stack don't get in your way), so Underload's function support has all the requirements we'd need from the question.

Explanation

true

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

이것은 매우 간단합니다. 우리는 원하지 않는 인수와 원하는 인수를 제거하여 반환 값으로 사용합니다.

그릇된

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

이것은 훨씬 더 간단합니다.

아니

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

이것의 재미 : not인수를 전혀 부르지 않고 단지 함수 구성을 사용합니다. 이것은 Underload의 일반적인 트릭입니다. 데이터를 전혀 검사하지 않고 데이터를 사전 및 사후 구성하여 데이터의 기능을 변경하기 만하면됩니다. 이 경우 실행하기 전에 인수를 바꾸도록 함수를 수정하여 교회 숫자를 분명히 무시합니다.

과

:((!)~^)*
 (     )   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

문제는 다른 기능과 관련하여 기능을 정의하는 것을 허용합니다. "최근"이 아닌 "정의"가 정의되었으므로 사용하기가 더 쉽기 때문에 "다음"을 정의합니다. (이것은 우리가 전혀 "이름"이 아니기 때문에 점수에서 차감하지는 않지만 정의를 다시 작성하는 것보다 바이트를 절약합니다. 어떤 함수를 참조하기 때문에 한 함수가 다른 함수를 참조하는 유일한 시간입니다. 그러나 가장 최근에 정의 된 바이트는 너무 많은 비용이 듭니다.)

여기서 정의는 and x y = (not x) false y입니다. 다시 말해, 만약 그렇다면 not x, 우리는 false; 그렇지 않으면을 반환 y합니다.

또는

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

@Nitrodon or x y = x x y은 일반적으로보다 짧은 의견에서 지적 or x y = x true y했으며 Underload에서도 올바른 것으로 나타났습니다. 그것의 순진한 구현은 될 (:~^)것이지만, 우리는 원래의 첫 번째 인수를 실행하든 그것의 사본을 실행하든 상관없이 결과가 동일하다는 것을 지적함으로써 추가 바이트를 골라 낼 수 있습니다.

언더로드는 실제로 일반적인 의미에서 카레를 지원하지 않지만 이와 같은 정의는 마치 커리처럼 보이게합니다! (비소비 된 인수는 그대로 사용되므로 호출하는 함수는 해당 인수를 자체 인수로 해석합니다.)

암시

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

여기에 사용 된 정의는 implies x y = not (y false x)입니다. y가 참이면 not false, 즉으로 단순화됩니다 true. y가 거짓이면, 이것은로 단순화되어 not x원하는 진리표를 우리에게줍니다.

이 경우에는 not코드를 참조하는 대신 코드를 다시 작성 하여 다시 사용 합니다. (~)~*괄호없이 직접 작성 되었으므로 정의되지 않고 호출됩니다.

xor

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

이번에는 두 가지 인수 중 하나만 평가하고이를 사용하여 두 번째 인수에 구성 할 항목을 결정합니다. Underload를 사용하면 arity로 빠르고 느슨하게 연주 할 수 있으므로 첫 번째 인수를 사용하여 두 개의 인수가 두 개인 리턴 함수를 선택합니다. 둘 다 반대 순서로 반환하는 인수 스왑과 둘 다 동일한 순서로 반환하는 identity 함수

첫 번째 인수가 참이면, 실행하기 전에 인수를 교체하는 즉, "swap arguments"로 사전 구성되는 두 번째 인수의 편집 된 버전을 생성합니다 not. 따라서 첫 번째 인수 not는 두 번째 인수를 반환한다는 의미 입니다. 다른 한편으로, 첫 번째 잘못된 주장은 우리가 정체성 기능, 즉 아무것도하지 않는 것을 구성한다는 것을 의미합니다. 결과는의 구현입니다 xor.

루비 , 82-4 = 78 바이트

f,t,a,n,i,o,x=%w(y:y x:x f:y t:f t:y y:t y:n[y]).map{|s|eval"->x,y=0{x==f ?#{s}}"}

온라인으로 사용해보십시오!

자바 8, 점수 : 360 358 319 271 233 (240-7) 바이트

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

내가 처음 시작할 때 생각했던 것보다 달성하기가 까다로웠다. 특히 implies. 어쨌든, 그것은 작동합니다. 아마 여기 저기 골프를 칠 수 있습니다. 편집 : 좋아, 함수를 재사용하지 않고 동일한 접근 방식을 복제하는 것이 Java의 바이트 수 측면에서 훨씬 저렴합니다. 그리고 함수를 사용하지 않으면 -7의 보너스를 얻습니다.

온라인으로 사용해보십시오.

설명:

// 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);

C ++ 17, 207−49 = 158195 − 58 = 137 바이트

줄 바꿈은 불필요합니다 (처음 두 개 제외).

#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_))

온라인으로 사용해보십시오!

다음과 같은 주장으로 단위 테스트를 거쳤습니다.

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'));

업데이트 : 이전에는

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

그러나 로마의 대답 은 더 짧은 버전으로가는 길을 가리 켰습니다. 지금 not_(std::plus<>)은 형식이 잘못 되었다는 점에 주목하십시오 std::plus<>. 그러나 std::plus<>"교회 부울을 대표하지는 않는다"고 생각하기 때문에 두 행동 모두 규칙에 따라 문제가 없다고 생각합니다.

넷째 (gforth) , 133 바이트 - 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 ;

온라인으로 사용해보십시오!

Quuxplusone 덕분에 -4 바이트

처음에는 매크로 및 리터럴과 같은 것을 고려하여 이것을 크게 무시했지만, 내가 처음부터해야했던 것처럼 참과 거짓의 관점에서 정의하면 훨씬 간단해진다는 것을 깨달았습니다.

코드 설명

\ 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

SKI 미적분 + C 결합기, 36 바이트

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

나는이 사용 테스트를했다, 그래서 사실, 당신은 이전의 것들의 측면에서 추가 콤비를 정의 할 수있는 인터프리터 모르는 http://ski.aditsu.net/를 원하는 콤비 예에 붙여 CCKK(SK)pq출력을 q보여주는, K암시하지 않습니다 SK.

줄리아 1.0 , 36 바이트

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

나는 그것이 중요한지 모르겠다. 나는 실제로 네이티브를 오버로드하고있다. Bool 유형을 호출 가능하게 있으므로 대부분의 논리 게이트를 무료로 얻습니다. 불행히도 Julia에게는 implies게이트가 없으므로 내 기능을 작성해야했습니다.

온라인으로 사용해보십시오!

Perl 6, 120 106 102 101 bytes

-1 byte thanks to Jo King

my (\t,\f,&n,&a,&o,&i,&x)={@_[0]},{@_[1]},|<f,t &^v,f t,&^v &^v,t n(&^v),&v>>>.&{"&\{\&^u($_)}".EVAL}

Try it online!

C ++ 17, 202–49 = 153 193 − 58 = 135 bytes

어쨌든 2 진 함수로 간주되는 것에 대한 의견 토론에서 영감을 얻은 이전 C ++ 17 솔루션 의 카레 버전입니다. not_다른 모든 함수를 정의 하기 위해 동일한 매크로를 사용하여 정의 할 수 있기 때문에 실제로 더 짧습니다 !

#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_))

온라인으로 사용해보십시오!

이것은 다음과 같은 주장으로 테스트됩니다.

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

or_효과적으로 정의 된 통지

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

우리는 or_보다 "간결하게" 정의 할 수 있습니다.

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

D더 이상 매크로 를 사용하지 않기 때문에 비용이 많이 듭니다 .

APL (dzaima/APL), 47 bytes^SBCS

Based on Jonah's J solution.

true and false are infix functions, not is a suffix operator, and the rest are infix operators.

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

As per OP, this counts everything from and including ← to the end of each line, and counts each call a previous definition as a single byte.

Try it online!

true and false are the left and right identity functions.

not simply swaps the arguments of its operand function.

The rest implement the decision tree:

and uses the righthand function ⍹ to select the result of the lefthand function ⍶ if true, else the result of the false function.

or uses the lefthand function ⍶ to select the true if true, else the result of the righthand function ⍹.

xor uses the righthand function ⍹ to select the the negated result of the lefthand function ⍶not if true, else the result of the lefthand function.

implies왼손 함수 ⍶를 사용하여 ⍹참인 경우 오른손 함수의 결과를 선택하고 그렇지 않으면 함수의 결과를 선택합니다 true.

Stax , 34 바이트

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

staxlang.xyz에서 실행하고 디버그하십시오!

여러 블록을 스택으로 푸시합니다. 각 블록은 스택 위에 마지막 인수가 있고 나머지 순서는 역순입니다.

풀림 (41 바이트) :

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

각 쌍은 { }블록입니다. 나는 홀드에 두 개의 레지스터 X와 Y를 사용 true하고 not내가 나중에 쉽게 그들을 액세스 할 수 있도록. 운수 나쁘게,false 단순히 스택을 어지럽히고 단일 XOR 케이스를 엉망으로 만들 수 있기 때문에 단순히 운영 체제가 될 수 없었습니다.

테스트 스위트

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)

Befunge-98 , 105 77 65 바이트

함수가없는 언어로 "기능"이라는 개념으로 더 연주하면 ... 여기 교회 부울의 Befunge-98 버전이 있습니다!

이 한정된 Befunge-98의 방언에서 프로그램은 일련의 "라인"또는 "기능"으로 구성되며, 각각은 >x = 0 열의 (오른쪽 이동) 명령으로 시작합니다 . 각 "기능"은 줄 번호 (y 좌표)로 식별 할 수 있습니다. 함수는 평소와 같이 Befunge의 스택을 통해 입력을받을 수 있습니다 .

(0,0)이 시작 IP이므로 행 0은 특별합니다. 라인 L을 실행하는 프로그램을 만들려면 실행될 때 명령 포인터를 (x = L, y = 0)으로 이동시키는 명령을 라인 0에 배치하십시오.

The magic happens on line 1. Line 1, when executed, pops a number L from the stack and jumps to line number L. (This line had previously been > >>0{{2u2}2}$-073*-\x, which can "absolute jump" to any line; but I just realized that since I know this line is pegged to line 1, we can "relative jump" L-1 lines in a heck of a lot less code.)

Line 2 represents Church FALSE. When executed, it pops two numbers t and f from the stack and then flies to line number f.

Line 3 represents Church TRUE. When executed, it pops two numbers t and f from the stack and then flies to line number t.

Church를 대표하는 6 호선 XOR은 혁신적입니다. 실행되면 두 숫자 a를 b스택에서 팝 한 다음 a스택 입력 에 맞춰 날아갑니다 NOT EXEC b. 따라서 aChurch를 대표 한다면 TRUE결과 a NOT EXEC b는 다음과 같습니다 NOT b. 그리고 a교회를 대표 한다면 FALSE그 결과 a NOT EXEC b는 다음과 같습니다 EXEC b.

테스트 하네스가 포함 된 언 골프 버전입니다. 라인 0에서 입력으로 스택을 설정하십시오. 예를 들어, 338의미 IMPLIES TRUE TRUE합니다. 닫힘 x이 정확히 (x, y) = (0,15)에 나타나야합니다. 그렇지 않으면 아무것도 작동하지 않습니다! 또한 ba프로그램이 실제로 일부 출력으로 종료되도록 스택 설정이로 시작해야합니다 .

온라인으로 사용해보십시오!

>  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",,,,,@

바이트 수를 세는 버전이 있습니다.

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

Notice that to define a function in this dialect you don't mention its name at all; its "name" is determined by its source location. To call a function, you do mention its "name"; for example, XOR (6) is defined in terms of NOT and EXEC (5 and 1). But all my "function names" already take only one byte to represent. So this solution gets no scoring adjustments.