2つの入力と1つの出力を備えた16個の論理ゲートすべてをゴルフしましょう!


63

たとえば、ゲートA and Bは2つの入力と1つの出力を持つ論理ゲートです。

以下の理由により、正確に16個あります。

  • 各論理ゲートは2つの入力を受け取ります。これらの入力は、真実または偽であり、4つの可能な入力を提供します
  • 4つの可能な入力のうち、それぞれが真実と偽の出力を持つことができます
  • したがって、2 ^ 4の可能性のある論理ゲートがあり、16です。

あなたの仕事は、それらすべてを個別に実装する16のプログラム/関数を書くことです。

機能/プログラムは独立している必要があります。

これらは、true / falsey値を出力する限り有効です。つまり、およびで生成されたA or Bとしてlambda a,b:a+bも、Pythonでとして実装できます。2A=TrueB=True

スコアは、各機能/プログラムに使用される合計バイト数です。

論理ゲートのリスト

  1. 0,0,0,0(false)
  2. 0,0,0,1(and)
  3. 0,0,1,0(A and not B)
  4. 0,0,1,1(A)
  5. 0,1,0,0(not A and B)
  6. 0,1,0,1(B)
  7. 0,1,1,0(xor)
  8. 0,1,1,1(or)
  9. 1,0,0,0(nor)
  10. 1,0,0,1(xnor)
  11. 1,0,1,0(not B)
  12. 1,0,1,1(B implies A)
  13. 1,1,0,0(not A)
  14. 1,1,0,1(A implies B)
  15. 1,1,1,0(nand)
  16. 1,1,1,1(true)

最初の数字がの出力でA=false, B=falseあり、2番目がの出力でA=false, B=trueあり、3番目がの出力でA=true, B=falseあり、4番目がの出力ですA=true, B=true。

リーダーボード


2
関数/プログラムはコードを共有できます。これは何を意味するのでしょうか?また、プログラムは異なる言語になっている可能性がありますか?
— リン

2
私は説明を紛らわしく感じます:「それぞれが持つことができる4つの可能な入力のうち、真実と偽の出力」。これは8(4 * 2)状態を意味しないのですか?
— DavidC

4
不足している名前はAND-NOTゲート(A AND NOT BおよびB AND NOT A)です。
— メゴ

14
それでまた起こりました。18の答えがあり、ほとんどがシンプルで正しいものですが、どこからともなく質問が「あなたが尋ねているものが不明」になりました。私はあなたが挑戦が好きではない、続けて、別のものを取り、それを閉じないでください!
— edc65

4
@dorukayhan参照:空虚な真実
— -Sp3000

回答:


110

ドミノ、122,000バイトまたは72タイル

バイトカウントは、保存されているファイルのサイズです0.122 MB。

ドミノコンピューティングはインスピレーションでした。Tabletop Simulatorと呼ばれる仮想現実のSteamゲームを介して、これらすべてを対称(およびそれ以上)までテストしました。

詳細

  • I / O
    • 開始 -これは明確にするために含まれており(合計にはカウントされません)、関数を「呼び出し」または「実行」します。[Yellow]が入力された後、「押される」必要があります。
    • 入力A-これはわかりやすくするために含まれており(合計にはカウントされません)、「押されて」aを示し、1押されていない場合は[Green]になります。
    • 入力B-これは明確にするために含まれており(合計にはカウントされません)、「押された」ことを示し、1そうでない場合は[青]を押します。
    • 出力 -これは合計にカウントされます。論理ゲートの結果を宣言するのはドミノ[Black]です。
  • T / F
    • 落ちた出力ドミノは、Trueまたはの結果を表します1
    • スタンディング出力ドミノは、Falseまたはの結果を表します0
  • 押す
    • 入力を行うか、チェーンを開始するには、金属大理石をスポーンします
    • 揚力を設定します 100%
    • 目的のドミノの上に大理石を持ち上げます
    • 大理石を落とす

enter image description here

ゲイツ

  • false、1
    • enter image description here
  • そして、6 4
    • enter image description here
  • BではなくA、4 3
    • enter image description here
  • A、1
    • enter image description here
  • AとBではない、4 3
    • enter image description here
  • B、1
    • enter image description here
  • xor、15 11
    • enter image description here
  • または、1
    • enter image description here
  • また、3 2
    • enter image description here
  • xnor、17 13
    • enter image description here
  • Bではない、2
    • enter image description here
  • BはAを意味します、7 6
    • enter image description here
  • Aではない、2
    • enter image description here
  • AはB、7 6を意味します
    • enter image description here
  • ナンド、16 15
    • enter image description here
    • true、1
    • enter image description here

TL; DR

ドミノにやさしいチャレンジを待ち望んでいたので、これを見たとき、私はそれを渡すことができませんでした。唯一の問題は、明らかに誰もドミノを所有していないということです!それで結局私は負けてDouble Twelveを買いました。このセットには91個のタイルがあり、通常の(長い)「時間遅延」メソッドの代わりに「関数呼び出し」/ドミノを開始するというアイデアがありました。90度ターンのクレジットはdominoesdouble07のチャンネルに属します。

物理的なドミノでこれらを構築した後、メタに基づいて有効なソリューションはデジタルであることが決定されました。そこで、これらのゲートをTabletop Simulatorで再作成しました。悲しいことに、TSと現実はドミノ物理学に同意しません。これには11個のドミノを追加する必要がありましたが、8個も節約できました。全体として、仮想ドミノは構築とテストの点で約150倍効果的です(Ctrl+ Z)。

更新

  • -9 [17-03-13]短縮xor xnor nand
  • [17-03-04]ワークショップファイルへのリンクを追加しました
  • +11 [17-03-03]デジタルxnorおよびxor
  • -8 [17-03-03]デジタル化された全てのゲート(除くxorとxnor)。テーブルトップでのブロックには、2つではなく1つのドミノのみが必要です。
  • [16-09-23]縮小画像
  • -11 [16-09-18] xorをほぼ半分に再度カットします。xnorの@DJMcMayhemとxorのJoeに感謝します。
  • -31 [16-08-31]いくつかの写真を更新し、いくつかのタイルを剃り、xorを半分にカットしました
  • [16-08-28]写真を追加しました

43
+1 PPCGでさらにドミノゴルフが必要
— ベータディケイ


7
ワオ。これは私がこのサイトで見た中で最も独創的な答えの一つです。
— DJMcMayhem

3
xnorを一緒に押しつぶし、5ではなく4を持っている場合、1つのドミノを脱ぐことができるようです。
— DJMcMayhem

2
これを有効な回答にするために時間を割いていただきありがとうございます。ただし、ソースファイルへのリンクを見つけるのは少し難しいです。通常、ヘッダー内のリンクは言語自体につながります。そのため、その1つをスチームゲームにリンクしてから、実際の「ソースファイル」へのリンクを、回答の本文のどこかにある明確にラベル付けされた別のリンクに入れます。
— マーティンエンダー

45

六角形、89バイト

XORソリューションに必要なインスピレーションを提供してくれたFryAmTheEggmanに感謝します。

0000 !@
0001 ?.|@!
0010 #?#!)@
0011 ?!@
0100 +?|@!?
0101 ??!@
0110 ?<@!!<_\~(
0111 ?<<@!
1000 )\!#?@{
1001 (~?/@#!
1010 ??|@!)
1011 \#??!1@
1100 ?(~!@
1101 ?.|@!)
1110 ?$@#)!<
1111 1!@

すべてのプログラム0はfalseおよび1trueに使用します。

オンラインでお試しください!これはテストスイートではありません。さまざまなプログラムや入力を自分でコピーする必要があります。

上記の解決策は、2バイト以内の最適化です(真実/偽の解釈を緩和しない限り)。サイドレングス2に適合するすべてのプログラム、つまり最大7バイト(完全にすべてのプログラムではない-すべての有効なプログラムが何を必要とし、何が有効なプログラムが持つことができます)。この検索で​​は、16の可能なゲートのうち15のソリューションが見つかりました。多くの場合、1つだけではありません。このペーストビンにはすべての代替ソリューションのリストがあり、同等の動作でグループ化しています。上に示したものは、最も単純なソリューションまたは最も興味深いソリューションのいずれかであるため選択しました。明日、それらの説明を追加します。

16番目のゲートについては、XORは明らかに7バイトで実装できない唯一のゲートです。残念ながら、現在使用しているコードでは、大規模なプログラムに対するブルートフォース検索は実行できません。そのため、XORは手書きで書かなければなりませんでした。私がこれまでに発見した最短のものは、上記の10バイトのプログラムです。これは、FryAmTheEggmanによる失敗した(ただし非常に近い)試みに基づいています。8バイトまたは9バイトのソリューションが存在する可能性がありますが、それ以外はすべてのソリューションが実際に最適である必要があります。

説明

警告:テキストの壁。これらの高度に圧縮されたHexagonyプログラムが実際にどのように機能するかに興味を持っている人は、偶然に、それぞれの説明を以下に含めました。説明を合理的に短くするために、複数の最適なプログラムが存在する場合、各ゲートに最も簡単なソリューションを選択しようとしました。しかし、それらのいくつかはまだ心を揺さぶるので、彼らはもう少し精巧に値すると思いました。

0000:偽

この図は必要ないと思う:

 ! @
. . .
 . .

メモリグリッド全体がゼロに初期化されるため、!単純にゼロを出力し@てプログラムを終了します。

これも唯一の2バイトソリューションです。

0001:そして

 ? .
| @ !
 . .

これは基本的に短絡を実装します。以下の灰色の図は、プログラムの開始を示しています。最初の入力が読み取られ?、命令ポインター(IP)が|ミラーが反映する左隅に回り込みます。これで、コーナーは条件として機能し、最初の入力の値に応じて2つの異なる実行パスがあります。赤の図は、の制御フローA = 0と緑の図を示していA = 1ます。

i i i

ご覧のとおり、Aisの場合0、それを単に出力して終了します(すべて.がノーオペレーションであることを思い出してください)。しかし、Aがの1場合、IPは最初の行を再度走査し、B代わりにそれを読み取り、印刷します。

合計で、このゲートには16個の5バイトソリューションがあります。そのうちの14個は基本的に上記と同じで、実質的に何もしないコマンドの>代わりに使用するか、コマンドで|置き換える.か?、2番目の位置に配置します。

?.|@!    .?|@!    ?=|@!    =?|@!    ?_|@!    _?|@!    ?0|@!
?.>@!    .?>@!    ?=>@!    =?>@!    ?_>@!    _?>@!    ?0>@!

そして、他に2つのソリューションがあります(これらは互いに同等です)。これらも同じショートサーキットロジックを実装しますが、実行パスは少しクレイジーです(そして読者への演習として残しておきます):

?<!@|
?<!@<

0010:BではなくA

 # ?
# ! )
 @ .

これは、短絡の形式も実装しますが#、制御フローを使用するため、はるかに注意が必要です。#条件付きIPスイッチです。Hexagonyには、のラベルが付いた6つのIPが実際に付属し0ています5。これらのIP は、グリッドの6つのコーナーで始まり、時計回りのエッジに沿ってポイントします(プログラムは常にIPで始まります0)。ときに#遭遇すると、電流値はモジュロを取られ6、制御フローは、対応するIPに続きます。この機能を追加した狂気のフィット感がわからないが、確かにいくつかの驚くべきプログラム(このような)を可能にします。

3つのケースを区別します。の場合A = 0、プログラムはかなり単純です。これは、IPスイッチングが発生しないよう0に値が常に検出されるためです#。

i

#何もせず、?読み取りA(つまりも何もせず)、#まだ何もせず、を!出力し0、)それをインクリメントします(これは重要です。そうでない場合、IPは3行目にジャンプしません)、@プログラムを終了します。簡単です。ケースを考えてみましょう(A, B) = (1, 0):

i

赤いパスはまだIP 0に対応しており、IPに緑のパスを追加しました1。?読み取り後A(1今回)、#右上隅から開始するIPに切り替わります。つまり、?読むことができますB(0)。今)、それを増加させて1、#左上隅が何もしないようにし、IPのままにします1。を!印刷し1、IPが左の対角線の周りにラップします。#それでも何もせず@、プログラムを終了します。

最後に、両方の入力が本当に奇妙な場合1:

i

今回は、2番目の入力もで1あり、)それをにインクリメントし2ます。つまり、#左上隅にあるIPに別の IPスイッチが発生し2、青色で示されます。そのパスでは、まずそれをさらに増やして3(それは無関係ですが)?、3回目に渡します。EOFにヒットしたため(入力が使い果たされたため)、を?返し0、それを!出力して、@プログラムを終了します。

特に、これはこのゲートの唯一の6バイトソリューションです。

0011:A

 ? !
@ . .
 . .

これは、ダイアグラムを必要としないほど単純です:?読み取りA、!印刷、@終了します。

これは、このゲートの唯一の3バイトソリューションです。(原則として、実行することも可能です,;@が、検索にはが含ま;れていませんでした。なぜなら!、このタスクのためにバイトを節約できるとは思わないからです。)

0100:BではなくA

 + ?
| @ !
 ? .

これは、その「兄弟」よりもずっと単純です0010。制御フローは0001(And)について上で見たものと実際には同じです。の場合A = 0、IPは下の行を走査し、B終了する前にそれを読み取って印刷します。もしA = 1その後、IPも読んで、もう一度最初の行を横断Bが、+2つの未使用のメモリはそれがないすべては、現在の値をリセットであるので、エッジ追加し0、そのので、!必ずプリントを0。

これには非常に多くの6バイトの代替があります(合計42)。まず、上記と同等のソリューションがたくさんあります。私たちは再び間で自由に選ぶことができる|と>、そして+私たちの空の端を与える他のコマンドに置き換えることができます。

"?|@!?    &?|@!?    '?|@!?    *?|@!?    +?|@!?    -?|@!?    ^?|@!?    {?|@!?    }?|@!?
"?>@!?    &?>@!?    '?>@!?    *?>@!?    +?>@!?    -?>@!?    ^?>@!?    {?>@!?    }?>@!?

さらに、の]代わりに使用することもできます?。]次のIPに移動します(つまりIPを選択します1)。そのため、代わりにこのブランチ?は右上隅で再利用します。それは別の18のソリューションを提供します:

"?|@!]    &?|@!]    '?|@!]    *?|@!]    +?|@!]    -?|@!]    ^?|@!]    {?|@!]    }?|@!]
"?>@!]    &?>@!]    '?>@!]    *?>@!]    +?>@!]    -?>@!]    ^?>@!]    {?>@!]    }?>@!]

そして、さまざまなレベルの狂気ですべてが異なる方法で動作する他の6つのソリューションがあります:

/[<@!?    ?(#!@]    ?(#>@!    ?/@#/!    [<<@!?    [@$\!?

0101:B

 ? ?
! @ .
 . .

Woohoo、もう1つの単純なもの:read A、read B、print B、terminate。ただし、実際にはこれに代わるものがあります。以来A唯一の単一の文字で、我々はまた、でそれを読むことができます,:

,?!@

また、単一?のミラーを使用し、ミラーを使用して2回実行するオプションもあります。

?|@!    ?>@!

0110:Xor

  ? < @
 ! ! < _
\ ~ ( . .
 . . . .
  . . .

上で言ったように、これはサイドレングス2に収まらない唯一のゲートなので、これはFryAmTheEggmanと私による手書きのソリューションであり、最適ではない可能性が十分にあります。区別するための2つのケースがあります。場合はA = 0、制御フローは、(その場合には、我々は唯一の印刷する必要があるので、非常に簡単ですB):

i

赤い道から始めます。?読み取りA、<ゼロを左に偏向するブランチです。IPは下に折り返され、_別のミラーになります。IPが角に達すると、左上に折り返され、青いパスを進みます。?読み取りB、!印刷します。今、(それをデクリメントします。これは、値が正でないことを保証するために重要です(どちらか0または-1現在)。これにより、IPが右端に折り返され@、プログラムが終了します。

A = 1物事が少し複雑になるとき。その場合not B、それ自体はそれほど難しくはありませんが、実行パスは少しトリッピーです。

i

今回<は、IPを右に偏向し、次に<ミラーとしてのみ機能します。そのため、IPは同じパスを逆にたどり、再びB遭遇?したときに読み取ります。IPは右隅に折り返され、緑色のパスを継続します。次に(~「減少、-1の乗算」に遭遇します。これはスワップを0行い1、したがって計算しnot Bます。\は単なる鏡であり!、望ましい結果を出力します。次に、?別の数値を返そうとしますが、ゼロを返します。これで、IPは青いパスの左下隅に続きます。(減少、<反映、(再び減少します。そのため、IPがコーナーに達する現在の値は負になります。右下の対角線を横切って移動し、最後にヒット@してプログラムを終了します。

0111: または

 ? <
< @ !
 . .

より短絡。

i i

ここでは、A = 0ケース(赤いパス)が少しわかりにくいです。IPは左に偏向され、左下隅に折り返され、すぐにに反映され、読み取りに<戻ります。次に、リグコーナーにラップし、印刷して終了します。?BB!

A = 1ケース(グリーンパス)は、ビット簡単です。<ブランチは、IPは、右偏向ので、我々は単に印刷し!、左上に戻ってラップし、で終了します@。

他の5バイトソリューションは1つだけです。

\>?@!

基本的には同じように機能しますが、実際の実行パスはまったく異なり、分岐の代わりにコーナーを使用します <ます。

1000:いいえ

 ) \
! # ?
 @ {

これは、この検索で​​見つかった私のお気に入りのプログラムかもしれません。最もクールなことは、この実装がnor実際に最大5つの入力に対して機能することです。これを説明するために、メモリモデルの詳細について少し説明する必要があります。したがって、Hexagonyのメモリモデルはクイックリフレッシャーとして、各エッジが整数値(最初はすべてゼロ)を保持する個別の六角形グリッドです。エッジとそのエッジに沿った方向を示すメモリポインター(MP)があります(現在のエッジの前後に2つの隣接するエッジがあり、意味のある左右の隣人があるように)。以下に、使用するエッジの図を示します。MPは赤で示されています。

i

まず、両方の入力が0次の場合を考えてみましょう。

i

我々は、単にエッジ増分グレー経路、上で起動Aをする1ように#IPにスイッチ1ブルーパスで、右上から開始します。\そこでは何もせず?、入力を読み取ります。)入力をインクリメントする左上隅に折り返します。今限り、入力がゼロであるように、これはにつながる1ことはので、#何もしません。次に{、MPを左に移動します。つまり、最初の反復でAからBに移動します。このエッジにはまだ初期ゼロがあるため、IPは右上隅と新しいメモリエッジにラップバックします。したがって、このループは継続します。?、ゼロ読み取る、MPをBから六角形の周りに移動ます。CのDなど。?入力であるかEOFであるため、ゼロを返すかどうかは関係ありません。

このループを6回繰り返した後、Aに{戻ります。今回は、エッジは最初の反復からの値をすでに保持しているため、IPは左隅に折り返され、代わりに緑のパスに進みます。単にそれを印刷してプログラムを終了します。1!1@

では、入力のいずれかが1どうなるのでしょうか?

i

次に、ある時点でそれを?読み取り、それを1に増やします。つまり、IPが再び切り替えられ、赤いパスの右隅に進みます。別の入力(ある場合)を読み取ります。これは実際には重要ではなく、1つのエッジをさらに移動します。これは未使用のエッジである必要があるため、最大5つの入力に対して機能します。IPは右上に折り返されてすぐに反映され、左隅に折り返されます。未使用のエッジにを出力し、IPに切り替えます。そのIPはまだ南西に向かって(灰色のパス)待機していたので、すぐにヒットしてプログラムを終了します。1)2#?{!0#0#@

このゲートには合計で7つの7バイトソリューションがあります。それらのうち5つはこれと同じように動作し、他のコマンドを使用して未使用のエッジに移動します(別の六角形の周りや別の方向に移動できます)。

)\!#?@"    )\!#?@'    )\!#?@^    )\!#?@{    )\!#?@}

また、2つの入力のみで機能するソリューションの別のクラスが1つありますが、その実行パスは実際にはさらに厄介です。

?]!|<)@    ?]!|<1@

1001:平等

 ( ~
? / @
 # !

また、これにより、条件付きIP選択が非常に巧妙に使用されます。とを再度区別する必要がA = 0ありA = 1ます。最初のケースでは印刷したいのですnot Bが、2番目では印刷したいですB。以下のためにA = 0我々はまたのための2つのケースを区別するB。始めましょうA = B = 0:

i

灰色のパスから始めます。(~無視することができ、IPは(まだ灰色のパス上)左の隅にラップし、読み込みAに?。(それを減らすので-1、左下隅にIPラップを取得します。さっきも言ったように、IPを選択#する6前にモジュロの値を取るので、-1実際にはIPを取得します5。これは、赤いパスの左隅から始まります。?を読み取りB、(同様にデクリメントして、再び5ヒット#したときにIPのままになるようにします。~を無効に-1して、IPが右下に折り返され、印刷し1て終了するようにします。

i

あれば今Bある1代わりに、現在の値になります0私たちはヒット時に#二時間を私たちはIPに切り替え、0(緑のパスになりました)。?3回目にヒットし、yield 0を!出力し、@終了します。

i

最後に、ケースどこA = 1。今回#は、最初にヒットしたときに現在の値がすでにゼロになっているため、最初はIP 5に切り替わりません。すぐに緑の道を進みます。?今はゼロを与えるだけでBなく、代わりに戻ります。!それを印刷して、@再び終了します。

合計で、このゲートには3つの7バイトソリューションがあります。他の2つの機能は非常に異なっており(お互いからでも)、をさらに奇妙に使用し#ます。特に、1つ以上の値を,(整数の代わりに文字コードを読み取る)で読み取り、その値をモジュロ6で使用してIPを選択します。それはかなりナッツです。

),)#?@!

?~#,~!@

1010:Bではない

 ? ?
| @ !
 ) .

これはかなり簡単です。実行パスは、and以前からすでに知っている水平ブランチです。??読んAですぐにB。で反射し|て分岐した後B = 0、下の分岐を実行し)ます。ここで値がインクリメントされ、その値に1印刷され!ます。上部ブランチ(場合にB = 1)?単にエッジをリセットし0、次にによっても印刷され!ます。

このゲートには8つの6バイトプログラムがあります。それらの4つはほとんど同じで、>代わりに、|または1代わりに)(または両方)を使用します。

??>@!)    ??>@!1    ??|@!)    ??|@!1

2つ?は、ミラーのために2回使用されるシングルを使用します。否定はxor、(~またはで行ったように発生します~)。

?>!)~@    ?>!~(@

最後に、2つのソリューションは条件付きIPスイッチを使用します。なぜなら、複雑なものも機能するのであれば、なぜ簡単な方法を使用するのかという理由からです。

??#)!@    ??#1!@

1011:BはAを意味します

 \ #
? ? !
 1 @

これはかなり複雑なIPスイッチングを使用します。A = 1今回はより簡単なので、今回のケースから始めましょう。

enter image description here

私たちは、読み込みグレー路上に開始Aし?、その後ヒット#。これAは1IP 1(緑のパス)に切り替わるためです。!すぐに、IPは左上に折り返されることを、読み込み出力しますB(不必要に)して終了します。

ときにA = 0、物事はもう少し面白く。最初に考えてみましょうA = B = 0:

enter image description here

今回#は何もせず、IPのままです0(その時点から赤いパス)。?読み取りB、1それを1。左上隅に折り返した後、#再びヒットしたので、結局緑のパスに行き、印刷します1前に以前のようにします。

最後に(A, B) = (0, 1)、これはfalseケースです。

enter image description here

わかりやすくするために最初の灰色のパスを削除しましたが、プログラムは同じ方法で始まり、以前と同じように赤いパスになります。したがって、今回は2番目?が戻ります1。今、私たちはに遭遇し1ます。この時点で、Hexagonyで実際に数字が何をするかを理解することが重要です(これまでゼロでのみ使用していました)。これは通常、10進数をソースコードに逐語的に書き込むために使用されますが、B = 1実際にはvalueにマッピングされます11。したがって、を押すと#、これはモジュロ6で与えられて与えられるため5、5(1以前のようにではなく)IPに切り替えて、青いパスに進みます。ヒッティング?3回目はゼロを返すため、IPはプログラムが終了する右下に折り返されます。!出力し、別の2つの後に?

これには7バイトのソリューションが4つあり、それらはすべて異なる動作をします。

#)/!?@$    <!?_@#1    \#??!1@    |/)#?@!

1100:Aではない

 ? (
~ ! @
 . .

ただ、単純な線形1:読んAで?、と否定(~して印刷する、!で終了し、@。

代替ソリューションが1つありますが、~)代わりにそれを無効にします。

?~)!@

1101:AはBを意味します

 ? .
| @ !
 ) .

これは、先ほど説明した反対の意味合いよりもはるかに単純です。これも、のような水平分岐プログラムの1つですand。場合Aで0、それは単ににインクリメントされます1一番下の枝の上に印刷します。それ以外の場合は、最上位のブランチが再度実行され、代わりにそれが?読み取られBて!出力されます。

ありますトン、主に起因する効果的な空命令を自由に選択し、ここでの選択肢の(合計で66社のソリューションは)、。スタートのために我々は我々ができた全て同じ方法で、上記の溶液を変えることができand、我々はまたの間に選択することができます)と1:

?.|@!)    .?|@!)    ?=|@!)    =?|@!)    ?_|@!)    _?|@!)    ?0|@!)
?.|@!1    .?|@!1    ?=|@!1    =?|@!1    ?_|@!1    _?|@!1    ?0|@!1
?.>@!)    .?>@!)    ?=>@!)    =?>@!)    ?_>@!)    _?>@!)    ?0>@!)
?.>@!1    .?>@!1    ?=>@!1    =?>@!1    ?_>@!1    _?>@!1    ?0>@!1

そして、最初のコマンドは、ほぼ任意に選ぶことができ、条件付きIPの選択を、使用して異なるバージョンがあります、との間の選択もあります)し、1それらのオプションのいくつかについては:

"?#1!@    &?#1!@    '?#1!@    )?#1!@    *?#1!@    +?#1!@    -?#1!@    .?#1!@    
0?#1!@    1?#1!@    2?#1!@    3?#1!@    4?#1!@    5?#1!@    6?#1!@    7?#1!@    
8?#1!@    9?#1!@    =?#1!@    ^?#1!@    _?#1!@    {?#1!@    }?#1!@

"?#)!@    &?#)!@    '?#)!@              *?#)!@    +?#)!@    -?#)!@    
0?#)!@              2?#)!@              4?#)!@              6?#)!@    
8?#)!@                        ^?#)!@    _?#)!@    {?#)!@    }?#)!@

1110:ナンド

 ? $
@ # )
 ! <

最後の複雑なもの。まだ読んでいるのなら、もうほとんど完成です。:) A = 0最初に見てみましょう:

enter image description here

?読み取りA、ヒットし$ます。これはジャンプコマンド(Befungeのような#)で、次の命令をスキップして、で終了しないようにし@ます。代わりに、IPはに続き#ます。ただし、Ais 0なので、これは何もしません。)をインクリメントし1て、IP 1が印刷される一番下のパスに続くようにします。<それは左隅にラップし、プログラムが終了右にIPを偏向させます。

次に、入力が(A, B) = (1, 0)この状況になったとき:

enter image description here

それは本質的にことを除いて、前と同じだ#、我々はIPに切り替える1(緑道)が、以来Bで0、我々はIPに切り替える0我々は打ったとき#、それは印刷し二回目(今ブルーパス)、1以前のようにします。

最後に、A = B = 1ケース:

enter image description here

今回は#、2回目に、現在の値がまだである1ため、IPを再度変更することはありません。<それを反映して、我々はヒット三度目は、?私たちは、ゼロを取得します。したがって、IPは左下に!折り返され、ゼロが出力されてプログラムが終了します。

これには、合計で9つの7バイトソリューションがあります。最初の選択肢は、次の代わりに単に使用し1ます):

?$@#1!<

次に、進行中のIPスイッチングの量に頭を悩ます2つのソリューションがあります。

)?#_[!@    1?#_[!@

これらは実際に私の心を吹き飛ばしました。興味深い部分は、IPスイッチングを遅延条件として使用できることです。言語のIP切り替えルールは、切り替えが発生する前に現在のIPが別のステップを実行するようなものです。そのステップがたまたまコーナーを通過した場合、現在の値は、IPに戻った場合にIPを継続するブランチを決定します。まさにこれは入力がのときに起こりますA = B = 1。これは私が言語をどのように設計したかと一致していますが、仕様のこの含意に気付いたことはありませんでした。

次に、IPスイッチングの量がさらに悪い3番目のソリューションがあります(ただし、その遅延条件付き効果は使用されません)。

>?1]#!@

そして、別のものがあります:

?$@#)!<

そして、これらの4つの同等のソリューションがあります。これらのソリューションは、無条件のIPスイッチングを使用し、代わりにブランチとコーナーを介してすべてのロジックを実装します。

]<?<@!)    ]<?<@!1    ]|?<@!)    ]|?<@!1

1111:本当

 1 !
@ . .
 . .

あなたは最後にシンプルなものを手に入れました:エッジを1に設定し、で印刷し!、で終了し@ます。:)

もちろん、1つの選択肢があります。

)!@

いつものように、すべての制御フロー図はTimwiのHexagonyColorerで作成され、メモリ図は彼のEsotericIDEで作成されました。


9
Aaaaaand the tl; dr賞は...に行く(明らかに冗談、素晴らしい答えと非常によく書かれた、+ 1)
— Bassdrop Cumberwubwubwub

4
これがチャットでもうアクティブでない理由ですか?
— オプティマイザー

ちょっと遅れましたが、ブルートフォースコードへのリンクを追加できますか?
— nedla2004

@ nedla2004私は通常それらを保持しませんが、それは常にこのスクリプトの修正版です。
— マーティンエンダー

40

APL、 22 20 18バイト

真と偽のエントリは完全なプログラムであり、他の14個は関数です。(アダムに感謝します。)

0000 false              0 (complete program)
0001 p and q            ∧
0010 p and not q        >
0011 p                  ⊣
0100 not p and q        <
0101 q                  ⊢
0110 xor                ≠
0111 p or q             ∨
1000 not p and not q    ⍱
1001 eq                 =
1010 not q              ~⊢
1011 p or not q         ≥
1100 not p              ~⊣
1101 not p or q         ≤
1110 not p or not q     ⍲
1111 true               1 (complete program)

ここで試してみてください。


1
+1頂点の素敵な使用!0000と1111をtrad-fns 0とにすると、2バイト節約できます1。
— アダム

tfnsを許可することには同意がありますが、最初の行はカウントしません。これは、プログラム名= filenameのプログラムコンテナーとしてファイルを使用する言語でファイル名をカウントしないことに対応します。
— アダム


10
ゼリー:19バイト。これ:18バイト。これは、デニスを追い抜いたということではありませんか?そのために+1。
— NoOneIsHere

29

終盤のチェス/中級チェスプレーヤー、70個

そのドミノの答えに触発されて、私は別のゲームがこの名誉を持つべきだと決めました。

ピースの動きについていくつかのルールを守ったことに注意してください。あらゆる状況で最適な動きを勉強する気はないので、白人の動きのルールは単純です:チェックを外して、そのターンで彼ができる最高のランキングの駒をキャプチャし、できるだけ少ない素材を失い、ポーンを止めます優先順位の昇格から。移動できるスペースが2つあり、同じ好意で移動できる場合は、どちらかに移動できます(したがって、複数の正方形に移動できる場合、それらは同じ色になります)。攻撃しているピースが失われたピースよりも高い値である場合、白はキャプチャされても何かでキャプチャすることに注意してください。値は次のとおりです。pawn<knight=bishop<rook<queen

入力は、ルークが存在するかどうかです。ルークは重要な場合にのみ名前AとBでラベル付けされることに注意してください:ルークが切り替えられたときにゲートが同じように動作する場合、それらはラベル付けされません。

出力は、正方形の白いキングの色で終了します:White = 1、black = 0

画像の前に、貧しい画像について謝罪したい。カメラをしっかりと保持するのはあまり得意ではありません。

False、4:

False

そして、4:

enter image description here

BではなくA、5(これを3つに減らすことができると思いますが、現在ボードを持っていません):

enter image description here

A、4:

enter image description here

AとB、5ではありません(これを3つに減らすことができると思いますが、今はボードを持っていません):

enter image description here

B、4:

enter image description here

Xor、5(4にする方法は知っていますが、現在ボードを持っていません):

enter image description here

または、4:

enter image description here

また、4:

enter image description here

Xnor、5(4にする方法は知っていますが、現在ボードを持っていません):

enter image description here

Bではない、4:

enter image description here

BはA、5を意味します(これを3つに減らすことができると思いますが、現在ボードを持っていません)。

enter image description here

Aではない、4:

enter image description here

AはB、5を意味します(これを3つに減らすことができると思いますが、現在ボードを持っていません)。

enter image description here

ナンド、4:

enter image description here

本当の4:

enter image description here


1
うわー、チェスでのプログラミングが可能だとは思いもしませんでした...これらのいくつかの実際のビデオ/シミュレーションを投稿できますか?
— ベータ崩壊

2
うーん、私は現在、チェス盤にアクセスできません。おそらく、AはB / Bがa / etcを意味することを意味すると言うでしょう。私はおそらくこれらの2つのより良い説明を追加する必要があります
— 破壊可能なレモン

インスピレーションを与えてくれてうれしい:D私が正しく理解しているなら、ボードとピースの位置はプログラムと同等です。ルークは入力なので、正しい色である限り任意の正方形に配置できますか?
— NonlinearFruit

いいえ、ルークの入力は、ルークがボードに存在するかどうかです。対称ゲートでない場合(異なるaおよびbが重要な場合)、aおよびbとラベル付けされます。また、2枚のゴルフをオフにする方法に気づきましたが、現在ボードを持っていません。ペイントブラシを使用する必要があります:)
— 破壊可能なレモン

「And」の場合、右のルークを削除すると、王様が下に(白に)移動するのを止めるのは何ですか?
— ネイサンメリル

27

ゼリー、19 バイト

0 0 0 0 ¤  1 byte  Empty niladic chain. Returns default argument 0.
0 0 0 1 &  1 byte  Bitwise AND.
0 0 1 0 >  1 byte  Greater than.
0 0 1 1    0 bytes Empty link. Returns left argument.
0 1 0 0 <  1 byte  Less than.
0 1 0 1 ị  1 byte  At-index (x,y -> [y][x]). Returns right argument.
0 1 1 0 ^  1 byte  Bitwise XOR.
0 1 1 1 |  1 byte  Bitwise OR.
1 0 0 0 |¬ 2 byte  Logical NOT of bitwise OR.
1 0 0 1 =  1 byte  Equals.
1 0 1 0 ¬} 2 bytes Logical NOT of right argument.
1 0 1 1 *  1 byte  Exponentiation.
1 1 0 0 ¬  1 byte  Logical NOT of left argument.
1 1 0 1 >¬ 2 bytes Logical NOT of greater than.
1 1 1 0 &¬ 2 bytes Logical NOT of bitwise AND.
1 1 1 1 !  1 byte  Factorial.

オンラインでお試しください!


13
Factorialを使用して0または1を1に変換するのが大好きです。-
— ニール

JellyはUTF-8ですか?はい、その後場合¤と¬2つのバイトではなく、1です
— Viに。

1
@Vi。JellyはUTF-8をサポートしますが、それぞれが1バイトとして認識する256文字のそれぞれをエンコードするカスタムコードページもサポートします。ヘッダーのバイトリンクはそれを指します。
— デニス

0 0 1 0 > 1 byte Greater than.2番目の入力が負の場合、これは失敗しませんか?
— MD XF

@MFXF私たちがサポートする真実と偽の価値を選択できます。
— デニス

24

NAND論理ゲート— 31ゲート

NAND ゲートに関する最初の 一連 の 質問の作成者として、これらのゲートを使用して別の論理ゲートの問題を解決する機会を逃すことはできませんでした。

enter image description here

これらの図のそれぞれで、上の入力はAで、下の入力はBです。


5
@xnor彼の論理ゲートはDを作るために、ほとんどのNANDゲートを必要とするものであることを知ってうれしくされる可能性があります:
— ジョー・Z.

少なくともLogisimを​​使用してコードをフォーマットできますか?
— mbomb007

1
@ mbomb007後で編集します。私はLogisimの経験があまりないので、しばらく時間がかかるかもしれません。
— ジョーZ.

3
しかし、私は手書きの方が好きです。
— リーキー修道女

1
別の方法としては、NORゲートに切り替えて...レッドストーンを使用して、それをフォーマットすることができ
— jimmy23013

22

ビット単位のサイクリックタグ、118ビット= 14.75バイト

Bitwise Cyclic Tagは、おそらくこれまでに考案された最も単純なチューリング完全言語です。プログラムテープとデータテープがあり、両方ともビットのリストで構成されています。プログラムテープは、次のようにデータテープが空になるまで周期的に解釈されます。

  • 0:データテープから最初のビットを削除します。
  • 1x:データテープの最初のビットが1の場合、データテープにビットxを追加します。

1の後に2つの入力ビットが続くデータテープを初期化し(データテープが完全に0で構成されている場合は1を作成する方法がないため、1が必要です)、最後に削除されたデータビットをゲートの出力として使用します。

  • 0,0,0,0(false):001
  • 0,0,0,1(and):1001001
  • 0,0,1,0(A and not B):0110100
  • 0,0,1,1(A):1001
  • 0,1,0,0(not A and B):0100
  • 0,1,0,1(B):0
  • 0,1,1,0(xor):0110110010
  • 0,1,1,1(or):0110
  • 1,0,0,0(nor):1101001000
  • 1,0,0,1(xnor):110101001100
  • 1,0,1,0(not B):1100100
  • 1,0,1,1(B implies A):110101101000
  • 1,1,0,0(not A):11010000
  • 1,1,0,1(A implies B):11010011001
  • 1,1,1,0(nand):10110100100010
  • 1,1,1,1(true):1100

おめでとうございます!
— リーキー修道女

後続1はfalse必須ですか?
— 電卓

@CalculatorFelineはい、0最後に削除できるようにテープに追加する必要があります。
— アンダースカセオルグ

あ。それ+ラッピングを忘れました。賢い!
— 電卓

20

Python 2、137バイト

[].sort
min
int.__rshift__
round
range
{}.get
cmp
max
lambda a,b:a<1>b
lambda a,b:a==b
lambda a,b:b<1
pow
{0:1,1:0}.get
{0:1}.get
lambda a,b:a+b<2
slice

以下のような入力を取りmin(True,False)(またはとしてmin(1,0))。適切なTruthy-Falsey値を持つことのみが必要な出力を大幅に活用します。可能な限り、組み込みを使用してコストのかかるを回避しlambdaます。コードを使用して、機能するビルトインを検索しました。

私のお気に入りは{0:1}.get、私が手で考えたものです。辞書{0:1}はキー0をvalueにマップします1。そのgetメソッドはキーとデフォルトを取り、キーに一致する値を出力します。そのようなキーがない場合はデフォルトを出力します。したがって、aを出力する唯一の方法0はasであり{0:1}.get(1,0)、key 1とdefault がありません0。異なる辞書を持つ他のバリアントを取得できますが、これだけが最短でした。

built_in_names = list(__builtins__) 

object_names = ["int","(0)","(1)"] + \
["True","False","0L","1L","0j","1j"] + \
["str", "''", "'0'","'1'","'a'"] + \
["list", "[]", "[0]", "[1]","['']","[[]]","[{}]"] + \
["set","set()","{0}","{1}","{''}"] + \
["dict","{}","{0:0}","{0:1}","{1:0}","{1:1}","{0:0,1:0}", "{0:0,1:1}","{0:1,1:0}","{0:1,1:1}"] + \
["id"]

object_method_names = [object_name+"."+method_name 
for object_name in object_names 
for method_name in dir(eval(object_name))]

additional_func_names = [
"lambda a,b:0",
"lambda a,b:1",
"lambda a,b:a",
"lambda a,b:b",
"lambda a,b:b<1",
"lambda a,b:a<1",
"lambda a,b:a+b",
"lambda a,b:a*b",
"lambda a,b:a==b",
"lambda a,b:a-b",
"lambda a,b:a<=b",
"lambda a,b:a>=b", 
"lambda a,b:a>b", 
"lambda a,b:a<b", 
"lambda a,b:a<1>b", 
"lambda a,b:a+b<2"]

func_names = built_in_names + object_method_names + additional_func_names

t=True
f=False

cases = [(f,f),(f,t),(t,f),(t,t)]

def signature(func):
    table = [bool(func(x,y)) for x,y in cases]
    table_string = ''.join([str(int(val)) for val in table])
    return table_string

d={}

for func_name in func_names:
    try:
        func = eval(func_name) 
        result = signature(func)
        if result not in d or len(func_name)<len(d[result]):
            d[result]=func_name
    except:
        pass

total_length = sum(len(func) for sig,func in d.items())

print total_length
print

for sig in sorted(d):
    print d[sig]

int __lt__やのような組み込みのメソッドを使用できませんか__eq__?:これらは、さらにバイト数が減少するint.__gt__代わりにlambda a,b:b<1、 int.__eq__代わりのlambda a,b:a==bようにし、
— ガーボルFekete

ので、@GáborFeketeものは、Python 2には存在しないintのは、との比較をオフロードcmpです。Python 3でこれを試したことはありません
— 。– xnor

なるほど
— ガボールフェケテ

関数を使用して4つのバイトを保存notするために0001、False- ideone
— ジョナサン・アラン

1
@JonathanAllanそれは賢いnotですが、あなたはできないので、それは関数の要件を満たしていないと思いますf=not;f(3,4)。文字列notは、想定される関数の引数がタプルのように見えるために機能します。これは、入力として受け取ることができる関数ではない場合3+と同じように機能します。3+(4)3+4
— -xnor

20

ゴー(ゲーム)、33石、73交差点

ドミノとチェスが許容される場合、これ。完全な19x19 Goボードでは、あまりゴルフにならないでしょう。そこで、小さな長方形のボードを使用しました。入力は、1および2とマークされた石が存在するかどうかです。出力は、黒が勝つかどうかです。エリアスコアリング、0.5コミ、状況的スーパーコ、自殺なしを使用します。再生するすべての黒。一部には複数のソリューションが与えられています。

白が勝つ(2、1x5):

➊━━━➋

1および2(3、2x3):

➊◯➋
┗┷┛

2ではなく1(2、1x5):

╺➊━➁╸

1(2、1x5):

╺➊➁━╸ 
╺➊━━➁
➀━➁━╸

1と2ではない(2、1x5):

╺➋━➀╸

2(2、1x5):

╺➋➀━╸

1 xor 2(2、2x3):

➀┯➁
┗┷┛

1または2(2、1x5):

╺➊━➋╸
➀━━━➁

1または2(2、1x4):

➊━━➋
╺➀➁╸

1 = 2(2、1x7):

╺━➀━➁━╸

2以外(2、1x3):

➀➁╸

1または2(2、1x4):

➀➁━╸
➀━➁╸
╺➊➁╸
➋➊━╸
➋━➊╸

なし1(2、1x3)

➁➀╸

1または2ではない(2、1x4):

➁➀━╸

1 nand 2(2、1x3):

➊━➋

黒勝(2、1x3):

➊➋╸
➀━➁
➊━➁

このページは少し役立ちました:http : //www.mathpuzzle.com/go.html

たぶん、誰かが1x9ボード上の1と2の2石の解決策を見つけることができます...


1
自殺のルールは何ですか?許可されていませんか?そして、片側がボード全体を埋めるとどうなりますか?それは自殺と見なされますか?
— マーティンエンダー

@MartinEnderは許可されていません。そして、はい、それは自殺と見なされます。
— jimmy23013

1x7ソリューションは間違っているように見えました。私はそれを修正しようとしています
— ...-jimmy23013

15

Javascript ES6、124バイト

a=>0
Math.min
parseInt
a=>a
a=>b=>a<b
a=>b=>b
a=>b=>a^b
Math.max
a=>b=>~a&~b
a=>b=>a==b
a=>b=>~b
Math.pow
a=>~a
a=>b=>a<=b
a=>b=>~a|~b
a=>1

私は今ラムダが大嫌いです。


1
いくつかのプログラムといくつかの関数を書くことが許可されている場合...に変更a=>b=>0してa=>0、それを呼び出す文法を(a=>0)(a,b)、これらの4つのエントリについてのみと言うことができると思います。
— jimmy23013

そうそう、ありがとう!
— ママファンロール

2
Math.minの代わりにa=>b=>a&b。Math.maxの代わりにa=>b=>a|b。Math.powの代わりにa=>b=>a>=b。
— コナーオブライエン

1
また、NaNは偽であるため、のparseInt代わりに行うことができますa=>b=>a>b。
— コナーオブライエン

1
@algmyr !NaN=> true、!!NaN=>false
— ママファンロール

14

網膜、62 39バイト

@MartinEnderのおかげで23バイト!

0000 false              1 byte : 2
0001 p and q            2 bytes: 11
0010 p and not q        2 bytes: 10
0011 p                  2 bytes: ^1
0100 not p and q        2 bytes: 01
0101 q                  2 bytes: 1$
0110 xor                5 bytes: 01|10
0111 p or q             1 byte : 1
1000 not p and not q    2 bytes: 00
1001 xnor               5 bytes: (.)\1
1010 not q              2 bytes: 0$
1011 p or not q         5 bytes: ^1|0$
1100 not p              2 bytes: ^0
1101 not p or q         5 bytes: ^0|1$
1110 not p or not q     1 byte : 0
1111 true               0 bytes: 

入力を受け取ります PQ。

0〜の間の整数を出力し3ます。0偽りであり、他は真実です。

説明

それらはすべて正規表現です。

例えば、01|10ちょうど一致します01か10。

では0000、2入力に含まれないため、一致しません。

では1111、空の文字列と一致します。4。


^1|0$1文字の文字列のみに一致する必要があります。何が起きてる?
— 電卓

@CalculatorFeline [ 1入力の開始時]または[ 0入力の終了時] に一致します。それを手に入れるのに
— 少しかかりました...-ETHproductions

優先順位、みんな....
— 漏れ修道女

私^1|0$は読むよりも読むのが難しいと思う1.|.0。すべてに難しく読み作るようです
— l4m2

10

Stack Cats、67 + 64 = 131バイト

+64は、-nm各プログラムにフラグを適用することからのものであることに注意してください。-nは数値I / Oを示し-m、最後の文字全体にソースコードをミラーリングします。すべてのサブミッションがこれらのフラグを技術的に必要とするわけではありませんが、一貫性と単純さのために同じ方法でスコアを付けています。

-2 -2 -3 -3     !I                0 0 0 0     <I!+
-4 -4 -4  1     |!T*I             0 0 0 1     [>I=I_
-4 -4  3 -2     *I*_              0 0 1 0     :I*=I:
-2 -2  3  3     T*I               0 0 1 1     [<!>X
-2  1 -2 -2     _*T*I             0 1 0 0     *|!TI:
-2  1 -3  1     !-|_I             0 1 0 1     <!I!>X
-2  3  3 -2     ^T*I              0 1 1 0     ^:]<_I
-2  3  3  3     -_T*I             0 1 1 1     *I<-I!
 2 -3 -3 -3     -*|_I             1 0 0 0     ^{!:}I_
 2 -3 -3  2     _|*I              1 0 0 1     _|[<I!:
 1 -2  1 -2     :]I*:             1 0 1 0     _!:|]X
 1 -2  1  1     *I\<X             1 0 1 1     *>I>!I
 2  2 -3 -3     -*I               1 1 0 0     I^:!
 2  2 -3  2     _*I_              1 1 0 1     |I|^:!
 1  2  2 -1     |!:^I             1 1 1 0     -I*<*I
 1  1  1  1     *<X               1 1 1 1     +I+

()Stack Catsでは、要素が正か非正(つまり0または負)かをチェックするため、それぞれを真実/偽に使用しています。2番目の列は興味の対象であり、出力として0/ 1s(合計スコア90)を持つ最適なゲートをリストします。

入力は、STDINを介した区切り文字で区切られたビットです。オンラインでお試しください!


Stack Catsはリバーシブルな難解な言語であり、プログラムでは反射対称性があります。スニペットf(例>[[(!-)/)が与えられると、鏡像(例\(-!)]]<)は逆行列を計算しf^-1ます。そのため、偶数の長さのプログラムは何もしません(または無限ループに陥ります)f g f^-1。g、中心演算子あるかをます。

ソースコードの半分は常に冗長であるため、省略することができます。-mフラグを指定してコードを実行すると、実際のソースコードを取得するには、ソースコードを最後の文字にミラーリングする必要があります。たとえば、プログラム*<Xは実際*<X>*には、対称です。

Stack Catsでのゴルフは非常に直感的ではないため、上記のプログラムは総当たりで見つける必要がありました。それらのほとんどは驚くほど複雑ですが、時間があるときにいくつかを説明し、この答えに追加します。現在のところ、0/ 1バージョンの説明と代替ソリューションは、Githubリポジトリにあります。


1
Note that the +64 is from applying the -nm flags to each program.3 * 16 = 48または2 * 16 = 32、いずれかのウェイ64はウェイハイ
— cat

@catフラグもプログラムごとに4個かかります。スペースもカウントする必要があります。
— FryAmTheEggman


1年以上経ちました。まだ時間はありますか?
— 電卓

8

Haskell、78 76 75バイト

  1. _#_=2<1
  2. &&
  3. >
  4. pure
  5. <
  6. _#b=b
  7. /=
  8. ||
  9. (not.).max
  10. ==
  11. _#b=not b
  12. >=
  13. a#_=not a
  14. <=
  15. (not.).min
  16. _#_=1<2

編集:@coleのおかげで-1バイト。


私は「おい、_#_標準的な演算子ではない!」とコメントしようとしていました。そして、私は気づいた...よくやった。
— MathematicalOrchid

4は可能性がありますpure
— コール

@cole:ありがとう。うわー、2015年pureに導入されたPreludeので、この課題の時点で利用可能でした。
— nimi

6

Brachylog、36 34バイト

0000 false              \     Backtrack (always false)
0001 p and q            1.    Unify input and output with 1
0010 p and not q        >.    Input > Output
0011 p                  1     Unify input with 1
0100 not p and q        <.    Input < Output
0101 q                  ,1.   Unify output with 1
0110 xor                '.    Input and output cannot unify
0111 p or q             1;1.  Unify input with 1 or unify output with 1
1000 not p and not q    0.    Unify input and output with 0
1001 eq                 .     Unify input with output
1010 not q              ,0.   Unify output with 0
1011 p or not q         >=.   Input >= Output
1100 not p              0     Unify input with 0
1101 not p or q         <=.   Input <= Output
1110 not p or not q     0;0.  Unify input with 0 or unify output with 0
1111 true                     Empty program (always true)

これは0、偽りの価値と真実の価値として期待してい1ます。trueまたはを返しますfalse。pはInput、qはOutputです。


出力をどのように入力しますか?
— リーキー修道女

1
@LeakyNun入力と同じです。主な述語お問合せは、と呼ばれる2つの引数、ありInputとOutput慣例によっては、しかし、あなたは、両方に値を設定し、またはその両方から値を返すことができます。
— 16年

1
これは、仕事のための適切なツールです:P
— コナー・オブライエン

6

プロローグ、 147 145バイト

@SQBのおかげで2バイト増加

a(a,a).       % 0000 false
b(1,1).       % 0001 P and Q
c(1,0).       % 0010 P and not Q
d(1,_).       % 0011 P
e(0,1).       % 0100 not P and Q
f(_,1).       % 0101 Q
g(P,Q):-P\=Q. % 0110 P xor Q
h(1,_).       % 0111 P or Q
h(0,1).
i(0,0).       % 1000 not P and not Q
j(P,P).       % 1001 P == Q                 
k(_,0).       % 1010 not Q
m(P,Q):-P>=Q. % 1011 P or not Q
n(0,_).       % 1100 not P              
r(P,Q):-P=<Q. % 1101 not P or Q         
s(0,_).       % 1110 not P or not Q
s(1,0).
t(_,_).       % 1111 true

適切な文字でクエリx(P,Q).しx、PそしてQ 0または1のいずれかに設定
を戻しますtrueかfalse。

テストを含むSWISHの例 - runTest.実行するために入力します。


a(2,2).falseをサポートしていますか?
— jimmy23013

2 それが受け入れられるかどうかはわかりません。
— 16年

@ jimmy23013実際、a(a,a).(または他の文字)もa機能し、真実性の許容可能な入力ではないため、それは良いことです。提案をありがとう。
— 16年

6

NTFJ、86バイト

0000 false              ~
0001 p and q            |:|
0010 p and not q        :||:|
0011 p                  $
0100 not p and q        #{:||:|
0101 q                  #{$
0110 xor                :#{:#{:||#}:|||
0111 p or q             :|#{:||
1000 not p and not q    :|#{:||:|
1001 eq                 :#{:#{:||#}:|||:|
1010 not q              #{$:|
1011 p or not q         #{:||
1100 not p              $:|
1101 not p or q         :||
1110 not p or not q     |
1111 true               #

ここで試してみてください!しかし、最初に以下をお読みください。

入力はスタックで暗黙的です。結果はスタックに入れられます。16バイト(1追加*したい場合は、それぞれの終わりまでに)0x00または0x01出力に0と1を表すしたい場合は、追加の160バイトを追加し0たり1、印刷。(~~##~~~#{@それぞれの前に置く*。)

NTFJの2項演算子はNANDであるため、これらはそれぞれNAND形式で記述されています。

それぞれを見ていきましょう。

0:偽

~

~偽ビットを表します。簡単です。入力はスタックの最下部で暗黙的に行われるため、これは最上部に残ります。

1:pおよびq

|:|

NTFJはスタック上で動作します。:複製のコマンドです。そのp and q≡ not (p nand q)とそれを観察してくださいnot q = q nand q。

Command | Stack
        | p q
   |    | (p nand q)
   :    | (p nand q) (p nand q)
   |    | (p nand q) nand (p nand q)
        | => not (p nand q)
        | => p and q

(注、次いで、:|であると言うことができる否定と|:|であると言うことができる組み合わせ)

2:qではなくp

:||:|

これは単なる否定で:|あり、接続詞であることに注意してください|:|。

Command | Stack
        | p q
  :|    | p (not q)
  |:|   | p and (not q)

3:p

$

$スタックからアイテムをポップします。だから...ええ。

4:pおよびqではない

#{:||:|

これは、#{先頭にあることを除いて、2と同じです。#1(真のビット)をプッシュし、{、スタックを左に1回回転します。簡単です。

5:q

#{$

左に1回回転してドロップします。

6:xor

:#{:#{:||#}:|||

観察する:

p xor q = (p and (not q)) or ((not p) and q)                ; by experimentation (trust me)
        = (not ((not p) nand q)) or (not (p nand (not q)))  ; by definition of nand
        = not (((not p) nand q) and (p nand (not q)))       ; by De Morgan's laws
        = ((not p) nand q) nand (p nand (not q))            ; by definition of nand

ただし、スタックを完全に複製する方法はありません。そこで、我々はそれぞれのを持参する必要があるとしているp、qトップにし、それを複製します。

Command | Stack
        | p q
   :    | p q q
  #{    | q q p
   :    | q q p p
  #{    | q p p q
  :|    | q p p (not q)
   |    | q p (p nand (not q))
  #}    | (p nand (not q)) q p
  :|    | (p nand (not q)) q (not p)
   |    | (p nand (not q)) (q nand (not p))
   |    | (p nand (not q)) nand (q nand (not p))

したがって、xorがあります。

7:pまたはq

:|#{:||

上部を否定し、下部を上部にし、それを否定し、それらをまとめます。基本的に、p or q = (not p) nand (not q)。

8:pではなく、qでもない

:|#{:||:|

これは単に7の否定です。簡単です。

9:eq

:#{:#{:||#}:|||:|

これは単なるxnorであるか、xorではありません。また簡単です。

10:qではない

#{$:|

5の否定。

11:pまたはq

#{:||

p、nandを否定します。(not p) nand q = not ((not p) and q) = p or (not q) (by De Morgan's laws)。

12:pではない

$:|

ドロップ、停止、および否定。

13:pまたはqではない

:||

デモーガンの法則が再び日を救う!11と同じプロセス、q代わりに単に否定p。

14:非pまたは非q

|

これは単なるナンドです。

15:true

#

# 本当のビットです。


ちょうど理由...> _>
— Rɪᴋᴇʀ16年

— idk

なぜ5は単なる空のプログラムではなく、10は単なるプログラムではないの:|ですか?
— ジョファン

6

Minecraft、89ブロック

次のすべての写真で、青のブロックは入力A用で、オレンジのブロックは入力B用です

16. TRUEゲート-1ブロック

ここに画像の説明を入力してください

15. NANDゲート-1x2x3 = 6ブロック

ここに画像の説明を入力してください

14. A => B-1x2x3 = 6ブロックここに画像の説明を入力してください

13. NOT A-2ブロック ここに画像の説明を入力してください

12. B => A-1x2x3 = 6ブロックここに画像の説明を入力してください

11. NOT B-2ブロック ここに画像の説明を入力してください

10. XNOR-1x3x4 = 12ブロック ここに画像の説明を入力してください

9. NOR-1x2x3 = 6ブロックここに画像の説明を入力してください

8.または-1ブロック ここに画像の説明を入力してください

7. XOR-1x3x4 = 12ブロック ここに画像の説明を入力してください

6. B-1ブロック ここに画像の説明を入力してください

5.!A&B-1x2x5 = 10ブロック ここに画像の説明を入力してください

4. A-1ブロック ここに画像の説明を入力してください

3. A&!B-1x2x5 = 10ブロック ここに画像の説明を入力してください

2. AND-2x2x3 = 12ブロック ここに画像の説明を入力してください

1. FALSE- 1ブロック ここに画像の説明を入力してください


2
最後から2番目の画像(AND)では、トーチをブロックの後ろ、つまりレバーの反対側に置くことで、6ブロック節約できます。中央のトーチをほこりと交換し、上部のほこりを取り除き、1x2x3 = 6ブロックに下げます。
— ルカH

5

Mathematica、67バイト

0>1&
And
#&&!#2&
#&
!#&&#2&
#2&
Xor
Or
Nor
Xnor
!#2&
#||!#2&
!#&
!#||#2&
Nand
1>0&

これらはそれぞれ関数に評価されるため、次のように使用できます。

#&&!#2&[True, False]
Xor[True, False]

ああ、Mathematicaで整数だけが真実/偽である場合、これらの4つの長いものはかなり短縮できたでしょう。


整数が真実/偽ではない場合、それらをifステートメントに入れるとどうなりますか?
— コナーオブライエン

3
@CᴏɴᴏʀO'Bʀɪᴇɴそれは未評価のままです。
— マーティンエンダー

5

MATL、34 23バイト

注文が大丈夫だと思います!ゼロは偽であり、ゼロ以外は真実です。各関数は2つの暗黙的な入力を受け取ります(ただし、一部の入力は無視される場合があります)。最初の入力があり、第二はBである入力できます0/ 1のための真/偽、またはT/F。

こちらはTryItOnlineですテストケース3の例。

*for を使用して4バイトを節約しand、デニスの答えを見た後に>/の<代わりに~wY&/ を使用してさらに4バイトを節約しましたw~Y&。

1.  0,0,0,0 0 (ignores input, just returns a zero)
2.  0,0,0,1 * (and)
3.  0,0,1,0 < (not-A and B)
4.  0,0,1,1 D (A)
5.  0,1,0,0 > (not-B and A)
6.  0,1,0,1 xD (discard A, display B)
7.  0,1,1,0 Y~ (xor)
8.  0,1,1,1 + (or)
9.  1,0,0,0 +~ (not-or)
10. 1,0,0,1 = (A=B)
11. 1,0,1,0 x~ (not-B)
12. 1,0,1,1 <~ (not-B or A)
13. 1,1,0,0 ~ (not-A)
14. 1,1,0,1 ~+ (not-A or B)
15. 1,1,1,0 *~ (not(A and B))
16. 1,1,1,1 1 (just returns 1)

10
6番は面白いと思います。
— コナーオブライエン

@CᴏɴᴏʀO'Bʀɪᴇɴ6番が最高です、私も12番が好きです!xD!
— デビッド

「等しくない」機能はありませんか?
— 漏れの修道女

いいえ(少なくともそうは思わない)
— デビッド

2
@David番号7を置き換えることができると思う-
— ルイスメンドー

5

dc、37バイト

dc( "卓上計算機")は、スタックベースのpostfix計算機である標準のUNIXコマンドです。ビット演算がなく、比較演算子はマクロを実行するためにのみ使用できます(これはバイトに値しません)。整数除算はその一部を補います。

これらのスクリプトはスタック上の値を期待0し1、結果をスタックに残します。

0,0,0,0 (false)              0
0,0,0,1 (and)                *         a*b
0,0,1,0                      -1+2/     (a-b+1)/2
0,0,1,1 (A)                  r         reverse a, b: a now on top
0,1,0,0                      -1-2/     (a-b-1)/2
0,1,0,1 (B)                            (0 bytes) do nothing: b on top
0,1,1,0 (xor)                -         a-b
0,1,1,1 (or)                 +         a+b                  
1,0,0,0 (nor)                +v1-      sqrt(a+b) -1
1,0,0,1 (xnor)               +1-       a+b-1
1,0,1,0 (not B)              1-        b-1
1,0,1,1 (if B then A)        -1+       a-b+1
1,1,0,0 (not A)              r1-       a-1
1,1,0,1 (if A then B)        -1-       a-b-1            
1,1,1,0 (nand)               *1-       a*b - 1
1,1,1,1 (true)               1

5

ラビリンス、85バイト

2バイトを節約してくれたSp3000に感謝します。

!@
??&!@
??~&!@
?!@
?~?&!@
??!@
??$!@
??|!@
??|#$!@
??$#$!@
?#?$!@
?#?$|!@
?#$!@
?#$?|!@
??&#$!@
1!@

これらはすべて完全なプログラムであり、2つの整数を読み取る0か1、STDINから(数字以外の区切り文字を使用して)、STDOUT として、0または1STDOUTに結果を出力します。

オンラインでお試しください!(テストスイートではないため、異なるプログラムと入力を手動で試す必要があります。)

説明に関しては、これらはすべてかなり単純です。すべてのプログラムは線形であり、使用中のコマンドは以下を実行します。

?   Read integer from STDIN and push.
!   Pop integer and write to STDOUT.
@   Terminate program.
&   Bitwise AND of top two stack items.
|   Bitwise OR of top two stack items.
$   Bitwise XOR of top two stack items.
~   Bitwise NOT of top stack item.
#   Push stack depth (which is always 1 when I use it in the above programs).
1   On an empty stack, this pushes 1.

私が使用していることに注意してください、#それを結合するために常に使用される$、すなわち、計算するためXOR 1、または言い換えれば論理否定のために。いくつかのケースでのみ、~代わりに使用できました。&これは、結果の-1or から不要なビットをすべて破棄するため-2です。


5

IA-32マシンコード、63バイト

コードのHexdump、逆アセンブリ:

0000  33 c0     xor eax, eax;
      c3        ret;

0001  91        xchg eax, ecx;
      23 c2     and eax, edx;
      c3        ret;

0010  3b d1     cmp edx, ecx;
      d6        _emit 0xd6;
      c3        ret;

0011  91        xchg eax, ecx;
      c3        ret;

0100  3b ca     cmp ecx, edx;
      d6        _emit 0xd6;
      c3        ret;

0101  92        xchg eax, edx;
      c3        ret;

0110  91        xchg eax, ecx;
      33 c2     xor eax, edx;
      c3        ret;

0111  8d 04 11  lea eax, [ecx + edx];
      c3        ret;

1000  91        xchg eax, ecx; // code provided by l4m2
      09 d0     or eax, edx;
      48        dec eax;
      c3        ret;

1001  3b ca     cmp ecx, edx;
      0f 94 c0  sete al;
      c3        ret;

1010  92        xchg eax, edx;
      48        dec eax;
      c3        ret;

1011  39 d1     cmp ecx, edx; // code provided by l4m2
      d6        _emit 0xd6;
      40        inc aex;
      c3        ret;

1100  91        xchg eax, ecx;
      48        dec eax;
      c3        ret;

1101  3b d1     cmp edx, ecx; // code inspired by l4m2
      d6        _emit 0xd6;
      40        inc aex;
      c3        ret;

1110  8d 44 11 fe   lea eax, [ecx+edx-2] // code provided by l4m2
      c3        ret;

1111  91        xchg eax, ecx;
      40        inc eax;
      c3        ret;

入力:それは標準コーディング規約使用しているため、コードは、もはやそれができるよりもあるecxとedxし、出力をal。これはCで次のように表現できます。

unsigned char __fastcall func(int, int);

MS Visual Studioは文書化されていないSALCオペコードを理解していないようで、名前の代わりにそのコードを使用する必要がありました。

ありがとうございます コードサンプルの一部を改善して l4m2に!


1
1110 8D4411FE LEA EAX, [ECX+EDX-2]
— l4m2

5

C 34バイト

#define g(n,a,b)((n-1)>>3-b-2*a)&1

ここで、nは使用する関数番号ですが、拒否されると思うので、もう1つ提案します。

C 244バイト(メモリを使用)

typedef int z[2][2];
z a={0,0,0,0};
z b={0,0,0,1};
z c={0,0,1,0};
z d={0,0,1,1};
z e={0,1,0,0};
z f={0,1,0,1};
z g={0,1,1,0};
z h={0,1,1,1};
z i={1,0,0,0};
z j={1,0,0,1};
z k={1,0,1,0};
z l={1,0,1,1};
z m={1,1,0,0};
z n={1,1,0,1};
z o={1,1,1,0};
z p={1,1,1,1};

二重インデックス配列を使用します。 n[0][1]は(A implies B)(0,1)

138バイト目

フォースを学んだばかりです。gforthでも動作するAnsi Forthと互換性があると思います。

: z create dup , 1+ does> @ -rot 3 swap - swap 2* - rshift 1 and ; 
0 
z a z b z c z d z e z f z g z h z i z j z k z l z m z n z o z p 
drop

関数zは、指定された名前で新しい関数を作成し、論理ゲート番号をスタックの先頭から新しい関数アドレスに配置します。次の宣言のために、スタック内の次の(n + 1)論理ゲート関数を残します。

あなたはそれをテストできます:
そしてAB

0 0 b . cr 
0 1 b . cr
1 0 b . cr 
1 1 b . cr   

( "。"スタックの最上部を印刷 "cr"はキャリッジリターン)


各関数にコードのスニペットを提供するだけです。
— 電卓

4

C、268バイト

#define c(a,b)0      // 0000 
#define d(a,b)a&b    // 0001 
#define e(a,b)a>b    // 0010 
#define f(a,b)a      // 0011 
#define g(a,b)a<b    // 0100 
#define h(a,b)b      // 0101 
#define i(a,b)a^b    // 0110 
#define j(a,b)a|b    // 0111 
#define k(a,b)!b>a   // 1000 
#define l(a,b)a==b   // 1001 
#define m(a,b)!b     // 1010 
#define n(a,b)!b|a   // 1011 
#define o(a,b)!a     // 1100 
#define p(a,b)!a|b   // 1101 
#define q(a,b)!b|!a  // 1110 
#define r(a,b)1      // 1111 

マクロは関数よりも短いようです。


4

ブライアン&チャック、183バイト

4バイトを節約してくれたSp3000に感謝します。

一部のプログラムには、印刷できない文字が含まれています。特に、すべて\x01を<SOH>(0x01)制御文字に置き換える必要があります。

0000
?
#>.
0001
,-?,-?>?\x01
#}>.
0010
,-?,?>?\x01
#}>.
0011
,?\x01+?
#>.
0100
,?,-?>?\x01
#}>.
0101
,,?\x01+?
#>.
0110
,?>},?>?_\x01
#}+{>?_}>.
0111
,\x01?,?>?
#{>.
1000
,?,?>?\x01
#}>.
1001
,-?>},?>?_\x01
#}+{>>?_}>.
1010
,,-?\x01+?
#>.
1011
,\x01?,-?>?
#{>.
1100
,-?\x01+?
#>.
1101
,\x01-?,?>?
#{>.
1110
,\x01-?,-?>?
#{>.
1111
?
#>+.

入力と出力はバイト値を使用するため、入力は2つの0x00または0x01バイト(区切り文字なし)であり、出力はそのような1バイトになります。これは実際には、B&Cの真実/偽の最も賢明な定義でもあります。なぜなら、唯一の制御フローコマンド?はゼロを偽であり、他のすべてが真実であると見なすからです。

説明

最初のクイックB&Cプライマー:

  • すべてのプログラムは、それぞれ独自の行に記述された2つのBrainfuckのようなインスタンスで構成されています。最初のものをブライアン、次のものをチャックと呼びます。ブライアンで実行が開始されます。
  • 各プログラムのテープは他のプログラムのソースコードであり、各プログラムの命令ポインタは他のプログラムのテープヘッドです。
  • ブライアンのみが,(入力バイト)コマンドを使用でき、チャックのみが.(出力バイト)コマンドを使用できます。
  • Brainfuckの[]ループは存在しません。代わりに、唯一の制御フローは?、テープヘッドの下の現在の値がゼロ以外である場合に、制御を他のインスタンスに切り替えることです。
  • 加えて>、および<、そこだ{と}本質的Brainfuckスニペットと同等である[<]と[>]彼らはその方向の次のゼロ位置にテープヘッドを移動させる、すなわち、。主な違いは{、テープの値に関係なく、テープの左端で停止できることです。
  • 便宜のために、任意の_(これらを捕捉するために、非自明プログラムにおいて非常に有用であるように、ソースコード中のSはヌルバイトで置換されている{と})。

すべてのプログラムで、チャックのテープはで始まることに注意してください#。これは本当に何でもありえます。?テープヘッドが実行を開始する前に1つのセルを移動するように機能します(そのため、条件自体が有効なコマンドである場合、条件自体は実行されません)。したがって、Chuckの最初のセルをコードに使用することはできません。

プログラムには5つのクラスがあり、これらについては後で詳しく説明します。とりあえず、複雑さを増す順序でここにリストします。

0000、1111:定数関数

?
#>.
?
#>+.

これらは非常に簡単です。無条件でチャックに切り替えます。チャックはテープヘッドを未使用のセルの右側に移動し、直接印刷するか、最初にインクリメントして印刷します1。

0011、0101、1010、11001つのだけの入力に応じて、機能

,?\x01+?
#>.
,,?\x01+?
#>.
,,-?\x01+?
#>.
,-?\x01+?
#>.

我々が開始するかどうかに応じて,か、,,我々が取り組んでいますAかB。最初の例0011(つまりA)を見てみましょう。値を読み取った後?、その値の条件として使用します。の場合A = 1、これはチャックに切り替わります。チャックはテープヘッドを右に移動し、文字通り埋め込まれた1-byteを出力します。それ以外の場合、制御はブライアンに残ります。ここでは、1バイトはノーオペレーションです。その後、我々は、とよく入力をインクリメント+してください、それがゼロ以外のmakeとし、その後にチャックに切り替えます?。今回>は、右側の未使用のセルに移動し、それがとして印刷され0ます。

値の1つを否定するには、単にでデクリメントし-ます。これは、オン1に0し、0に-1限り非ゼロひいてはtruthyある、?懸念しています。

0001、0010、0100、1000:1つのtruthy結果とのバイナリ機能

,-?,-?>?\x01
#}>.
,-?,?>?\x01
#}>.
,?,-?>?\x01
#}>.
,?,?>?\x01
#}>.

これは、2つの入力を処理するための以前のアイデアの拡張です。1000(NOR)の例を見てみましょう。(潜在的に)両方の入力をで読み取ります,?。これらのいずれかがある場合は1、?チャックに切り替わります。彼は}(Brianのコードの後の空のセルに)テープヘッドを最後に移動し、>(まだゼロ)で別のセルを移動し、で印刷し.ます。

ただし、両方の入力がゼロの場合、制御は引き続きブライアンで行われます。>次に、でチャックに切り替えたときに}このコマンドが実行されないように、テープヘッドをに移動し?ます。チャックが行うことは>.、1-cellに移動するだけで、それを出力します。

必要に応じて入力の一方または両方を否定することにより、他の3つの関数を簡単に取得できます。

0111、1011、1101、1110:3つのtruthy結果とのバイナリ機能

,\x01?,?>?
#{>.
,\x01?,-?>?
#{>.
,\x01-?,?>?
#{>.
,\x01-?,-?>?
#{>.

結果を否定するための前のアイデアのマイナーな修正(つまり0、ブライアンのすべてを通過したときに印刷するなど1)。0111例として(OR)を見てみましょう。埋め込み1バイトはノーオペレーションなので、これはまだで始まることに注意してください,?,?。どちらかの入力があった場合は1、チャックに切り替えます。チャックは、でテープヘッドを最初に戻し{ます。>.テープヘッドをその1-byteに移動して印刷します。

両方の入力がゼロの場合、ブライアンに残り、テープヘッドを上{に移動してスキップし、チャックに切り替えます。彼が>.今回実行すると、Brianのコードの後に​​空のセルに移動し、を出力し0ます。

この場合も、一方または両方の入力を否定することにより、他の関数を簡単に取得できます。

0110、10012つの真実の結果を持つバイナリ関数

,?>},?>?_\x01
#}+{>?_}>.
,-?>},?>?_\x01
#}+{>>?_}>.

これは少し複雑です。前の関数は、短絡する可能性があるため、かなり単純でした-最初の入力の値が出力を決定でき、そうでない場合は、他の入力を調べます。これらの2つの関数では、常に両方の入力を調べる必要があります。

基本的な考え方は、第2の入力との間を選択するかどうかを決定する第一の入力を使用することです0し、1あるいは間1と0。0110例として(XOR)を見てみましょう。

検討してくださいA = 0。この場合B、そのまま出力する必要があります。,読み取りA、?何もしません。>それはので、次の(ゼロ以外)のセル上に移動}する私たちをもたらし_チャックに。ここで、私たちは読みB、再び,使います?。場合Bでした0としても、我々はだまだブライアンに。on Chuckを>スキップし}て、Brianのソースコードに埋め込まれ?たものを>.印刷するように切り替え0ます。場合Bだった1一方で、チャックを実行しない}に移動する_ので、すでにブライアンのコードでは>.、次に印刷します1代わりに-byteを。

の場合A = 1、すぐにChuckに切り替え}+{>?ます。これは_、ブライアンのソースコードに移動し、で1同様に変換して+から、最初に戻ります{? 1つのセルを右に移動してブライアンをスキップ>します。今回は、ブライアンはのを読んだ後Bならば、B = 0とチャックが使用する>.ブライアンの隣のセルを?されます1代わりに0。また、の場合B = 1、チャック}はギャップであったものをスキップし、テープの最後まで移動します>.。そのため、代わりにゼロが出力されます。この方法で印刷していますnot B。

等価性を実装するためにA、条件として使用する前に単純に否定しました。このため、最初に戻るときにも、別の>Chuckを追加してスキップする必要があることに注意してください-。


4

ClojureScript、88 84 76 74バイト

nilそしてfalsefalsyあり、他のすべての値はtruthyです。ブール演算は、算術および不等式の0/1に強制されます。関数は間違った数の引数を取ることができます。

0000   nil?            ; previously: (fn[]nil)
0001   and
0010   <
0011   true?           ; previously: (fn[x]x)
0100   >
0101   (fn[x y]y)
0110   not=
0111   or
1000   #(= 0(+ % %2))
1001   =
1010   #(not %2)
1011   <=
1100   not
1101   >=
1110   #(= 0(* % %2))
1111   /               ; previously: (fn[]4), inc

0偽物ではないですか?
— リーキー修道女

2
ClojureScriptではありません。
— MattPutnam

@LeakyNunほとんどのLISPや関数型プログラミング言語ではなく、Clojureは間違いなく
— cat

@cat はい、ほとんどの関数型プログラミング言語で!たとえば、Python はfalsey値であると評価not not(0)しFalseます。
— エリックアウトゴルファー

3
@EʀɪᴋᴛʜᴇGᴏʟғᴇʀEr ... Pythonは純粋に関数型でも、私が話している関数型言語でもありません。Pythonは大部分が必須であり、いくつかのより小さな(不完全に実行された)機能的な側面があります。アーラン、ハスケル(と思う)、Common Lispの、Clojureの、ラケット、スキーム、ファクター、標準ML、客観CAMLなど0はちょうど別の値であり、結果としてtruthyで、偽(のシンボル#f、f、false、など)があります偽。他のすべての値は、ほとんどの関数型言語で真実です。
— 猫

4

Brainfuck、184の 178 174バイト

入出力にはU + 0000とU + 0001が使用されます。

0000 .
0001 ,[,[->+<]]>.
0010 ,[,-[+>+<]]>.
0011 ,.
0100 ,-[,[->+<]]>.
0101 ,,.
0110 ,>,[-<->]<[>>+<]>.
0111 ,-[,-[+>-<]]>+.
1000 ,-[,-[+>+<]]>.
1001 ,>,[-<->]<[>>-<]>+.
1010 ,,-[+>+<]>.
1011 ,-[,[->-<]]>+.
1100 ,-[+>+<]>.
1101 ,[,-[+>-<]]>+.
1110 ,[,[->-<]]>+.
1111 +.

条件付きの2番目の入力を読むのは費用がかかります。例えば、0001あなたはできませんでした(あなた,[,>]<.が開始セルの左側に行くことを可能にする通訳を与えられました)?
— マーティンエンダー

@MartinEnderデニスの答えをここにコピーするだけではいけないと思いました。
— リーキー修道女

4

Brain-Flak、418バイト

オンラインでお試しください!

入力をプログラムの開始時のスタックの上位2つの数値(trueの場合はfalseの場合はゼロ)、プログラムの終了時の出力をスタックの先頭(trueの場合はfalseの場合はゼロ)にします。

false、4バイト(Leaky Nun提供)

(<>)

および、36バイト

(({}{}[(())()])){{}{}(((<{}>)))}{}{}

BではなくA、40バイト

((({}){}{}[(())()])){{}{}(((<{}>)))}{}{}

A、6バイト

({}<>)

AおよびBではなく、38バイト

((({}){}{}[(())])){{}{}(((<{}>)))}{}{}

B、2バイト

{}

xor、34バイト

(({}{}[(())])){{}{}(((<{}>)))}{}{}

または、6バイト

({}{})

また、34バイト

(({}{}<(())>)){{}{}(((<{}>)))}{}{}

xnor、10バイト

({}{}[()])

Bではなく、34バイト

{}(({}<(())>)){{}{}(((<{}>)))}{}{}

BはA、14バイトを意味します

(({}){}{}[()])

Aではなく、34バイト

(({}<{}(())>)){{}{}(((<{}>)))}{}{}

AはB、16バイトを意味します

(({}){}{}[()()])

ナンド、12バイト

({}{}[()()])

true、6バイト

<>(())

説明

これらのほとんどは非常に類似しているため、それぞれの動作を正確に説明するつもりはありません。しかし、16のすべてがどのように機能するかを明確にするために最善を尽くします。

まず、同じ値の3つ(つまり、2、3、5、8、9、12、14、および15)を返すゲートです。これらはすべて同じパターンに従います。まず、入力を2の位としてa、1としてBを使用して2ビットの数値に変換します。これは、このスニペットで行われ(({}){}{})ます。次に、分離する2ビット入力の値を減算します({}[value])。(実際のコードでは、減算と変換は1バイトで行われ、バイトが節約されます)。これは、必要に応じてnotと組み合わせることができます。(({}<(())>)){{}{}(((<{}>)))}{}{}。

次:and、nor、or、xor、xnor。これらは上記のものと同様に機能します。実際、これらの一部は上記に含まれていますが、この方法はより短くなります。ここで使用したトリックは、これらがそれぞれA Bの合計に対応することです。たとえば、xorは、A + B = 1の場合はtrue、それ以外の場合はfalseと評価されます。最初にABを追加し、関連する金額を減算します。として表され({}{}[0,1,2 or 3])ます。その後、必要に応じて

次に:A、B、AでもBでもありません。これらはほとんど自明です。不要な値を削除することから始めて、否定するか終了します。

最後に、trueとfalseの2つのシンプトンがあります。これらの場合、正しい値をスタック外にプッシュします。<>nilad戻りので、我々はゼロ値としてスイッチを使用して、2つのバイトを保存することができますゼロ。

最も効率的なソリューションではありません(おそらくBrain-Flakで最も効率的なソリューション)が、私はこれらを書くのがとても楽しかったので、これらを短くするようにお願いします。


(<>)のために十分ですfalse。また、(<{}{}>)8バイト
— Leaky Nun

うわー、私ははるかに厳しい挑戦の定義を持っていました。ありがとうございました。これを大幅に削減します
— ウィートウィザード

どういう意味ですか?
— リーキー修道女

既存の入力を削除し、その場所に結果を配置する必要があると考えました。 (<>)入力を残し、他のスタックにゼロを置きます。
— 小麦ウィザード

1
暗黙的なゼロのために<>十分ではありませんfalseか?また、a空のプログラムになる可能性があると思います。trueことができます<>[][](:Pバイトを保存しますが、クールに見えていません)。
— 電卓

4

ProgFk、18.5 17.5バイト

ProgFkの命令はニブルで指定されているため、以下のコードは16進数で示され、1行に1つの論理ゲートがあり、バイト間にスペースがあります。

3
E1
DE 2D
<empty>
DE 1
1
E3
E2
E2 D
E3 D
1D
DE 2
D
DE 1D
E1 D
4

説明

ProgFkはテープベースのエゾラン(Brainfuckに似ています)で、各セルは少しで、指示はニブル(4バイト)で与えられます。命令は、命令ポインタが指すセルで動作します。入力は、(第1および第2のセルに与えられているAと、Bそれぞれ第1および第2のセルである)、及び命令ポインタは、最初のセルから始まります。出力は最初のセルに保存されます。

使用される各命令について以下に説明します。

1   Increment the instruction pointer.
2   Decrement the instruction pointer.
3   Set the current bit to 0.
4   Set the current bit to 1.
D   Perform a NOT on the current bit.
E   The next instruction is an extended instruction.

Extended instructions:
1   Set the current bit to the current bit AND the next bit.
2   Set the current bit to the current bit OR the next bit.
3   Set the current bit to the current bit XOR the next bit.
6   Swap the current bit and the next bit.

@LeakyNunのおかげで1バイト節約できました!


4

実際には、24バイト

これらのプログラムは入力をA\nB(\n改行を表す)として受け取り、Bをスタックの一番上に残し、Aを下に残します。Falseはで表され0、True正の整数で表されます。

é0  (false: clear stack, push 0)
*   (and: multiply)
<   (A and not B: less-than)
X   (A: discard B)
>   (B and not A: greater-than)
@X  (B: discard A)
^   (A xor B: xor)
|   (A or B: or)
|Y  (A nor B: or, boolean negate)
=   (A xnor B: equals)
@XY (not B: discard A, boolean negate B)
≤   (if B then A: less-than-or-equal)
XY  (not A: discard B, boolean negate)
≥   (if A then B: greater-than-or-equal)
*Y  (A nand B: multiply, boolean negate)
é1  (true: clear stack, push 1)

3バイトのLeaky Nunに感謝

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.