Có 16 hàm boolean riêng biệt cho hai biến nhị phân A và B:

A B | F0 | F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8 | F9 | F10 | F11 | F12 | F13 | F14 | F15
-----------------------------------------------------------------------------------------
0 0 | 0  | 0  | 0  | 0  | 0  | 0  | 0  | 0  | 1  | 1  | 1   | 1   | 1   | 1   | 1   | 1  
0 1 | 0  | 0  | 0  | 0  | 1  | 1  | 1  | 1  | 0  | 0  | 0   | 0   | 1   | 1   | 1   | 1  
1 0 | 0  | 0  | 1  | 1  | 0  | 0  | 1  | 1  | 0  | 0  | 1   | 1   | 0   | 0   | 1   | 1  
1 1 | 0  | 1  | 0  | 1  | 0  | 1  | 0  | 1  | 0  | 1  | 0   | 1   | 0   | 1   | 0   | 1   

Toán tử nhỏ hơn toán tử <, thường không được coi là toán tử logic như KHÔNG, AND hoặc OR, trên thực tế là một trong những hàm này (F4) khi được áp dụng cho các giá trị boolean:

A B | A < B
-----------
0 0 | 0
0 1 | 1
1 0 | 0
1 1 | 0

Thật thú vị, chúng ta có thể mô phỏng bất kỳ trong số 15 hàm khác bằng các biểu thức chỉ chứa các ký hiệu ()<AB10. Các biểu thức này được đọc và đánh giá giống như trong các ngôn ngữ lập trình tiêu chuẩn, ví dụ: dấu ngoặc đơn phải khớp và <phải có đối số ở hai bên của nó.

Cụ thể, các biểu thức này phải tuân thủ ngữ pháp sau (được đưa ra dưới dạng Backus-Naur ):

element ::= A | B | 1 | 0
expression ::= element<element | (expression)<element | element<(expression) | (expression)<(expression)

Điều này có nghĩa là các mệnh đề và biểu thức vô dụng của biểu mẫu A<B<1không được phép.

Vì vậy, biểu thức A<Bphù hợp với chức năng F4 và A<B<1phải được thay đổi thành (A<B)<1hoặc A<(B<1).

Để chứng minh rằng tất cả 15 chức năng khác có thể được chuyển thành biểu thức, nó đủ để tạo thành một tập hợp các biểu thức được hoàn thành về mặt chức năng , bởi vì theo định nghĩa, chúng có thể được tạo thành biểu thức cho bất kỳ chức năng nào.

Một tập hợp các biểu thức như vậy là x<1(where xis Ahoặc B), is ¬x, and (((B<A)<1)<A)<1, is A → B. Phủ định ( ¬) và hàm ý ( →) được biết là hoàn thành chức năng.

Thử thách

Sử dụng các ký tự ()<AB10, viết 16 biểu thức theo mẫu được mô tả ở trên tương đương với mỗi trong số 16 hàm boolean riêng biệt.

Mục tiêu là làm cho mỗi biểu thức càng ngắn càng tốt. Điểm của bạn là tổng số lượng ký tự trong mỗi 16 biểu thức của bạn. Điểm thấp nhất sẽ thắng. Tiebreaker đi đến câu trả lời sớm nhất (với điều kiện họ không chỉnh sửa câu trả lời của họ sau đó với các biểu thức ngắn hơn được lấy từ người khác).

Về mặt kỹ thuật, bạn không cần phải viết bất kỳ mã thực sự nào cho cuộc thi này nhưng nếu bạn đã viết bất kỳ chương trình nào để giúp bạn tạo các biểu thức, bạn rất khuyến khích đăng chúng.

Bạn có thể sử dụng Stack Snippet này để kiểm tra xem biểu thức của bạn có làm những gì được mong đợi không:

function check() {
  var input = document.getElementById('input').value.split('\n'), output = ''
  if (input.length == 1 && input[0].length == 0)
    input = []
  
  for (var i = 0; i < 16; i++) {
    var expected = [(i & 8) >> 3, (i & 4) >> 2, (i & 2) >> 1, i & 1]
    
    output += 'F' + i.toString() + '\nA B | expected | actual\n-----------------------\n'
    for (var j = 0; j < 4; j++) {
      var A = (j & 2) >> 1, B = j & 1, actual = '?'
      if (i < input.length) {
        try {
          actual = eval(input[i]) ? 1 : 0
        } catch (e) {}
      }
      
      output += A.toString() + ' ' + B.toString() +
        ' | ' + expected[j] + '        | ' + actual.toString() + '     '
      if (expected[j] != actual)
        output += ' <- MISMATCH'
      if (j != 3)
        output += '\n'
    }
    if (i != 15)
      output += '\n\n'
  }
  document.getElementById('output').value = output
}

<textarea id='input' rows='16' cols='64' placeholder='put all 16 expressions here in order, one per line...'></textarea><br><br>
<button type='button' onclick='check()'>Check</button><br><br>
<textarea id='output' rows='16' cols='64' placeholder='results...'></textarea><br>
"?" means there was some sort of error

100 ký tự

0
(A<1)<B
B<A
A
A<B
B
((B<A)<((A<B)<1))<1
(A<(B<1))<1
A<(B<1)
(B<A)<((A<B)<1)
B<1
(A<B)<1
A<1
(B<A)<1
((A<1)<B)<1
1

Có một vài lựa chọn cho một vài trong số này, vì vậy bộ 100 ký tự này không giống với các tùy chọn được đăng trước đó.

0
(B<A)<A
B<A
A
A<B
B
((A<B)<((B<A)<1))<1
(A<(B<1))<1
A<(B<1)
(A<B)<((B<A)<1)
B<1
(A<B)<1
A<1
(B<A)<1
((B<A)<A)<1
1

Một bằng chứng dễ dàng hơn về mặt <chức năng sẽ là A<(B<1)cung cấp cho NOR.

Mã mà tôi đã sử dụng để tìm thấy điều này là một sự đơn giản hóa nặng nề của một số mã tối ưu hóa Boolean tôi đã sử dụng cho các thách thức trước đó, với hai thay đổi nhỏ:

1. Đặt điểm của biểu thức là độ dài của chuỗi chứ không phải số lượng thao tác.
2. Làm cho chuỗi tránh các dấu ngoặc đơn không cần thiết, để giảm thiểu độ dài.

import java.util.*;

public class PPCG48193 {

    public static void main(String[] args) {
        Expr[] optimal = new Expr[16];
        int unfound = 16;

        PriorityQueue<Expr> q = new PriorityQueue<Expr>();
        q.offer(new Expr(0, "0"));
        q.offer(new Expr(15, "1"));
        q.offer(new Expr(3, "A"));
        q.offer(new Expr(5, "B"));
        while (unfound > 0) {
            Expr e = q.poll();
            if (optimal[e.val] != null) continue;

            optimal[e.val] = e;
            unfound--;
            for (Expr e2 : optimal) {
                if (e2 != null) {
                    Expr e3 = e.op(e2), e4 = e2.op(e);
                    if (optimal[e3.val] == null) q.offer(e3);
                    if (optimal[e4.val] == null) q.offer(e4);
                }
            }
        }

        for (Expr e : optimal) System.out.println(e.expr);
    }

    private static class Expr implements Comparable<Expr> {
        public final int val;
        public String expr;

        public Expr(int val, String expr) {
            this.val = val;
            this.expr = expr;
        }

        public Expr op(Expr e) {
            String l = expr.contains("<") ? String.format("(%s)", expr) : expr;
            String r = e.expr.contains("<") ? String.format("(%s)", e.expr) : e.expr;
            return new Expr((15 - val) & e.val, String.format("%s<%s", l, r));
        }

        public int compareTo(Expr e) {
            int cmp = expr.length() - e.expr.length();
            if (cmp == 0) cmp = val - e.val;
            return cmp;
        }
    }
}

100 ký tự

0
(A<B)<B
B<A
A
A<B
B
((A<B)<((B<A)<1))<1
(B<(A<1))<1
B<(A<1)
(A<B)<((B<A)<1)
B<1
(A<B)<1
A<1
(B<A)<1
((A<B)<B)<1
1

100 ký tự

0
(A<1)<B
B<A
A
A<B
B
((A<B)<((B<A)<1))<1
((B<1)<A)<1
(B<1)<A
(A<B)<((B<A)<1)
B<1
(A<B)<1
A<1
(B<A)<1
((A<1)<B)<1
1

Hey, nó không phải là chính xác giống như những người khác. Tôi đã dành khoảng 10 phút cho việc này vì vậy nó đáng để đăng tải dù sao đi nữa, ngay cả khi điều này đã 2 tuổi.

100 ký tự

0
(A<1)<B
B<A
A
A<B
B
((A<B)<((B<A)<1))<1
(A<(B<1))<1
A<(B<1)
(A<B)<((B<A)<1)
B<1
(A<B)<1
A<1
(B<A)<1
((B<1)<A)<1
1