ऑपरेटर से कम के साथ सभी 16 बूलियन कार्यों को व्यक्त करें

15

दो बाइनरी चर, ए और बी के लिए 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

ऑपरेटर से कम <, जिसे सामान्य रूप से तर्क ऑपरेटर के रूप में नहीं सोचा जाता है, जैसे कि, और, या, वास्तव में इन कार्यों में से एक है (एफ 4) जब बूलियन मूल्यों पर लागू किया जाता है:

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

दिलचस्प बात यह है कि हम उन 15 अन्य कार्यों में से किसी का भी अनुकरण कर सकते हैं जिसमें केवल प्रतीक होते हैं ()<AB10। इन अभिव्यक्तियों का मूल्यांकन और मूल्यांकन वैसे ही किया जाता है जैसे वे कई मानक प्रोग्रामिंग भाषाओं में होते हैं, उदाहरण के लिए कोष्ठक का मिलान <होना चाहिए और इसके दोनों ओर तर्क होने चाहिए।

विशेष रूप से, इन अभिव्यक्तियों को निम्नलिखित व्याकरण ( बैकस-नौर फॉर्म में दिए गए ) के साथ पालन करना होगा :

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

इसका मतलब है कि बेकार पेरेथेस और फॉर्म के अभिव्यक्तियों की A<B<1अनुमति नहीं है।

तो अभिव्यक्ति A<Bफ़ंक्शन F4 से मेल खाती है, और A<B<1इसे (A<B)<1या तो बदलना चाहिए A<(B<1)।

यह साबित करने के लिए कि सभी 15 अन्य कार्यों को अभिव्यक्तियों में बदला जा सकता है, यह अभिव्यक्तियों का एक समूह बनाने के लिए पर्याप्त है जो कार्यात्मक रूप से पूरा हो , क्योंकि तब, परिभाषा के अनुसार, उन्हें किसी भी फ़ंक्शन के लिए अभिव्यक्तियों में बनाया जा सकता है।

भावों का ऐसा एक समूह x<1(जहाँ xहै Aया है B), जो है ¬x, और (((B<A)<1)<A)<1जो है A → B। ऋणात्मक ( ¬) और निहितार्थ ( →) कार्यात्मक रूप से पूर्ण होने के लिए जाने जाते हैं ।

चुनौती

वर्णों का उपयोग करते हुए ()<AB10, ऊपर वर्णित रूप में 16 अभिव्यक्तियों को लिखें जो 16 अलग-अलग बूलियन कार्यों में से प्रत्येक के बराबर हैं।

लक्ष्य प्रत्येक अभिव्यक्ति को यथासंभव छोटा बनाना है। आपका स्कोर आपके प्रत्येक 16 भावों में वर्णों की संख्या का योग है। सबसे कम स्कोर जीतता है। टाईब्रेकर जल्द से जल्द जवाब देता है (बशर्ते कि वे अपने जवाब को बाद में किसी और से लिए गए छोटे भावों के साथ संपादित न करें)।

इस प्रतियोगिता के लिए आपको तकनीकी रूप से कोई वास्तविक कोड लिखने की आवश्यकता नहीं है, लेकिन यदि आपने भाव उत्पन्न करने में मदद करने के लिए कोई प्रोग्राम लिखा है, तो आपको उन्हें पोस्ट करने के लिए अत्यधिक प्रोत्साहित किया जाता है।

आप इस स्टैक स्निपेट का उपयोग यह जांचने के लिए कर सकते हैं कि आपके भाव क्या उम्मीद करते हैं:

कोड स्निपेट दिखाएं

metagolf  logic-gates 
— केल्विन के शौक
स्रोत
8
-1, समस्या बहुत सरल है।
— ईसैक
2
वैसे मुझे लगता है कि कोई और जवाब पोस्ट करने की बात नहीं है , इसलिए यहाँ मेरा प्रयास है ।
— Sp3000
7
@isaacg तुम सही हो। मैं कहूंगा कि यह अब तक की सबसे सरल पीपीसीजी प्रतियोगिता से दूर है, लेकिन तथ्य यह है कि इष्टतम जवाब लगभग समान होगा यह एक प्रतियोगिता के रूप में उबाऊ बनाता है। हालाँकि, मुझे लगता है कि यह व्यक्तिगत व्यायाम के रूप में पूरी तरह से ठीक है, खासकर ऐसे लोगों के लिए जो तर्क में विशेषज्ञ नहीं हैं। मुझे यकीन है कि पीपीसीजी पर कम से कम आधे लोग यहां मौज-मस्ती करने के लिए हैं, न कि केवल जीतने के लिए, वरना कोई भी कभी भी गैर-विजेता प्रस्तुत के साथ सवाल का जवाब नहीं देगा।
— केल्विन के शौक
मैं शायद विवादास्पद गोल्फ अभ्यास से इसकी तुलना करूंगा । यह एक मजेदार और दिलचस्प सवाल था, अगर थोड़ा आसान हो।
— 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
@ मिनीबिस, 100 चार्ट, अन्य के समान।
— पीटर टेलर
"अनावश्यक कोष्ठक से बचें, लंबाई को कम करने के लिए" नहीं, आप उन्हें टालें नहीं, ताकि आप नियमों का पालन करने के लिए छोटा कर सकें।
— एरिक आउटोलॉफ़र
@EriktheOutgolfer, मुझे 100% यकीन नहीं है कि आपका क्या मतलब है, लेकिन मेरा सबसे अच्छा अनुमान यह है कि आप इसका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
— isaacg
स्रोत
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
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.