एक न्यूनतम वृक्ष का मूल्यांकन करें

Question

एलिस और बॉब थोड़ा खेल खेल रहे हैं। सबसे पहले, वे एक रूट नोड (मोटी डॉट द्वारा इंगित) से एक पेड़ खींचते हैं, जिसमें पत्तियों पर संख्या के साथ कोई आंतरिक नोड नहीं होता है। किसी भी नोड में बच्चों की संख्या हो सकती है।

हम रूट पर शुरू करते हैं, और पहले खेलने के लिए ऐलिस (ए) है। उसे वर्तमान नोड के बच्चों में से एक का चयन करना होगा। फिर यह बॉब की बारी है, और वह इसी तरह एक बच्चे के नोड का चयन करता है। यह तब तक जारी रहता है जब तक एक पत्ती नोड तक नहीं पहुंच जाता है।

जब एक पत्ता नोड तक पहुँच जाता है, तो खेल खत्म हो गया है। यह ऐलिस का लक्ष्य जितना संभव हो उतना बड़े नोड के साथ समाप्त होना है, और बॉब का लक्ष्य जितना संभव हो उतना कम मूल्य के साथ नोड पर समाप्त होना है।

नेस्टेड सरणी रूप में एक पेड़ को देखते हुए, उस पत्ते का मूल्य लौटाएं जो कि पहुंच जाएगा यदि एलिस और बॉब दोनों पूरी तरह से खेलते हैं।

---

उदाहरण:

18: [[67, [[100, [[67, 47], [86], 21, 16], [[46, [14], 35, 85], [71, [18, 63, 69], 99, 22], 3]]], [[18, 32, 42, 80]], [[36, 70], [86, 53, 46, 59], [[41], 86, 35]]], 3]
60: [[[84, 35], [44, 60]], [[24, 98], [16, 21]]]
58: [[53, 77], [58, [82, 41]], 52]
59: [[93, [100, 53], 58, 79], [63, 94, 59], [9, [55, 48]], [40, 10, 32]]
56: [[20, 10, [[[89, 22, 77, 10], 55], [24, 28, 30, 63]]], [[49, 31]], 17, 56]
0: [0]

आप मान सकते हैं कि रूट नोड कभी लीफ नोड नहीं है और कम से कम एक लीफ नोड को इंगित करता है। आप मान सकते हैं कि लीफ़ नॉनगेटिव नंबर हैं।

---

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

मैं इसे पहचानता हूँ!

— कॉनर बेल

Answer 1

जेली , 7 बाइट्स

N߀¬¡ṂN

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह @ xnor के उत्तर से एल्गोरिथ्म का उपयोग करता है । तुलनात्मक उद्देश्यों के लिए, एक और सीधा दृष्टिकोण जो बारी-बारी से मिनीमा और मैक्सिमा की गणना करता है, उसका वजन 8 बाइट होता है :

߀¬¡€Ṃ€Ṁ

यह काम किस प्रकार करता है

N߀¬¡ṂN  Main link. Argument: x (array or integer)

N        Negate. For an array, this negates all integers in it.
   ¬     Logical NOT. For an array, this applies to all integers in it.
    ¡    Apply the second link to the left once if ¬ returned an array or 1, or not
         at all if it returned 0.
 ߀      Recursively call the main link on all elements at depth 1 of -x.
         If -x == 0, € will cast 0 to range before mapping ß over it. 
         Since the range of 0 is [], mapping ß over it simply yields [].
     Ṃ   Minimum.
         For an integer, Ṃ simply returns the integer. For [], Ṃ returns 0.
      N  Negate the minimum.

Answer 2

पायथन 2, 53 बाइट्स

f=lambda l,c=1:c*l if l<[]else-min(f(x,-c)for x in l)

मुख्य प्रश्न के बीच वैकल्पिक करने के लिए कैसे है maxऔर minप्रत्येक परत। इस तथ्य का उपयोग करते हुए कि max(l) == -min([-x for x in l]), हम इसके बजाय हर दूसरी परत को नकारते हैं और पुनरावृत्ति करते हैं -min। हर दूसरी परत को नकारने के लिए, हम एक गुणक को पास करते हैं जो cकि वैकल्पिक होता है +1और -1, जब हम एक पत्ती तक पहुंचते हैं, तो हम गुणक द्वारा इसके मूल्य को समायोजित करते हैं। हम पहचान के माध्यम से एक पत्ती पर जा रहे हैं l<[], क्योंकि पायथन 2 सूची से कम संख्या में व्यवहार करता है।

else/ifटर्नरी को छोटा करना कठिन है क्योंकि या तो शाखा एक ट्रू (नॉनजेरो) या फाल्सी (शून्य) मूल्य दे सकती है।

Answer 3

जावास्क्रिप्ट (ईएस 6), 53 बाइट्स

f=(a,s=1)=>a.map?s*Math.max(...a.map(b=>s*f(b,-s))):a

@ Xnor के उत्तर के समान दृष्टिकोण का उपयोग करता है। यदि संख्याएँ नॉनज़रो हैं, तो केवल 49 बाइट्स:

f=(a,s=1)=>+a||s*Math.max(...a.map(b=>s*f(b,-s)))

Answer 4

पायथ, 21 बाइट्स

M?sIG*GH_hSmgd_HGLgb1

मेरा पहला पायथ उत्तर! मदद के लिए डेनिस को धन्यवाद :)।

M                      # define a binary function (G, H)
 ?sIG                  # if G (first argument) is the same with s applied
                       # (check if it's an integer, so, a leaf node)
     *GH               # in such a case, calculate G*H
        _              # negation
         hS            # take the first element of the sorted list (that's the min)
           mgd_HG      # map over G, applying ourself (g) recursively,
                       # with the current lambda's value (d)
                       # and the negation of H
                 Lgb1  # Define a unary function to call our previous
                       # one with the correct base argument (1)

Comments

उस मानचित्र के लिए छोटा सिंटैक्स है: mgd_Hहो सकता है gR_H। इसके अलावा, बजाय एक समारोह को परिभाषित करने के लिए आप के साथ इनपुट ले जा सकते हैं Qऔर बदलने के Lgb1साथ gQ1।

— lirtosiast

Answer 5

गणितज्ञ, 13 बाइट्स

-Min[#0/@-#]&

या समकक्ष

Max[-#0/@-#]&

यह एक अनाम फ़ंक्शन का मूल्यांकन करता है जो पेड़ लेता है और परिणाम देता है।

यह भी अनिवार्य रूप से xnor के समाधान के समान है: प्रत्येक स्तर पर हम सूची और परिणाम के संकेत को स्वैप करते हैं और Minसभी तरह से नीचे का उपयोग करते हैं । मैथमेटिका में यह अविश्वसनीय रूप से गोल्फ में बदल गया, क्योंकि:

• Minअलग-अलग संख्या या सूची या कई सूचियाँ भी ले सकते हैं। यह सिर्फ आपको इसके सभी तर्कों के न्यूनतम मूल्य देता है। इसका मतलब है कि यह सूचियों के साथ-साथ पत्तियों पर भी काम करता है (जहां यह सिर्फ पत्ती देता है)।
• /@के लिए कम है जो Mapगणितज्ञ में एक बहुत ही सामान्य उच्च-क्रम फ़ंक्शन है। यह केवल सूचियों पर एक फ़ंक्शन को मैप नहीं करता है, यह किसी भी अभिव्यक्ति पर उन्हें मैप कर सकता है। संख्याएं एक ऐसी अभिव्यक्ति हैं, लेकिन उनमें मैप किए जाने वाले कोई तत्व नहीं हैं। इसका मतलब है कि हम किसी भी फ़ंक्शन को संख्याओं पर सुरक्षित रूप से मैप कर सकते हैं, जो संख्या को बिल्कुल भी प्रभावित नहीं करता है।

उन दोनों चीजों का एक साथ मतलब है कि हम बिना किसी शर्त के कोड लिख सकते हैं, क्योंकि संख्याओं पर संचालन Minऔर Mapसंचालन बिना ऑप्सन हैं, और बाद में दो नकारात्मकताएं रद्द हो जाती हैं, ताकि नंबर दिए जाने पर फ़ंक्शन पहचान बन जाए।

अंत में, इसके लिए धन्यवाद#0 गणितज्ञ में अनाम पुनरावर्ती कार्यों को लिखना संभव है, जो कुछ और बाइट्स बचाता है।

Answer 6

रूबी, 46 बाइट्स

minअधिकतम और न्यूनतम के बीच वैकल्पिक करने के लिए @ xnor की चाल का उपयोग किया ।

f=->n,a=1{n==[*n]?-n.map{|c|f[c,-a]}.min: a*n}

Answer 7

जूलिया, 27 25 बाइट्स

!a=0==0a?a:-minimum(!,-a)

यह @ xnor के उत्तर से एल्गोरिथ्म का उपयोग करता है । इसे ऑनलाइन आज़माएं!