A ve B olmak üzere iki ikili değişken için 16 farklı boole işlevi vardır :

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   

Operatör daha az <normal DEĞİL gibi bir mantık operatörü olarak düşünülebilir VE veya VEYA değildir, boole değerlerine uygulanan bu fonksiyonların (F4) gerçeği birinde olur:

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

İlginç bir şekilde, sadece sembolleri içeren ifadeleri kullanarak diğer 15 fonksiyondan herhangi birini simüle edebiliriz ()<AB10. Bu ifadeler tıpkı birçok standart programlama dilinde olduğu gibi okunur ve değerlendirilir, örneğin parantezler eşleşmeli ve <her iki tarafında da argümanlar bulunmalıdır.

Özellikle, bu ifadeler aşağıdaki dilbilgisine ( Backus-Naur formunda verilir ) uygun olmalıdır:

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

Bu, işe yaramaz parantezlere ve formun ifadelerine A<B<1izin verilmediği anlamına gelir .

Dolayısıyla ifade A<BF4 işleviyle eşleşir ve veya A<B<1olarak değiştirilmelidir .(A<B)<1A<(B<1)

Diğer 15 fonksiyonun hepsinin ifadeye dönüştürülebildiğini kanıtlamak için, işlevsel olarak tamamlanmış bir dizi ifade oluşturmak yeterlidir , çünkü daha sonra tanım gereği, herhangi bir fonksiyon için ifadelere dönüştürülebilirler.

İfadelerin Bu gibi bir dizi x<1(burada xolduğu Aya da B) olan ¬x, ve (((B<A)<1)<A)<1ki, A → B. Negation ( ¬) ve implication ( →) işlevlerinin işlevsel olarak tamamlandığı bilinmektedir .

Meydan okuma

Karakterleri kullanarak, ()<AB1016 farklı boolean fonksiyonunun her birine eşdeğer olan yukarıda açıklanan formda 16 ifade yazın.

Amaç, ifadelerin her birini mümkün olduğunca kısa yapmaktır. Puanınız, 16 ifadenizin her birindeki karakter sayısının toplamıdır. En düşük puan kazanır. Tiebreaker en erken cevaba gider (daha sonra başka birinden alınan daha kısa ifadelerle cevaplarını düzenlemedikleri takdirde).

Bu yarışma için teknik olarak herhangi bir gerçek kod yazmanız gerekmez, ancak ifadeleri oluşturmanıza yardımcı olacak herhangi bir program yazdıysanız, bunları yayınlamanız şiddetle tavsiye edilir.

İfadelerinizin beklenenleri yapıp yapmadığını kontrol etmek için bu Yığın Snippet'ini kullanabilirsiniz:

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 karakter

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

Bunlardan bazıları için birkaç seçenek var, bu yüzden bu 100 karakterlik set daha önce yayınlananlarla aynı değil.

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

<İşlevsel olarak tamamlanmış daha kolay bir kanıt, A<(B<1)NOR'u verir.

Bunu bulmak için kullandığım kod, iki küçük değişiklikle daha önceki zorluklarda kullandığım bazı Boolean optimizasyon kodunun ağır bir basitleştirilmesidir:

1. Bir ifadenin puanını, işlem sayısı yerine dizesinin uzunluğu olun.
2. Uzunluğu en aza indirmek için dizenin gereksiz parantezlerden kaçının.

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 karakter

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 karakter

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, diğerleriyle tam olarak aynı değil. Bu bile 10 dakika geçirdim, bu yüzden bu 2 yaşında olsa bile, yine de gönderme değer.

100 karakter

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