최근에 논리 "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

당신이 또는 비교를하고 있기 때문에, 당신이 정말로 조합을 확인해야한다고 생각하지 않습니다. 그들 중 하나가 true를 반환하는 것이 사실이라면 그것은 중요합니다. 그렇지 않으면 우리는 거짓을 돌려주고 싶다.

덜 장황한 더 짧은 버전을 찾고 있다면 다음과 같이 작동합니다.

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

다음은 비교 및 ​​부울 리터럴이 있거나없는 솔루션입니다.

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

아마도 그보다 훨씬 더 근본적이지는 않을 것입니다.)

한 줄의 코드 :

return not (not arg1 and not arg2)

분기가없고 OR이 없습니다.

C 기반 언어에서는 다음과 같습니다.

return !(!arg1 && !arg2);

이것은 단순히 De Morgan의 법칙을 적용한 것입니다 .(A || B) == !(!A && !B)

andand 만 가지고 있다면 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"연산자는 분기를 의미합니다.

...

모든 것이 있다면 nand( wikipedia 참조 )

반환 nand (nand (arg1, arg1), nand (arg2, arg2))

기능 (ECMAScript)

함수 정의와 함수 호출 만 있으면됩니다. 분기, 조건부, 연산자 또는 내장 함수가 필요하지 않습니다. ECMAScript를 사용한 구현을 보여 드리겠습니다.

먼저 trueand 라는 두 함수를 정의 해 봅시다 false. 원하는 방식으로 정의 할 수 있지만 완전히 임의적이지만 나중에 볼 수있는 몇 가지 장점이있는 매우 특별한 방식으로 정의 할 것입니다.

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

tru단순히 두 번째 인수를 무시하고 첫 번째를 반환하는 두 개의 매개 변수가있는 함수입니다. fls또한 첫 번째 인수를 무시하고 두 번째 매개 변수를 반환하는 두 개의 매개 변수가있는 함수입니다.

왜 우리는 인코딩 않았다 tru및 fls이 방법은? 음, 이런 식으로, 두 함수는 두 개념을 나타내지 true하고 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.

이 인코딩이 발명 된 λ- 미적분학에서는 문제가되지 않습니다 : λ- 미적분학은 순수합니다 . 즉, 부작용이 없습니다. 따라서 두 번째 인수도 평가됩니다. 또한 λ- 미적분은 게 으르 거나 (또는 ​​적어도 정상적인 순서로 평가되는 경우가 많음) 실제로 필요하지 않은 인수는 평가하지 않습니다. 그래서, IOW : λ- 미적분에서 두 번째 논증은 결코 평가되지 않을 것이며, 만약 그렇다면, 우리는 눈치 채지 못할 것입니다.

그러나 ECMAScript는 엄격합니다 . 즉, 항상 모든 인수를 평가합니다. 실제로 항상 그런 것은 아닙니다. 예를 들어, if/ then/ 는 조건이 조건 인 경우 에만 분기를 평가 하고 조건이 조건 인 경우 에만 분기를 평가합니다 . 그리고 우리는이 동작을로 복제하고 싶습니다 . 고맙게도 ECMAScript가 게으르지 않더라도 거의 모든 다른 언어와 마찬가지로 코드 조각의 평가를 지연시키는 방법이 있습니다. 함수로 감싸고 함수를 호출하지 않으면 코드는 절대로 처형되지 않습니다.elsethentrueelsefalseiff

따라서 함수에서 두 블록을 모두 래핑하고 마지막에 반환되는 함수를 호출합니다.

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

이제이 두 가지 정의가 있으므로 구현할 수 있습니다 or. 첫 or번째 피연산자가 진실이면 표현식의 결과는 첫 번째 피연산자와 동일합니다. 그렇지 않으면 표현식의 결과는 두 번째 피연산자의 결과입니다. 간단히 말해 : 첫 번째 피연산자가 true이면 첫 번째 피연산자 를 반환하고, 그렇지 않으면 두 번째 피연산자를 반환합니다.

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

객체 (스칼라)

당신은 주목 뭔가 독특한이있을 수 있습니다 : tru및 fls이중 역할을, 그들은 데이터 값 역할을 모두 true하고 false, 그러나 동시에, 그들은 또한 조건식 역할을합니다. 그들은있는 데이터 및 행동 "일"... 하나 개 ... 음으로 번들 ... 나 (I는 말을 감히) 오브젝트를 !

사실, tru그리고 fls객체입니다. 그리고 Smalltalk, Self, Newspeak 또는 기타 객체 지향 언어를 사용한 적이 있다면, 동일한 방식으로 부울을 구현한다는 것을 알게 될 것입니다. 여기 스칼라에서 이러한 구현을 보여줄 것입니다.

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는 다형성 리팩토링으로 조건부 바꾸기가 항상 작동하는 이유입니다. 방금 보여 드렸듯이, 다형성 메시지 디스패치가 조건부를 간단히 구현하여 조건부를 대체 할 수 있기 때문에 프로그램의 모든 조건부를 다형성 메시지 디스패치로 항상 바꿀 수 있습니다. 스몰 토크, 셀프, 뉴스 피크와 같은 언어는 조건이 없기 때문에 존재 증거입니다. (또한 가상 메소드 호출이라고 불리는 다형성 메시지 디스패치를 ​​제외하고 루프, BTW 또는 실제로 어떤 종류의 언어 내장 제어 구조도 없습니다.)

패턴 매칭 (Haskell)

or패턴 일치 또는 Haskell의 부분 함수 정의와 같은 것을 사용하여 정의 할 수도 있습니다 .

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

물론 패턴 일치는 조건부 실행의 한 형태이지만 다시 객체 지향 메시지 디스패치입니다.

여기에 OR을 정의하는 가장 전통적인 방법을 사용하여 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보다 크면 리턴되는 것이 참 또는 거짓입니다.

boolean isOR(boolean arg1, boolean arg2){

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

   return (L+R) > 0;

}

두 가지 형태 :

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

또는

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

지금까지의 다른 제안보다 약간 작은 코드 골프와 같은 장점이 있습니다. 따라서 매우 많이 사용되는 프리미티브의 생성을 고려하고 있다면 브랜치 수를 줄이는 것이 어리석은 선택조차 아닙니다.

자바 스크립트의 정의 ||식은 자사 낚아 입력 수단과 결합 된이, 가깝다 false || "abc"값을 보유 "abc"하고 42 || "abc"값을 갖는다 42.

다른 논리 연산자가 이미 있으면 nand(not(arg1), not(arg2))분기가 전혀 없다는 이점이 있습니다.

if 구문을 사용하여 프로그래밍 된 모든 솔루션 외에도 3 개의 NAND 게이트를 결합하여 OR 게이트를 구성 할 수 있습니다. Wikipedia에서 어떻게 수행되는지 보려면 여기를 클릭하십시오 .

이것으로부터 표현은

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)

이것은 단순히 사용 드 모르 강의 법칙 과 학대 사실 *과 유사 &&할 때 true와 false같이 취급 1하고 0각각을. (잠깐, 이것이 코드 골프 가 아니라고 말하고 있습니까?)

여기에 알맞은 답변이 있습니다 :

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

그러나 그것은 이미 주어진 다른 답변과 본질적으로 동일합니다.

정의하는 한 가지 방법 or은 조회 테이블을 이용하는 것입니다. 이를 명시 적으로 만들 수 있습니다.

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

우리는 반환 값이 무엇인지에 따라 필요한 값으로 배열을 만듭니다 a. 그런 다음 조회를 수행합니다. C ++와 같은 언어에서, bool로 배열 인덱스로 사용할 수있는 값으로 촉진 true되고 1그리고 false되 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하면 작동합니다.

위의 기술에는 인수 종속 조회 및 템플릿을 지원하는 언어가 필요합니다. 당신은 아마 generics와 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둘의 합집합을 반환합니다.

이것은 저에게 특징적인 기능을 기억합니다.

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

이것은 부울을 (1, 0)으로 취급 할 수있는 언어에만 적용됩니다. 부울은 클래스이므로 Smalltalk 또는 Python에는 적용되지 않습니다. 스몰 토크에서는 훨씬 더 나아갑니다 (의사 코드로 작성 됨).

False::or(a)
    return a

True::or(a)
    return self

그리고 두 가지 방법이 존재합니다.

False::and(a)
    return self

True::and(a)
    return a

따라서 "논리적"은 상세하지만 OP 문에서 완벽하게 유효합니다. 나쁘지 않습니다. 예를 들어 일종의 행렬을 기반으로 수학 연산자처럼 작동하는 함수가 필요한 경우에 적합합니다. 다른 사람들은 Quine-McCluskey 문과 같은 실제 큐브를 구현합니다.

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

그리고 당신은 평가하거나 [a] [b]

따라서 모든 논리가 유효합니다 (언어 OR 연산자 xDDDDDDDD를 사용하여 게시 된 것을 제외하고).

그러나 내가 가장 좋아하는 것은 DeMorgan의 법칙입니다. !(!a && !b)

Swift 표준 라이브러리를보고 바로 가기 OR 및 바로 가기 AND 연산의 구현을 확인하십시오 . 필요하지 않은 경우 두 번째 피연산자를 평가 하지 않습니다 .

논리는 완벽하지만 간단 할 수 있습니다.

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