2つのバイナリ変数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許可されないことを意味します。

したがって、式A<Bは関数F4と一致し、or A<B<1に変更する必要があります。(A<B)<1A<(B<1)

他の15個の関数すべてを式に変換できることを証明するには、機能的に完全な式のセットを形成するだけで十分です。定義により、それらは任意の関数の式に合成できるからです。

このような式のセットの1つはx<1（where xis AまたはB）、つまり¬x、および(((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 を与えることです。

これを見つけるために使用したコードは、以前の課題で使用したブール最適化コードを大幅に単純化したもので、2つの小さな変更があります。

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