नॉनरी गेम से कौन बच सकता है?

द नॉनरी गेम एक काल्पनिक खेल है जो इसी नाम के वीडियो गेम ट्राइलॉजी में खेला जाता है। आपका लक्ष्य यह पता लगाना है कि कितने खिलाड़ी (सर्वश्रेष्ठ में) किसी दिए गए खेल से बच सकते हैं, कोड के कुछ बाइट्स में।

खेल के नियम

9 खिलाड़ी हैं, जिनकी संख्या 1 से 9 है।
सभी खिलाड़ी एक ही कमरे में शुरू करते हैं।
दरवाजे की कोई भी संख्या है, प्रत्येक 1 से 9 नंबर के साथ है। डुप्लिकेट या गुम डोर नंबर हो सकते हैं।
कमरे के बीच दरवाजा एक तरफ़ा कनेक्शन है। प्रत्येक दरवाजे का उपयोग केवल एक बार किया जा सकता है ।
केवल 3 से 5 खिलाड़ियों के समूह एक दरवाजे से गुजर सकते हैं।
एक समूह केवल एक दरवाजे के माध्यम से जा सकता है अगर उनकी संख्या के जोड़ मोडुलो 9 की संख्या दरवाजे के संख्या मोडुलो 9 से मेल खाती है।
कोई भी खिलाड़ी जो 9 दरवाजे से गुजरता है वह बच जाता है (जीत जाता है)।

उदाहरण

┌───┬───┬───┐
│   6   4   9
│ < │   |   |
│   3   5   9
└───┴───┴───┘

<प्रारंभिक बिंदु का प्रतिनिधित्व करता है। सभी खिलाड़ी वहां से शुरू करते हैं।

इस सेटिंग में, हर कोई बच सकता है। इसे प्राप्त करने के विभिन्न तरीके हैं, जिनमें से एक है:

[१, २, ३, ४, ५] हालांकि द्वार ६ ((१ + २ + ३ + ४ + ५)% ९ = ६) चलते हैं, जबकि [६, 3, 3, ९] द्वार ३ (६) से गुजरते हैं + 7 + 8 + 9)% 9 = 3)। सब लोग दूसरे कमरे में मिलते हैं।
[१, २, ३, go] द्वार ४ से गुजरते हैं, जबकि [४, ५, ६, 3, ९] द्वार ५ से गुजरते हैं।
[१, २, ३, ४, go] ९ में से एक दरवाजे से गुजरते हैं, [५, ६, 3, ९] दूसरे से गुजरते हैं।

┌───┬───┐
│   │   |
│ < 8   9
│   │   |
└───┴───┘

इस बार, अधिकतम 4 लोग बच सकते हैं:

[१, ३, ५, 5, ९] द्वार 5 के माध्यम से जाना।
[१, ३, ५, ९] द्वार ९ से गुजरते हैं।

बचे हुए लोगों की अन्य सूची संभव है, जैसे कि [2, 3, 4] या [1, 4, 6, 7], लेकिन 4 से अधिक लोगों के बचने का कोई रास्ता नहीं है।

चुनौती

एक नक्शे को देखते हुए, अधिकतम संख्या में खिलाड़ी का उत्पादन कर सकते हैं जो बच सकते हैं।

चिंता मत करो, तुम मेरे भयानक चित्र पार्स करने की जरूरत नहीं है! इनपुट एक लेबल निर्देशित ग्राफ़ है, जिसे आप किसी भी सुविधाजनक प्रारूप (एज सेट, आसन्न मैट्रिक्स ...) में दर्शा सकते हैं।
यदि आपके प्रतिनिधित्व को कमरों के लिए लेबल की आवश्यकता होती है, तो आप किसी भी संगत मान का उपयोग कर सकते हैं। हालांकि, दरवाजे 1 से 9 के पूर्णांक द्वारा दर्शाए जाने चाहिए।
इनपुट में हमेशा कम से कम एक 9 दरवाजा होगा। सभी 9 दरवाजे हमेशा बाहर निकलते हैं, जबकि अन्य दरवाजे कभी नहीं करते हैं।
आपका सबमिशन एक फंक्शन या फुल प्रोग्राम हो सकता है।
मानक खामियों पर रोक लगाई जाती है।

परीक्षण के मामलों

इनपुट्स को [दरवाजे की संख्या, कमरे से कमरे तक] तीनों की सूची के रूप में दिखाया गया है, जिसमें 0 शुरुआती कमरा है और -1 बाहर निकलने वाला है। यदि आप किसी अन्य प्रारूप का उपयोग करना चुनते हैं, तो आपको उन्हें उचित रूप से परिवर्तित करना होगा।

Input                                                                      Output
[[6, 0, 1], [3, 0, 1], [4, 1, 2], [5, 1, 2], [9, 2, -1], [9, 2, -1]]       9
[[8, 0, 1], [9, 1, -1]]                                                    4
[[9, 0, -1]]                                                               5
[[2, 0, 1], [1, 1, 2], [9, 2, -1]]                                         0
[[2, 0, 1], [3, 1, 2], [9, 2, -1]]                                         3
[[1, 0, 1], [9, 1, -1], [1, 0, 2], [9, 2, -1]]                             4
[[2, 0, 1], [3, 0, 1], [5, 1, 2], [4, 0, 2], [9, 2, -1], [9, 2, -1]]       8
[[3, 0, 1], [4, 0, 1], [5, 0, 1], [9, 1, -1], [7, 1, 2], [9, 2, -1]]       7
[[1, 0, 1], [2, 0, 1], [4, 0, 1], [9, 1, -1], [8, 1, 2], [9, 2, -1]]       6
[[6, 0, 1], [7, 0, 1], [9, 1, -1], [9, 1, -1]]                             7

code-golf game

— ग्रिमी
स्रोत

मुझे पता है कि यह खेल के 999 होने का एक अवशेष है, लेकिन यह मुझे

— बताता है

यह विवरण और सचित्र उदाहरणों में स्पष्ट करने के लायक हो सकता है कि कुछ दरवाजे कमरों को बायपास करते हैं। इसके अलावा दरवाजे कभी भी पीछे की तरफ जा सकते हैं? यानी कुछ लोग 0-> 1-> बाहर निकल सकते हैं और अन्य लोग 0-> 2-> 1-> बाहर निकल जाते हैं?

— निक केनेडी

@NickKennedy निश्चित नहीं है कि आप "बाईपास" से क्या मतलब है। दरवाजे किसी भी कमरे को किसी अन्य कमरे से जोड़ सकते हैं। यह एक निर्देशित ग्राफ है।

— ग्रिम्मी

अगर आपको लगता है कि नियमों की इस श्रृंखला को सहज विस्फोट के खतरे के साथ और अधिक दिलचस्प बनाया जा सकता है जैसे ही कोई भी गलती करता है, तो कृपया खेल को आज़माएं। यह बहुत अच्छा है।

— तितर बितर

@ निश्चित रूप से, लेकिन सचित्र उदाहरण और पहले 5 वास्तविक उदाहरणों में एक कमरे से दूसरे दरवाजे तक जाने वाले सभी दरवाजे दाईं ओर हैं।

— निक केनेडी

जवाबों:

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

स्ट्रिंग्स के बजाय बिटमास्क का उपयोग करते हुए एक धीमी लेकिन काफी कम संस्करण।

f=(D,P=[511],e=m=0)=>P.map((X,r)=>[...Array(-~X)].map((_,p)=>D.map(([d,s,t],j)=>(N=(g=(n,k)=>n&&n%2+g(n>>1,++k,x+=n%2*k))(p&=X,x=0))<3|N>5|r-s|x%9^d%9||f(D.filter(_=>j--),A=[...P],e+!~t*N,A[r]^=p,A[t]^=p))),m=m>e?m:e)|m

इसे ऑनलाइन आज़माएं!

$X$ $(X \operatorname{AND} p)$ $0\le p\le X$

जावास्क्रिप्ट (ईएस 7), 293 272 271 बाइट्स

चुनौती में वर्णित प्रारूप में इनपुट लेता है। यह एक ब्रूट फोर्स सर्च है।

f=(D,P=[17**6+'8'],e=m=0)=>P.map((X,r)=>X&&[...X].reduce((a,x)=>[...a,...a.map(y=>y+x)],['']).map(p=>D.map(([d,s,t],j)=>p<99|p[5]|r-s|eval([...p].join`+`)%9^d%9||f(D.filter(_=>j--),A=[...P],e+!~t*p.length,A[r]=X.replace(eval(`/[${p}]/g`),''),A[t]=[A[t]]+p))),m=m>e?m:e)|m

इसे ऑनलाइन आज़माएं! (TIO पर पहला टेस्ट केस टाइम आउट)

कैसे?

सरणी P[]प्रत्येक कमरे में खिलाड़ियों का वर्णन करते हुए तार की एक सूची रखती है।

P=['241375698'] $17^6=24137569$ $0$

प्रत्येक कमरे Xकी स्थिति के लिए r, हम निम्नलिखित की गणना करते हैं X:

[...X].reduce((a, x) => [...a, ...a.map(y => y + x)], [''])

इंडेक्स में pप्रत्येक दरवाजे के लिए खिलाड़ियों के समूह के लिए , हम परीक्षण करते हैं कि क्या समूह दरवाजे से गुजरने में असमर्थ है:[d,s,t]j

                         // we can't pass if:
p < 99 |                 // there are less than 3 players
p[5] |                   // or there are more than 5 players
r - s |                  // or the source room s is not equal to the current room
eval([...p].join`+`) % 9 // or the sum of the players modulo 9
^ d % 9                  // does not match the ID of the door modulo 9

यदि समूह पास हो सकता है, तो हम एक पुनरावर्ती कॉल करते हैं:

f(                       //
  D.filter(_ => j--),    // remove the door that has just been used from D[]
  A = [...P],            // use a copy A[] of P[]
  e + !~t * p.length,    // if t = -1, add the length of p to e (number of escaped guys)
  A[r] = X.replace(      // remove the players from the source room A[r]
    eval(`/[${p}]/g`),   //
    ''                   //
  ),                     //
  A[t] = [A[t]] + p      // and append them to the target room A[t]
)                        //

हम बच गए खिलाड़ियों की अधिकतम संख्या पर नज़र रखते हैं mऔर अंततः इसे वापस लौटाते हैं।

— Arnauld
स्रोत

क्या आप सिर्फ सभी संभावनाओं की कोशिश कर रहे हैं?

— योना

@ जोना हां। यह इनपुट द्वारा निहित बाधाओं के आधार पर या तो बहुत तेज या बहुत धीमा हो सकता है।

— अरनुलद

जैली , 76 बाइट्स

2ịịœc3r5¤ẎS,%9EʋƇ1ị${ḟ@;ƭⱮ€Ḋị¥ż€Ḋ{ṛṪ}¦ƒ€
ç@€Ẏ;ḷṢ€€Q
“”WẋḊ€FṀƊ9RW¤;Wçƒ@⁸ẈṪ$€Ṁ

इसे ऑनलाइन आज़माएं!

एक पूर्ण तर्क, एकल 1, 2, ... और 0 का उपयोग करके निर्देशित ग्राफ को बाहर निकलने के रूप में लिया गया। एक पूर्णांक देता है जो अधिकतम संख्या है जो बच सकती है। पालन करने के लिए पूर्ण स्पष्टीकरण।

Ṣ€€Q4-बाइट की बचत के बिना चलना चाहिए लेकिन आराम करने के लिए धीमा।

— निक केनेडी
स्रोत