Il existe 16 fonctions booléennes distinctes pour deux variables binaires, A et 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'opérateur less than <, qui n'est normalement pas considéré comme un opérateur logique comme NOT, AND ou OR, est en fait l'une de ces fonctions (F4) lorsqu'il est appliqué à des valeurs booléennes:

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

Fait intéressant, nous pouvons simuler l' une des 15 autres fonctions en utilisant des expressions qui ne contiennent que les symboles ()<AB10. Ces expressions sont lues et évaluées comme elles le seraient dans de nombreux langages de programmation standard, par exemple, les parenthèses doivent correspondre et <doivent avoir des arguments de chaque côté.

Plus précisément, ces expressions doivent respecter la grammaire suivante (donnée sous forme Backus-Naur ):

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

Cela signifie que les paréthèses et expressions inutiles de la forme A<B<1ne sont pas autorisées.

L'expression A<Bcorrespond donc à la fonction F4 et A<B<1doit être remplacée par (A<B)<1ou A<(B<1).

Pour prouver que les 15 autres fonctions peuvent être transformées en expressions, il suffit de former un ensemble d'expressions fonctionnellement complet , car alors, par définition, elles peuvent être composées en expressions pour n'importe quelle fonction.

Un tel ensemble d'expressions est x<1(où xest Aou B), qui est ¬x, et (((B<A)<1)<A)<1qui est A → B. La négation ( ¬) et l'implication ( →) sont connues pour être fonctionnellement complètes.

Défi

À l'aide des caractères ()<AB10, écrivez 16 expressions sous la forme décrite ci-dessus qui sont équivalentes à chacune des 16 fonctions booléennes distinctes.

L'objectif est de rendre chacune des expressions aussi courte que possible. Votre score est la somme du nombre de caractères dans chacune de vos 16 expressions. Le score le plus bas l'emporte. Tiebreaker passe à la première réponse (à condition qu'ils n'aient pas modifié leur réponse plus tard avec des expressions plus courtes empruntées à quelqu'un d'autre).

Techniquement, vous n'avez pas besoin d'écrire de code réel pour ce concours, mais si vous avez écrit des programmes pour vous aider à générer les expressions, vous êtes fortement encouragés à les publier.

Vous pouvez utiliser cet extrait de pile pour vérifier si vos expressions font ce qui est attendu:

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 caractères

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

Il y a quelques options pour certains d'entre eux, donc cet ensemble de 100 caractères n'est pas identique à ceux précédemment publiés.

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

Une preuve plus simple et <fonctionnellement complète serait celle qui A<(B<1)donne NOR.

Le code que j'ai utilisé pour trouver ceci est une simplification lourde d'un code d'optimisation booléen que j'ai utilisé sur des défis précédents, avec deux petits changements:

1. Faites en sorte que le score d'une expression soit la longueur de sa chaîne plutôt que le nombre d'opérations.
2. Faites en sorte que la chaîne évite les parenthèses inutiles, pour minimiser la longueur.

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 caractères

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 caractères

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

Hé, ce n'est pas exactement la même chose que les autres. J'ai passé environ 10 minutes là-dessus donc ça vaut quand même la peine de poster, même si c'est 2 ans.

100 caractères

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