보다 작은 연산자로 16 개의 부울 함수 모두 표현

15

두 개의 이진 변수 A와 B에 대해 16 개의 고유 한 부울 함수 가 있습니다 .

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과 같은 논리 연산자로 생각되지 않는 less than 연산자 는 실제로 부울 값에 적용될 때 다음 함수 (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)

이것은 쓸모없는 paretheses와 형태의 표현이 A<B<1허용되지 않음을 의미합니다 .

따라서 표현식 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. 부정 ( ¬)과 의미 ( →)는 기능적으로 완전한 것으로 알려져 있습니다 .

도전

문자를 사용하여 ()<AB1016 개의 고유 한 부울 함수 각각에 해당하는 위에서 설명한 형식으로 16 개의 표현식을 작성하십시오.

목표는 각 표현을 가능한 한 짧게 만드는 것입니다. 당신의 점수는 각 16 개의 표현에있는 문자 수의 합입니다. 가장 낮은 점수가 이깁니다. Tiebreaker는 가장 빠른 답변으로갑니다 (나중에 다른 사람의 짧은 표현으로 답변을 편집하지 않은 경우).

기술적으로이 콘테스트에 실제 코드를 작성할 필요는 없지만 식 생성에 도움이되는 프로그램을 작성한 경우 해당 코드를 게시하는 것이 좋습니다.

이 스택 스 니펫을 사용하여 표현식이 예상 한 작업을 수행하는지 확인할 수 있습니다.

코드 스 니펫 표시

metagolf  logic-gates 
— 캘빈의 취미
소스
8
-1, 문제가 너무 간단합니다.
— isaacg
2
글쎄 , 다른 답변을 게시 할 필요가 없다고 생각 하므로 여기에 내 시도가 있습니다.
— Sp3000
7
@isaacg 당신이 맞아요. 나는 그것이 가장 간단한 PPCG 경연 대회와는 거리가 멀다고 말하지만 최적의 답변이 거의 똑같다는 사실은 경쟁으로 지루합니다. 그러나 나는 그것이 특히 논리 전문가가 아닌 사람들에게 개인적인 운동으로 완벽하게 잘 작동 한다고 생각합니다. PPCG 직원의 절반 이상이이기는 것이 아니라 재미를 위해 여기에있을 것이라고 확신합니다.
— Calvin 's Hobbies
나는 이것을 논란의 여지가있는 골프 연습 과 비교할 것이다 . 조금 쉬우면 재미 있고 흥미로운 질문이었습니다.
— Sp3000
2
사람이 관심이 있다면, 여기에 3 개 변수. 가장 긴 표현식은 (0, 0, 0, 1, 0, 1, 1, 0)및에 해당합니다 (0, 1, 1, 0, 1, 0, 0, 0).
— Sp3000

답변:

5

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
— jimmy23013
소스
9

이 중 일부에는 몇 가지 옵션이 있으므로이 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 을 제공 한다는 것 입니다.

이 코드를 찾는 데 사용한 코드는 두 가지 작은 변경 사항을 통해 이전 문제에서 사용한 부울 최적화 코드를 크게 단순화 한 것입니다.

  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;
        }
    }
}
— 피터 테일러
소스
총 문자 수는 얼마입니까?
— user253751
@immibis, 100 자, 다른 것과 동일합니다.
— Peter Taylor
"길이를 최소화하기 위해 불필요한 괄호를 사용하지 마십시오."
— 아웃 골퍼 에릭 11
@EriktheOutgolfer, 나는 당신이 무슨 뜻인지 100 % 확신하지 못하지만, 내 최선의 추측은 " 이것은 쓸모없는 paretheses와 양식의 표현이 A<B<1허용되지 않는다는 것을 의미합니다. " 편집하다 이 답변 다음에 .
— 피터 테일러
2

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
— 아이작
소스
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 살이더라도 어쨌든 게시 할 가치가 있습니다.

— nog642
소스
0

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
— 아웃 골퍼 에릭
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.