Esistono 16 funzioni booleane distinte per due variabili binarie, 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   

L'operatore minore di <, che normalmente non è considerato un operatore logico come NOT, AND o OR, è in effetti una di queste funzioni (F4) quando applicata a valori booleani:

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

È interessante notare che possiamo simulare una qualsiasi delle altre 15 funzioni usando espressioni che contengono solo i simboli ()<AB10. Queste espressioni vengono lette e valutate come in molti linguaggi di programmazione standard, ad esempio le parentesi devono corrispondere e <devono avere argomenti su entrambi i lati.

Nello specifico, queste espressioni devono rispettare la seguente grammatica (indicata in forma di Backus-Naur ):

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

Ciò significa che A<B<1non sono consentite inutili paretesi ed espressioni del modulo .

Quindi l'espressione A<Bcorrisponde alla funzione F4 e A<B<1deve essere cambiata in (A<B)<1o A<(B<1).

Per dimostrare che tutte le 15 altre funzioni possono essere trasformate in espressioni, è sufficiente formare un insieme di espressioni funzionalmente complete , perché quindi, per definizione, possono essere composte in espressioni per qualsiasi funzione.

Una di queste serie di espressioni è x<1(dove xè Ao B), che è ¬xe (((B<A)<1)<A)<1che è A → B. Negazione ( ¬) e implicazione ( →) sono noti per essere funzionalmente completi.

Sfida

Usando i caratteri ()<AB10, scrivi 16 espressioni nella forma sopra descritta che sono equivalenti a ciascuna delle 16 distinte funzioni booleane.

L'obiettivo è rendere ciascuna delle espressioni il più breve possibile. Il tuo punteggio è la somma del numero di caratteri in ciascuna delle tue 16 espressioni. Vince il punteggio più basso. Tiebreaker arriva alla prima risposta (a condizione che non abbiano modificato la loro risposta in seguito con espressioni più brevi prese da qualcun altro).

Tecnicamente non è necessario scrivere alcun codice reale per questo concorso, ma se hai scritto programmi per aiutarti a generare le espressioni, sei fortemente incoraggiato a pubblicarle.

Puoi utilizzare questo frammento di stack per verificare se le tue espressioni fanno ciò che è previsto:

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 caratteri

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

Ci sono alcune opzioni per alcuni di questi, quindi questo set da 100 caratteri non è identico a quelli precedentemente pubblicati.

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

Una prova più semplice <funzionalmente completa sarebbe quella che A<(B<1)fornisce NOR.

Il codice che ho usato per trovare questo è una pesante semplificazione di alcuni codici di ottimizzazione booleani che ho usato nelle sfide precedenti, con due piccole modifiche:

1. Fai in modo che il punteggio di un'espressione sia la lunghezza della sua stringa anziché il numero di operazioni.
2. Fai in modo che la stringa eviti le parentesi non necessarie, per ridurre al minimo la lunghezza.

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 caratteri

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 caratteri

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

Ehi, non è esattamente lo stesso degli altri. Ho impiegato circa 10 minuti per questo, quindi vale la pena pubblicarlo comunque, anche se ha 2 anni.

100 caratteri

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