对于两个二进制变量A和B，有16个不同的布尔函数：

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   

小于运算符<（通常不被视为NOT，AND或OR之类的逻辑运算符）在应用于布尔值时实际上是以下功能之一（F4）：

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

有趣的是，我们可以使用仅包含符号的表达式来模拟其他 15个函数()<AB10。就像在许多标准编程语言中一样，将读取和评估这些表达式，例如，括号必须匹配，并且<在表达式的两边都必须有参数。

具体来说，这些表达式必须符合以下语法（以Backus-Naur形式给出）：

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

这意味着A<B<1不允许使用无用的parethese和形式的表达式。

因此，表达式A<B与函数F4匹配，并且A<B<1必须将其更改为(A<B)<1或A<(B<1)。

为了证明所有其他15个函数都可以转换为表达式，就足以形成一组功能上完整的表达式，因为根据定义，它们可以组合为任何函数的表达式。

这样的一组表达式是x<1（where xis A或B），is是¬x和and (((B<A)<1)<A)<1，后者是A → B。否定（¬）和蕴含（→）在功能上是完整的。

挑战

使用这些字符()<AB10，以上述形式编写与16个不同的布尔函数中的每一个等效的16个表达式。

目的是使每个表达式都尽可能短。您的分数是16个表达式中每个字符的总和。最低分获胜。Tiebreaker会采用最早的答案（前提是他们以后没有使用别人的简短表达来编辑答案）。

从技术上讲，您不需要为该比赛编写任何实际的代码，但是，如果您确实编写了任何程序来帮助您生成表达式，则强烈建议您发布它们。

您可以使用此堆栈代码片段来检查您的表达式是否符合预期：

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个字符

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

其中一些选项有几个选项，因此此100个字符的设置与以前发布的设置不同。

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

在<功能上更完整的更简单的证明是A<(B<1)给出NOR。

我用来查找此代码的代码大大简化了我在较早的挑战中使用的一些布尔优化代码，但做了两个小的更改：

1. 使表达式的分数成为其字符串的长度，而不是操作数。
2. 使字符串避免不必要的括号，以最小化长度。

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个字符

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个字符

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

嘿，这与其他人不完全相同。我在上面花了10分钟，因此即使2岁也还是值得发布的。

100个字符

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