Es gibt 16 verschiedene Boolesche Funktionen für zwei Binärvariablen, A und 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   

Der less than-Operator <, der normalerweise nicht als logischer Operator wie NOT, AND oder OR aufgefasst wird, ist tatsächlich eine der folgenden Funktionen (F4), wenn er auf boolesche Werte angewendet wird:

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

Interessanterweise können wir jede der 15 anderen Funktionen mit Ausdrücken simulieren , die nur die Symbole enthalten ()<AB10. Diese Ausdrücke werden wie in vielen Standard-Programmiersprachen gelesen und ausgewertet, z. B. müssen Klammern übereinstimmen und <Argumente auf beiden Seiten enthalten.

Insbesondere müssen diese Ausdrücke der folgenden Grammatik entsprechen (in Backus-Naur-Form angegeben ):

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

Dies bedeutet, dass nutzlose Parethesen und Ausdrücke des Formulars A<B<1nicht erlaubt sind.

Der Ausdruck A<Bentspricht also der Funktion F4 und A<B<1muss in (A<B)<1oder geändert werden A<(B<1).

Um zu beweisen, dass alle 15 anderen Funktionen in Ausdrücke umgewandelt werden können, genügt es, eine Menge von Ausdrücken zu bilden, die funktional vollständig sind , da sie dann per Definition zu Ausdrücken für jede Funktion zusammengesetzt werden können.

Eine solche Menge von Ausdrücken ist x<1(wo xist Aoder B), was ist ¬xund (((B<A)<1)<A)<1was ist A → B. Negation ( ¬) und Implication ( →) sind bekanntermaßen funktional vollständig.

Herausforderung

()<AB10Schreiben Sie unter Verwendung der Zeichen 16 Ausdrücke in der oben beschriebenen Form, die jeder der 16 verschiedenen Booleschen Funktionen entsprechen.

Ziel ist es, jeden Ausdruck so kurz wie möglich zu halten. Ihre Punktzahl ist die Summe der Anzahl der Zeichen in jedem Ihrer 16 Ausdrücke. Die niedrigste Punktzahl gewinnt. Tiebreaker geht zur frühesten Antwort über (vorausgesetzt, sie haben ihre Antwort später nicht mit kürzeren Ausdrücken bearbeitet, die von jemand anderem stammen).

Sie müssen technisch gesehen keinen echten Code für diesen Wettbewerb schreiben. Wenn Sie jedoch Programme geschrieben haben, die Sie beim Generieren der Ausdrücke unterstützen, wird dringend empfohlen, diese zu veröffentlichen.

Mit diesem Stack-Snippet können Sie überprüfen, ob Ihre Ausdrücke den Erwartungen entsprechen:

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 Zeichen

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

Für einige von ihnen gibt es einige Optionen, sodass dieses 100-Zeichen-Set nicht mit den zuvor veröffentlichten identisch ist.

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

Ein einfacherer Beweis, der <funktional vollständig ist, wäre, dass A<(B<1)NOR ergibt.

Der Code, den ich verwendet habe, um dies zu finden, ist eine starke Vereinfachung eines Booleschen Optimierungscodes, den ich bei früheren Herausforderungen verwendet habe, mit zwei kleinen Änderungen:

1. Stellen Sie die Punktzahl eines Ausdrucks auf die Länge der Zeichenfolge und nicht auf die Anzahl der Operationen ein.
2. Vermeiden Sie unnötige Klammern, um die Länge zu minimieren.

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 Zeichen

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 Zeichen

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

Hey, es ist nicht genau dasselbe wie die anderen. Ich habe ungefähr 10 Minuten damit verbracht, es lohnt sich also trotzdem etwas zu posten, auch wenn dies 2 Jahre alt ist.

100 Zeichen

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