最近、論理的な「OR」演算子をプログラムで定義する必要がある問題に遭遇しましたが、演算子自体は使用していません。

私が思いついたのはこれです：

OR(arg1, arg2)
  if arg1 = True and arg2 = True
     return True

  else if arg1 = True and arg2 = False
     return True

  else if arg1 = False and arg2 = True
     return True

  else:
     return False

この論理は正しいですか、それとも何か見落としていましたか？

それは正しいと思いますが、このようなものに凝縮することはできませんか？

or(arg1, arg2)
    if arg1 == true
        return true
    if arg2 == true
        return true

    return false

あなたは比較をしているので、実際に組み合わせを確認する必要はないと思います。それらの1つがtrueを返すことがtrueであるかどうかだけが重要です。それ以外の場合は、falseを返します。

冗長性の少ない短いバージョンを探している場合、これも機能します。

or(arg1, arg2)
    if arg1
        return arg1
    return arg2

以下は、比較とブールリテラルを使用しない、または使用しない、および使用しないソリューションです。

or(arg1, arg2)
  if arg1
    return arg1
  else
    return arg2

それはおそらくそれよりもはるかに基本的なものにはなりません;）

1行のコード：

return not (not arg1 and not arg2)

分岐もORもありません。

Cベースの言語では、次のようになります。

return !(!arg1 && !arg2);

これは単にDe Morganの法則の適用です：(A || B) == !(!A && !B)

としか持っていない場合はand、notDeMorganの法則を使って振り向くことができますand。

if not (arg1 = False and arg2 = False)
  return True
else
  return False

...または（さらに簡単に）

if arg1 = False and arg2 = False
  return false
else
  return true

...

そして、とにかく機械命令としてほとんど常に利用できるものを最適化することに固執するようになったので、要約すると次のようになります。

return not(not arg1 and not arg2)

return arg1 ? true : arg2

などなどなど

ほとんどの言語は条件付きANDを提供するため、「AND」演算子は分岐を意味します。

...

持っているものがすべてある場合nand（ウィキペディアを参照）：

return nand（nand（arg1、arg1）、nand（arg2、arg2））

関数（ECMAScript）

必要なのは、関数定義と関数呼び出しだけです。分岐、条件、演算子、組み込み関数は必要ありません。ECMAScriptを使用した実装を示します。

まずは、という2つの関数を定義してみましょうtrueとfalse。自由に定義できますが、完全に任意ですが、後で見るようにいくつかの利点がある非常に特別な方法で定義します。

const tru = (thn, _  ) => thn,
      fls = (_  , els) => els;

truは、2番目の引数を単に無視し、最初の引数を返す2つのパラメーターを持つ関数です。flsまた、最初の引数を単に無視して2番目の引数を返す2つのパラメーターを持つ関数です。

なぜこのようにエンコードtruしたのflsですか？さて、このように、2つの関数はtrueand の2つの概念を表すだけfalseでなく、「選択」の概念も表す、つまりif/ then/ else式でもあります。if条件を評価し、thenブロックとelseブロックを引数として渡します。条件がに評価されるtruと、thenブロック評価される場合fls、elseブロックを返します。以下に例を示します。

tru(23, 42);
// => 23

これは戻ります 23、：

fls(23, 42);
// => 42

42期待どおりに戻ります。

しかし、しわがあります：

tru(console.log("then branch"), console.log("else branch"));
// then branch
// else branch

これは両方を印刷します then branchをしelse branchます！どうして？

まあ、それは返す最初の引数の戻り値を、それが評価される ECMAScriptのは厳密で、常に関数を呼び出す前に、関数のすべての引数を評価するので、両方の引数を。IOW：最初の引数であるを評価します。これはconsole.log("then branch")単に返され、コンソールに出力するというundefined副作用があります。then branchそれが二番目の引数を評価し、またその戻りundefined副作用としてコンソールへとプリント。次に、最初のを返しますundefined。

このエンコーディングが発明されたλ計算では、それは問題ではありません。λ計算は純粋です。つまり、副作用がありません。したがって、2番目の引数も評価されることに気付かないでしょう。さらに、λ計算は遅延（または、少なくとも通常の順序で評価されることが多い）、つまり、必要のない引数を実際には評価しません。したがって、IOW：λ計算では、2番目の引数は評価されず、評価されても気付かないでしょう。

ただし、ECMAScriptはstrictです。つまり、常にすべての引数を評価します。まあ、実際には、常にではありません：たとえば、if/ then/ は、条件がある場合にのみブランチを評価し、条件がある場合にのみブランチを評価しますelsethentrueelsefalseます。そして、この振る舞いをiff。ありがたいことに、ECMAScriptは怠zyではありませんが、他のほとんどすべての言語と同じように、コードの評価を遅らせる方法があります：関数でラップし、その関数を呼び出さないとコードは決して実行されません。

したがって、両方のブロックを関数でラップし、最後に返される関数を呼び出します。

tru(() => console.log("then branch"), () => console.log("else branch"))();
// then branch

プリントthen branchと

fls(() => console.log("then branch"), () => console.log("else branch"))();
// else branch

プリント else branchます。

従来のif/ then/をelse次のように実装できます。

const iff = (cnd, thn, els) => cnd(thn, els);

iff(tru, 23, 42);
// => 23

iff(fls, 23, 42);
// => 42

繰り返しますが、関数を呼び出すときに追加の関数のラッピングが必要であり、上記と同じ理由iffでiff、追加の関数はの定義で括弧を呼び出します。

const iff = (cnd, thn, els) => cnd(thn, els)();

iff(tru, () => console.log("then branch"), () => console.log("else branch"));
// then branch

iff(fls, () => console.log("then branch"), () => console.log("else branch"));
// else branch

これらの2つの定義ができたので、実装できますor。最初に、真理値表を見てください。or第1オペランドが真理値の場合、式の結果は第1オペランドと同じです。それ以外の場合、式の結果は第2オペランドの結果です。つまり、第1オペランドがの場合、第1オペランドtrueを返します。それ以外の場合、第2オペランドを返します。

const orr = (a, b) => iff(a, () => a, () => b);

動作することを確認しましょう：

orr(tru,tru);
// => tru(thn, _) {}

orr(tru,fls);
// => tru(thn, _) {}

orr(fls,tru);
// => tru(thn, _) {}

orr(fls,fls);
// => fls(_, els) {}

すばらしいです！しかし、その定義は少しいように見えます。覚えておいてください、truそしてfls、すでに自分で条件付きのすべてのように行動するので、実際には必要ありませんiffので、すべてのすべてで、その関数のラッピングの：

const orr = (a, b) => a(a, b);

そこにあなたはそれを持っています：（orそして他のブール演算子）ほんの数行の関数定義と関数呼び出しだけで定義されています：

const tru = (thn, _  ) => thn,
      fls = (_  , els) => els,
      orr = (a  , b  ) => a(a, b),
      nnd = (a  , b  ) => a(b, a),
      ntt = a          => a(fls, tru),
      xor = (a  , b  ) => a(ntt(b), b),
      iff = (cnd, thn, els) => cnd(thn, els)();

返すECMAScriptのには関数や演算子がない：残念ながら、この実装はかなり無用であるtruかfls、それらはすべて返却trueまたはfalse私達は私達の機能でそれらを使用することはできませんので、。しかし、私たちにできることはまだたくさんあります。たとえば、これは片方向リンクリストの実装です。

const cons = (hd, tl) => which => which(hd, tl),
      car  = l => l(tru),
      cdr  = l => l(fls);

オブジェクト（Scala）

奇妙なことに気づいたかもしれません：truそしてfls、二重の役割を果たし、データ値trueとの両方として機能しますfalseが、同時に条件式としても機能します。それらはデータと振る舞いであり、1つにまとめられています…ええと…「もの」…または（あえて言う）オブジェクト！

確かに、truそしてflsオブジェクトです。また、Smalltalk、Self、Newspeak、またはその他のオブジェクト指向言語を使用したことがある場合は、それらがまったく同じ方法でブール値を実装していることに気付くでしょう。このような実装をScalaで実演します。

sealed abstract trait Buul {
  def apply[T, U <: T, V <: T](thn: ⇒ U)(els: ⇒ V): T
  def &&&(other: ⇒ Buul): Buul
  def |||(other: ⇒ Buul): Buul
  def ntt: Buul
}

case object Tru extends Buul {
  override def apply[T, U <: T, V <: T](thn: ⇒ U)(els: ⇒ V): U = thn
  override def &&&(other: ⇒ Buul) = other
  override def |||(other: ⇒ Buul): this.type = this
  override def ntt = Fls
}

case object Fls extends Buul {
  override def apply[T, U <: T, V <: T](thn: ⇒ U)(els: ⇒ V): V = els
  override def &&&(other: ⇒ Buul): this.type = this
  override def |||(other: ⇒ Buul) = other
  override def ntt = Tru
}

object BuulExtension {
  import scala.language.implicitConversions
  implicit def boolean2Buul(b: ⇒ Boolean) = if (b) Tru else Fls
}

import BuulExtension._

(2 < 3) { println("2 is less than 3") } { println("2 is greater than 3") }
// 2 is less than 3

BTWは、条件付きポリモーフィズムリファクタリングとの置換が常に機能する理由です。先ほど示したように、ポリモーフィックメッセージディスパッチは単に実装するだけで条件を置き換えることができるため、プログラム内のすべての条件を常に多態的なメッセージディスパッチに置き換えることができます。Smalltalk、Self、Newspeakなどの言語は、これらの言語には条件さえないため、その存在を証明しています。（また、ループ、BTW、または仮想メソッド呼び出しとも呼ばれるポリモーフィックメッセージディスパッチを除き、実際にはあらゆる種類の言語組み込み制御構造はありません。）

パターンマッチング（Haskell）

また、orパターンマッチング、またはHaskellの部分関数定義のようなものを使用して定義することもできます。

True ||| _ = True
_    ||| b = b

もちろん、パターンマッチングは条件付き実行の一種ですが、オブジェクト指向のメッセージディスパッチも同様です。

以下に、ORまたはそれを定義する最も伝統的な方法を使用した論理演算子を定義する別の方法を示します。真理値表を使用します。

もちろん、これはJavascriptやPerlなどの高水準言語で行うのは非常に簡単ですが、この手法が高水準言語機能に依存しないことを示すためにCでこの例を書いています。

#include <stdio.h>

int main (void) {
    // Define truth table for OR:
    int OR[2][2] = {
        {0,   // false, false
         1},  // false, true
        {1,   // true, false
         1}   // true, true
    }

    // Let's test the definition
    printf("false || false = %d\n",OR[1==2]['b'=='a']);
    printf("true || false = %d\n",OR[10==10]['b'=='a']);

    // Usage:
    if (OR[ 1==2 ][ 3==4 ]) {
        printf("at least one is true\n");
    }
    else {
        printf("both are false\n");
    }
}

AND、NOR、NAND、NOT、XORでも同じことができます。コードは、構文のように見えるほどきれいなので、次のようなことができます。

if (OR[ a ][ AND[ b ][ c ] ]) { /* ... */ }

論理演算子を整数算術式として表現する別の方法（可能な場合）。この方法は、多くの述語のより大きな表現のために多くの分岐を避けることができます

Trueを1にするFalseを0にする

両方の合計が1より大きい場合、trueまたはfalseが返されます。

boolean isOR(boolean arg1, boolean arg2){

   int L = arg1 ? 1 : 0;
   int R = arg2 ? 1 : 0;

   return (L+R) > 0;

}

2つの形式：

OR(arg1, arg2)
  if arg1
     return True
  else:
     return arg2

または

OR(arg1, arg2)
  if arg1
     return arg1
  else:
     return arg2

コードと同様に、これまでの他の提案よりも少し小さいというゴルフのような利点があり、ブランチが1つ少なくなります。私たちが非常に頻繁に使用されるプリミティブの作成を検討している場合、ブランチの数を減らすことはそれほど愚かではありません。

Javascriptの定義は||これに似ており、その緩いタイピングと組み合わせることで、式false || "abc"に値が"abc"あり、値があることを意味し42 || "abc"ます42。

既に他の論理演算子を持っている場合nand(not(arg1), not(arg2))は、そのようなものには分岐がまったくないという利点があるかもしれませんが。

ifコンストラクトを使用するすべてのプログラムされたソリューションに加えて、3つのNANDゲートを組み合わせてORゲートを構築することができます。ウィキペディアでそれがどのように行われているかをご覧になりたい場合は、ここをクリックしてください。

これから、式、

NOT [NOT（A AND A）AND NOT（B AND B）]

NOTとANDを使用すると、ORと同じ答えが返されます。NOTとANDの両方を使用することは、NANDを表すあいまいな方法にすぎないことに注意してください。

すべての良い答えはすでに与えられています。しかし、私はそれを止めさせません。

// This will break when the arguments are additive inverses.
// It is "cleverness" like this that's behind all the most amazing program errors.
or(arg1, arg2)
    return arg1 + arg2
    // Or if you need explicit conversions:
    // return (bool)((short)arg1 + (short)arg2)

代わりに：

// Since `0 > -1`, negative numbers will cause weirdness.
or(arg1, arg2)
    return max(arg1, arg2)

このようなアプローチを実際に誰も使用しないことを願っています。彼らはここで、代替案の認識を促進するためだけにいます。

更新：

負の数は上記のアプローチの両方を破ることができるため、別のひどい提案があります：

or(arg1, arg2)
    return !(!arg1 * !arg2)

これは単にDeMorganの法則を使用*し&&、when trueおよびand falseがそれぞれ1およびのように扱われることに類似する事実を悪用し0ます。（待って、これはコードゴルフではないと言っているのですか？）

これはまともな答えです：

or(arg1, arg2)
    return arg1 ? arg1 : arg2

しかし、それはすでに与えられた他の答えと本質的に同じです。

定義する1つの方法orは、ルックアップテーブルを使用することです。これを明示的にすることができます：

bool Or( bool a, bool b } {
  bool retval[] = {b,true}; // or {b,a};
  return retval[a];
}

返り値が何であるかに応じて持つべき値で配列を作成しますa。次に、ルックアップを行います。C ++のような言語でboolは、truebeing 1およびfalsebeing を使用して、配列インデックスとして使用できる値に昇格します0。

次に、これを他の論理演算に拡張できます。

bool And( bool a, bool b } {
  bool retval[] = {false,b}; // or {a,b};
  return retval[a];
}
bool Xor( bool a, bool b } {
  bool retval[] = {b,!b};
  return retval[a];
}

これらすべての欠点は、プレフィックス表記が必要になることです。

namespace operators {
  namespace details {
    template<class T> struct is_operator {};
    template<class Lhs, Op> struct half_expression { Lhs&& lhs; };
    template<class Lhs, class Op>
    half_expression< Lhs, Op > operator*( Lhs&&lhs, is_operator<Op> ) {
      return {std::forward<Lhs>(lhs)};
    }
    template<class Lhs, class Op, class Rhs>
    auto operator*( half_expression<Lhs, Op>&& lhs, Rhs&& rhs ) {
    return invoke( std::forward<Lhs>(lhs.lhs), Op{}, std::forward<Rhs>(rhs) );
    }
  }
  using details::is_operator;
}

struct or_tag {};
static const operators::is_operator<or_tag> OR;

bool invoke( bool a, or_tag, bool b ) {
  bool retval[] = {b,true};
  return retval[a];
}

そして今、あなたは入力することができます true *OR* false、それは動作します。

上記の手法には、引数依存のルックアップをサポートする言語とテンプレートが必要です。おそらくジェネリックとADLを使用した言語でそれを行うことができます。

余談ですが*OR*、セットを操作するために上記を拡張できます。以下invokeと同じ名前空間に無料の関数を作成しますor_tag。

template<class...Ts>
std::set<Ts...> invoke( std::set<Ts...> lhs, or_tag, std::set<Ts...> const& rhs ) {
  lhs.insert( rhs.begin(), rhs.end() );
  return lhs;
}

そして今set *OR* set、2つの和集合を返します。

これは私に特徴的な機能を覚えています：

or(a, b)
    return a + b - a*b

これは、ブール値を（1、0）として処理できる言語にのみ適用されます。booleanはクラスであるため、SmalltalkまたはPythonには適用されません。smalltalkではさらに進んでいきます（これは一種の擬似コードで記述されます）。

False::or(a)
    return a

True::or(a)
    return self

また、次の2つの方法があります。

False::and(a)
    return self

True::and(a)
    return a

そのため、OPステートメントでは「ロジック」は完全に有効ですが、冗長ではあります。注意してください、それは悪くありません。たとえば、一種のマトリックスに基づいた数学演算子のように機能する関数が必要な場合に最適です。他のものは、実際のキューブを実装します（Quine-McCluskeyステートメントのような）：

or = array[2][2] {
    {0, 1},
    {1, 1}
}

そして、あなたは評価するでしょう[または] [b]

そのため、ここでのすべてのロジックは有効です（ただし、言語内OR演算子xDDDDDDDDを使用して投稿されたものは除きます）。

しかし、私のお気に入りはDeMorganの法則です： !(!a && !b)

Swift標準ライブラリを見て、ショートカットORおよびショートカットAND演算の実装を確認してください。これらの演算は、必要でない場合や許可されていない場合に2番目のオペランドを評価しません。

ロジックは完全に正しいですが、単純化できます：

or(arg1, arg2)
  if arg1 = True
     return True
  else if arg2 = True
     return True
  else
     return False

そして、おそらくあなたの言語はOR演算子を持っているので、質問の精神に反しない限り-

or(arg1, arg2)
  if arg1 = True or arg2 = True
     return True
  else
     return False