Existem 16 funções booleanas distintas para duas variáveis ​​binárias, A e 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   

O operador less than <, que normalmente não é considerado um operador lógico como NOT, AND ou OR, é de fato uma dessas funções (F4) quando aplicada a valores booleanos:

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

Curiosamente, podemos simular qualquer uma das 15 outras funções usando expressões que contêm apenas os símbolos ()<AB10. Essas expressões são lidas e avaliadas exatamente como seriam em muitas linguagens de programação padrão, por exemplo, parênteses devem corresponder e <devem ter argumentos em ambos os lados.

Especificamente, essas expressões devem obedecer à seguinte gramática (fornecida na forma Backus-Naur ):

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

Isso significa que parênteses e expressões inúteis do formulário A<B<1não são permitidos.

Portanto, a expressão A<Bcorresponde à função F4 e A<B<1deve ser alterada para (A<B)<1ou A<(B<1).

Para provar que todas as outras 15 funções podem ser transformadas em expressões, basta formar um conjunto de expressões funcionalmente completas , pois, por definição, elas podem ser compostas em expressões para qualquer função.

Um desses conjuntos de expressões é x<1(onde xé Aou B), qual é ¬xe (((B<A)<1)<A)<1qual é A → B. Negação ( ¬) e implicação ( →) são conhecidas por serem funcionalmente completas.

Desafio

Usando os caracteres ()<AB10, escreva 16 expressões no formulário descrito acima que são equivalentes a cada uma das 16 funções booleanas distintas.

O objetivo é tornar cada uma das expressões o mais curta possível. Sua pontuação é a soma do número de caracteres em cada uma de suas 16 expressões. A pontuação mais baixa vence. O desempatador vai para a resposta mais antiga (desde que não tenha editado sua resposta posteriormente com expressões mais curtas tiradas de outra pessoa).

Tecnicamente, você não precisa escrever nenhum código real para este concurso, mas se você criou algum programa para ajudá-lo a gerar as expressões, é altamente recomendável publicá-las.

Você pode usar este snippet de pilha para verificar se suas expressões fazem o que é esperado:

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 caracteres

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

Existem algumas opções para algumas delas, portanto, este conjunto de 100 caracteres não é idêntico ao publicado anteriormente.

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

Uma prova mais fácil, <funcionalmente completa, seria a A<(B<1)NOR.

O código que eu usei para encontrar isso é uma simplificação pesada de algum código de otimização booleano que usei em desafios anteriores, com duas pequenas alterações:

1. Faça com que a pontuação de uma expressão seja o comprimento de sua sequência e não o número de operações.
2. Faça com que a cadeia evite parênteses desnecessários, para minimizar o comprimento.

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 caracteres

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 caracteres

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

Ei, não é exatamente o mesmo que os outros. Eu gastei 10 minutos nisso, então vale a pena postar de qualquer maneira, mesmo que ele tenha 2 anos de idade.

100 caracteres

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