Є 16 різних булевих функцій для двох бінарних змінних, A і 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   

Менше, ніж оператор <, який зазвичай не вважається логічним оператором, як 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, і його A<B<1потрібно змінити на (A<B)<1або A<(B<1).

Щоб довести, що всі 15 інших функцій можна перетворити на вирази, достатньо сформувати набір виразів, які є функціонально завершеними , тому що тоді, за визначенням, вони можуть бути складені в вирази для будь-якої функції.

Одним із таких наборів виразів є x<1(де xє 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.

Код, за допомогою якого я знаходив це, - це сильне спрощення деякого булевого коду оптимізації, який я використовував у попередніх завданнях, з двома невеликими змінами:

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