Gần đây, tôi đã gặp một vấn đề yêu cầu tôi xác định toán tử "HOẶC" hợp lý theo chương trình, nhưng không sử dụng chính toán tử.

Những gì tôi nghĩ ra là đây:

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

Là logic này đúng, hoặc tôi đã bỏ lỡ một cái gì đó?

Tôi muốn nói điều đó đúng, nhưng bạn có thể không cô đọng nó xuống một cái gì đó như thế này không?

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

    return false

Vì bạn đang thực hiện hoặc so sánh, tôi không nghĩ bạn thực sự cần kiểm tra kết hợp. Nó chỉ quan trọng nếu một trong số chúng là đúng để trở về đúng. Nếu không, chúng tôi muốn trả lại sai.

Nếu bạn đang tìm kiếm một phiên bản ngắn hơn ít dài dòng hơn, thì điều này cũng sẽ hoạt động:

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

Đây là một giải pháp không có hoặc, và, không, so sánh và boolean nghĩa đen:

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

Nó có thể không nhận được nhiều cơ bản hơn thế;)

Một dòng mã:

return not (not arg1 and not arg2)

Không phân nhánh, không HOẶC.

Trong ngôn ngữ dựa trên C, nó sẽ là:

return !(!arg1 && !arg2);

Đây chỉ đơn giản là một ứng dụng của luật De Morgan :(A || B) == !(!A && !B)

Nếu bạn chỉ có andvà not, bạn có thể sử dụng luật của DeMorgan để lật lại and:

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

... hoặc (thậm chí đơn giản hơn)

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

...

Và vì tất cả chúng ta rõ ràng đã trở nên cố định trong việc tối ưu hóa một cái gì đó hầu như luôn có sẵn như một hướng dẫn máy móc, điều đó có nghĩa là:

return not(not arg1 and not arg2)

return arg1 ? true : arg2

v.v ... v.v.

Vì hầu hết các ngôn ngữ cung cấp một điều kiện - và, tỷ lệ cược là toán tử "và" ngụ ý một nhánh.

...

Nếu tất cả những gì bạn có là nand(xem wikipedia ):

return nand (nand (arg1, arg1), nand (arg2, arg2))

Hàm (ECMAScript)

Tất cả bạn cần là định nghĩa chức năng và các cuộc gọi chức năng. Bạn không cần bất kỳ chức năng phân nhánh, điều kiện, toán tử hoặc hàm dựng sẵn. Tôi sẽ chứng minh việc thực hiện bằng ECMAScript.

Đầu tiên, hãy xác định hai hàm được gọi truevà false. Chúng ta có thể định nghĩa chúng theo bất kỳ cách nào chúng ta muốn, chúng hoàn toàn tùy ý, nhưng chúng ta sẽ định nghĩa chúng theo một cách rất đặc biệt có một số lợi thế như chúng ta sẽ thấy sau:

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

trulà một hàm có hai tham số đơn giản bỏ qua đối số thứ hai và trả về tham số thứ nhất. flscũng là một hàm có hai tham số đơn giản bỏ qua đối số thứ nhất và trả về tham số thứ hai.

Tại sao chúng ta mã hóa truvà flstheo cách này? Vâng, theo cách này, hai hàm không chỉ đại diện cho hai khái niệm truevà false, không, đồng thời, chúng còn đại diện cho khái niệm "sự lựa chọn", nói cách khác, chúng cũng là một if/ then/ elsebiểu thức! Chúng tôi đánh giá ifđiều kiện và truyền cho nó thenkhối và elsekhối làm đối số. Nếu điều kiện ước tính tru, nó sẽ trả về thenkhối, nếu nó ước lượng fls, nó sẽ trả về elsekhối. Đây là một ví dụ:

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

Điều này trả về 23, và điều này:

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

trả lại 42, như bạn mong đợi

Có một nếp nhăn, tuy nhiên:

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

Điều này in cả then branch và else branch! Tại sao?

Chà, nó trả về giá trị trả về của đối số đầu tiên, nhưng nó đánh giá cả hai đối số, vì ECMAScript rất nghiêm ngặt và luôn đánh giá tất cả các đối số cho một hàm trước khi gọi hàm. IOW: nó đánh giá đối số đầu tiên console.log("then branch"), đơn giản là trả về undefinedvà có tác dụng phụ của việc in then branchra bàn điều khiển, và nó đánh giá đối số thứ hai, cũng trả về undefinedvà in ra bàn điều khiển như một hiệu ứng phụ. Sau đó, nó trả về đầu tiên undefined.

Trong calcul-compus, nơi mã hóa này được phát minh, đó không phải là vấn đề:-compus là thuần túy , có nghĩa là nó không có bất kỳ tác dụng phụ nào; do đó, bạn sẽ không bao giờ nhận thấy rằng đối số thứ hai cũng được đánh giá. Thêm vào đó,-compus là lười biếng (hoặc ít nhất, nó thường được đánh giá theo thứ tự thông thường), có nghĩa là, nó không thực sự đánh giá các đối số không cần thiết. Vì vậy, IOW: trong-tính toán, đối số thứ hai sẽ không bao giờ được đánh giá, và nếu có, chúng tôi sẽ không chú ý.

ECMAScript, tuy nhiên, là nghiêm ngặt , tức là nó luôn đánh giá tất cả các đối số. Vâng, trên thực tế, không phải lúc nào: sự if/ then/ else, ví dụ, chỉ đánh giá các thenchi nhánh nếu điều kiện là truevà chỉ đánh giá các elsechi nhánh nếu điều kiện là false. Và chúng tôi muốn nhân rộng hành vi này với iff. Rất may, mặc dù ECMAScript không lười biếng, nhưng có một cách để trì hoãn việc đánh giá một đoạn mã, giống như hầu hết mọi ngôn ngữ khác: bọc nó trong một hàm và nếu bạn không bao giờ gọi hàm đó, mã sẽ không bao giờ được thực hiện.

Vì vậy, chúng tôi bọc cả hai khối trong một hàm và cuối cùng gọi hàm được trả về:

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

in then branchvà

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

in else branch.

Chúng ta có thể thực hiện truyền thống if/ then/ elsetheo cách này:

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

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

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

Một lần nữa, chúng ta cần một số gói chức năng bổ sung khi gọi iffhàm và hàm bổ sung gọi dấu ngoặc đơn trong định nghĩa của iff, với cùng lý do như trên:

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

Bây giờ chúng ta có hai định nghĩa đó, chúng ta có thể thực hiện or. Đầu tiên, chúng ta nhìn vào bảng chân lý cho or: nếu toán hạng đầu tiên là trung thực, thì kết quả của biểu thức giống như toán hạng đầu tiên. Mặt khác, kết quả của biểu thức là kết quả của toán hạng thứ hai. Tóm lại: nếu toán hạng thứ nhất là true, chúng ta trả về toán hạng thứ nhất, nếu không chúng ta trả về toán hạng thứ hai:

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

Hãy kiểm tra xem nó hoạt động:

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

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

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

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

Tuyệt quá! Tuy nhiên, định nghĩa đó có vẻ hơi xấu xí. Hãy nhớ, truvà flsđã hành động như một điều kiện một mình, vì vậy thực sự không cần thiết iff, và do đó tất cả các chức năng đó bao gồm tất cả:

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

Ở đó bạn có nó: or(cộng với các toán tử boolean khác) được định nghĩa không có gì ngoài các định nghĩa hàm và các hàm gọi chỉ trong một số dòng:

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

Thật không may, việc triển khai này khá vô dụng: không có hàm hoặc toán tử nào trong ECMAScript trả về truhoặc fls, tất cả chúng đều trả về truehoặc false, vì vậy chúng ta không thể sử dụng chúng với các hàm của mình. Nhưng vẫn còn rất nhiều điều chúng ta có thể làm. Ví dụ: đây là một triển khai danh sách liên kết đơn:

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

Đối tượng (Scala)

Bạn có thể nhận thấy một cái gì đó đặc biệt: truvà flsđóng một vai trò kép, chúng hoạt động cả hai như là các giá trị dữ liệu truevà false, nhưng đồng thời, họ cũng đóng vai trò như một biểu thức điều kiện. Chúng là dữ liệu và hành vi , được kết hợp thành một đối tượng "điều" hay khác (tôi dám nói) !

Thật vậy, truvà flslà đối tượng. Và, nếu bạn đã từng sử dụng Smalltalk, Self, Drameak hoặc các ngôn ngữ hướng đối tượng khác, bạn sẽ nhận thấy rằng chúng thực hiện booleans theo cùng một cách chính xác. Tôi sẽ chứng minh một triển khai như vậy ở đây trong 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 này là lý do tại sao Công cụ tái cấu trúc đa hình thay thế luôn hoạt động: bạn luôn có thể thay thế bất kỳ và mọi điều kiện trong chương trình của bạn bằng việc gửi tin nhắn đa hình, bởi vì như chúng tôi vừa trình bày, việc gửi tin nhắn đa hình có thể thay thế điều kiện bằng cách đơn giản thực hiện chúng. Các ngôn ngữ như Smalltalk, Self và Drameak là bằng chứng tồn tại cho điều đó, bởi vì những ngôn ngữ đó thậm chí không có điều kiện. (Họ cũng không có các vòng lặp, BTW hoặc thực sự là bất kỳ loại cấu trúc điều khiển tích hợp ngôn ngữ nào ngoại trừ việc gửi tin nhắn đa hình hay còn gọi là phương thức ảo.)

Kết hợp mẫu (Haskell)

Bạn cũng có thể xác định orbằng cách sử dụng khớp mẫu hoặc một cái gì đó như định nghĩa hàm một phần của Haskell:

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

Tất nhiên, khớp mẫu là một hình thức thực hiện có điều kiện, nhưng sau đó, một lần nữa, việc gửi thông điệp hướng đối tượng cũng vậy.

Đây là một cách khác để định nghĩa OR, hoặc thực sự là bất kỳ toán tử logic nào, sử dụng cách định nghĩa truyền thống nhất: sử dụng bảng chân lý.

Tất nhiên điều này khá đơn giản để thực hiện bằng các ngôn ngữ cấp cao hơn như Javascript hoặc Perl nhưng tôi đang viết ví dụ này bằng C để cho thấy rằng kỹ thuật này không phụ thuộc vào các tính năng ngôn ngữ cấp cao:

#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");
    }
}

Bạn có thể làm tương tự với AND, NOR, NAND, NOT và XOR. Mã này đủ sạch để trông giống như cú pháp để bạn có thể làm những thứ như thế này:

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

Một cách khác để biểu thị các toán tử logic dưới dạng biểu thức số học số nguyên (khi khả thi). Cách này có thể tránh được nhiều nhánh cho biểu thức lớn hơn của nhiều vị từ ..

Đặt True là 1 Đặt sai là 0

nếu tổng của cả hai lớn hơn 1 thì trả về đúng hay sai.

boolean isOR(boolean arg1, boolean arg2){

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

   return (L+R) > 0;

}

Hai hình thức:

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

HOẶC LÀ

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

Có lợi thế giống như mã golf nhỏ hơn một chút so với các đề xuất khác cho đến nay, một nhánh ít hơn. Thậm chí đó không phải là một lựa chọn vi mô ngớ ngẩn để giảm số lượng chi nhánh nếu chúng ta đang xem xét việc tạo ra một nguyên thủy do đó sẽ được sử dụng rất nhiều.

Định nghĩa của Javascript ||gần giống với điều này, kết hợp với việc gõ lỏng có nghĩa là biểu thức false || "abc"có giá trị "abc"và 42 || "abc"có giá trị 42.

Mặc dù nếu bạn đã có các toán tử logic khác thì việc thích nand(not(arg1), not(arg2))có thể có lợi thế là không có nhánh nào cả.

Ngoài tất cả các giải pháp được lập trình bằng cách sử dụng cấu trúc if, có thể xây dựng cổng OR bằng cách kết hợp ba cổng NAND. Nếu bạn muốn xem nó được thực hiện như thế nào trong wikipedia, bấm vào đây .

Từ đây, biểu thức,

KHÔNG [KHÔNG (A VÀ A) VÀ KHÔNG (B VÀ B)]

trong đó sử dụng KHÔNG và AND cho câu trả lời giống như OR. Lưu ý rằng việc sử dụng cả KHÔNG và AND chỉ là một cách khó hiểu để thể hiện NAND.

Tất cả các câu trả lời tốt đã được đưa ra. Nhưng tôi sẽ không để điều đó ngăn cản tôi.

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

Cách khác:

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

Tôi hy vọng không ai sẽ thực sự sử dụng các phương pháp như thế này. Họ ở đây chỉ để thúc đẩy nhận thức về các lựa chọn thay thế.

Cập nhật:

Vì các số âm có thể phá vỡ cả hai cách tiếp cận trên, đây là một gợi ý khủng khiếp khác:

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

Điều này chỉ đơn giản là sử dụng Luật của DeMorgan và lạm dụng thực tế *tương tự như &&khi truevà falseđược đối xử như thế nào 1và 0tương ứng. (Đợi đã, bạn đang nói đây không phải là mã golf?)

Đây là một câu trả lời đúng:

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

Nhưng về cơ bản là giống hệt với các câu trả lời khác đã được đưa ra.

Một cách để xác định orlà thông qua bảng tra cứu. Chúng ta có thể làm rõ điều này:

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

chúng ta tạo một mảng với các giá trị mà giá trị trả về nên có tùy thuộc vào giá trị nào a. Sau đó, chúng tôi làm một tra cứu. Trong C ++ như ngôn ngữ, boolthúc đẩy đến một giá trị có thể được sử dụng như một chỉ số mảng, với trueviệc 1và falsetrở 0.

Sau đó chúng ta có thể mở rộng điều này sang các hoạt động logic khác:

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];
}

Bây giờ một nhược điểm của tất cả những điều này là nó yêu cầu ký hiệu tiền tố.

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];
}

và bây giờ bạn có thể gõ true *OR* falsevà nó hoạt động.

Kỹ thuật trên yêu cầu một ngôn ngữ hỗ trợ tra cứu phụ thuộc đối số và các mẫu. Bạn có thể có thể làm điều đó bằng một ngôn ngữ với thuốc generic và ADL.

Bên cạnh, bạn có thể mở rộng *OR*ở trên để làm việc với các bộ. Chỉ cần tạo một hàm miễn phí invoketrong cùng một không gian tên như 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;
}

và bây giờ set *OR* settrả lại sự kết hợp của hai.

Điều này nhớ cho tôi các chức năng charasteristic:

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

Điều này chỉ áp dụng cho các ngôn ngữ có thể coi booleans là (1, 0). Không áp dụng cho Smalltalk hoặc Python vì boolean là một lớp. Trong smalltalk họ còn đi xa hơn (điều này sẽ được viết bằng mã giả):

False::or(a)
    return a

True::or(a)
    return self

Và các phương thức kép tồn tại cho và:

False::and(a)
    return self

True::and(a)
    return a

Vì vậy, "logic" là hoàn toàn hợp lệ trong câu lệnh OP, mặc dù nó dài dòng. Coi chừng, nó không tệ. Thật hoàn hảo nếu bạn cần một hàm hoạt động như một toán tử toán học dựa trên một loại ma trận. Những người khác sẽ triển khai một khối thực tế (như câu lệnh Quine-McCluskey):

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

Và bạn sẽ đánh giá hoặc [a] [b]

Vì vậy, có, mọi logic ở đây là hợp lệ (ngoại trừ một logic được đăng dưới dạng sử dụng toán tử OR ngôn ngữ xDDDDDDDD).

Nhưng điều tôi thích nhất là luật của DeMorgan: !(!a && !b)

Nhìn vào thư viện chuẩn Swift và kiểm tra việc họ thực hiện các phím tắt HOẶC và các thao tác AND tắt, không đánh giá các toán hạng thứ hai nếu không cần thiết / cho phép.

Logic là hoàn toàn chính xác, nhưng có thể được đơn giản hóa:

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

Và có lẽ ngôn ngữ của bạn có toán tử OR - trừ khi nó trái với tinh thần của câu hỏi - tại sao không

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