มีฟังก์ชั่นบูลีน 16 แบบสำหรับตัวแปรไบนารีสองแบบคือ A และ 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   

ตัวดำเนินการที่น้อยกว่า<ซึ่งตามปกติจะไม่คิดว่าเป็นตัวดำเนินการเชิงตรรกะเช่น NOT, AND หรือ OR เป็นจริงหนึ่งในฟังก์ชันเหล่านี้ (F4) เมื่อใช้กับค่าบูลีน:

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

ที่น่าสนใจที่เราสามารถจำลองการใด ๆของฟังก์ชั่นอื่น ๆ 15 ()<AB10ใช้นิพจน์ที่มีเพียงสัญลักษณ์ นิพจน์เหล่านี้อ่านและประเมินผลเช่นเดียวกับในภาษาการเขียนโปรแกรมมาตรฐานเช่นวงเล็บต้องจับคู่และ<ต้องมีอาร์กิวเมนต์ในแต่ละด้าน

โดยเฉพาะนิพจน์เหล่านี้ต้องเป็นไปตามไวยากรณ์ต่อไปนี้ (ระบุในรูปแบบ Backus-Naur ):

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

ซึ่งหมายความว่าA<B<1ไม่อนุญาตให้มีparethes และนิพจน์ในแบบฟอร์มที่ไร้ประโยชน์

ดังนั้นการแสดงออกA<Bตรงกับ F4 ฟังก์ชั่นและA<B<1ต้องมีการเปลี่ยนแปลงไปหรือ(A<B)<1A<(B<1)

เพื่อพิสูจน์ว่า 15 ฟังก์ชันอื่น ๆ สามารถเปลี่ยนเป็นนิพจน์ได้ก็เพียงพอที่จะสร้างชุดของนิพจน์ที่สมบูรณ์ตามหน้าที่เพราะจากนั้นตามนิยามแล้วฟังก์ชันเหล่านั้นสามารถประกอบเป็นนิพจน์สำหรับฟังก์ชันใด ๆ

หนึ่งชุดดังกล่าวของการแสดงออกเป็นx<1(ที่xเป็นAหรือB) ซึ่งเป็น¬xและซึ่งเป็น(((B<A)<1)<A)<1 A → Bการปฏิเสธ ( ¬) และการอนุมาน ( →) เป็นที่ทราบกันว่าสมบูรณ์ตามหน้าที่

ท้าทาย

ใช้อักขระ()<AB10เขียน 16 นิพจน์ในรูปแบบที่อธิบายไว้ข้างต้นซึ่งเทียบเท่ากับฟังก์ชันบูลีนที่แตกต่างกัน 16 รายการ

เป้าหมายคือทำให้แต่ละนิพจน์สั้นที่สุดเท่าที่จะทำได้ คะแนนของคุณคือผลรวมของจำนวนอักขระในแต่ละ 16 นิพจน์ของคุณ คะแนนต่ำสุดชนะ Tiebreaker ไปที่คำตอบแรกสุด (หากพวกเขาไม่ได้แก้ไขคำตอบในภายหลังด้วยการแสดงออกสั้นลงจากคนอื่น)

คุณไม่จำเป็นต้องเขียนโค้ดจริงสำหรับการแข่งขันครั้งนี้ แต่อย่างใด แต่ถ้าคุณเขียนโปรแกรมใด ๆ เพื่อช่วยคุณในการสร้างการแสดงออกคุณควรโพสต์ข้อความเหล่านั้น

คุณสามารถใช้กองย่อยนี้เพื่อตรวจสอบว่าการแสดงออกของคุณทำสิ่งที่คาดหวัง:

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 ตัวอักษร

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

มีตัวเลือกไม่กี่ตัวเลือกเหล่านี้ดังนั้นชุด 100 อักขระนี้ไม่เหมือนกับชุดที่โพสต์ก่อนหน้านี้

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

หลักฐานที่ง่ายกว่าที่ทำให้การ<ใช้งานสมบูรณ์นั้นคือA<(B<1)NOR

รหัสที่ฉันใช้ในการค้นหานี้เป็นการลดความซับซ้อนของรหัสการเพิ่มประสิทธิภาพ Boolean บางอย่างที่ฉันเคยใช้กับความท้าทายก่อนหน้านี้โดยมีการเปลี่ยนแปลงเล็กน้อยสองประการ:

1. ทำให้คะแนนของนิพจน์เป็นความยาวของสตริงแทนที่จะเป็นจำนวนของการดำเนินการ
2. ทำให้สตริงหลีกเลี่ยงวงเล็บที่ไม่จำเป็นเพื่อลดความยาว

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 ตัวอักษร

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 ตัวอักษร

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

เฮ้มันไม่เหมือนกับคนอื่น ๆ ฉันใช้เวลาประมาณ 10 นาทีในเรื่องนี้ดังนั้นมันจึงคุ้มค่ากับการโพสต์แม้ว่าจะมีอายุ 2 ปีก็ตาม

100 ตัวอักษร

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