सभी प्रकाश सभी प्रकाश सभी प्रकाश!

Question

^{यह चुनौती पूरी तरह से ऑल लाइट से प्रेरित है , जिसे सोलगिट गेम्स द्वारा विकसित किया गया है।}

चुनौती

आप एक इलेक्ट्रीशियन हैं, और बैटरी को सभी रोशनी को तार करना आपका काम है।

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

बैटरी और प्रत्येक प्रकाश की स्थिति को देखते हुए, और प्रत्येक प्रकाश को जितने कनेक्शन की आवश्यकता होती है, उन दोनों के बीच कनेक्शन को आउटपुट करता है जो इन गुणों को स्वीकार करते हैं।

विन कंडीशन

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है।

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

I / O हमेशा की तरह लचीला है।

इनपुट के लिए मैं ग्रिड के आकार का 2d सरणी का उपयोग करूंगा, जो रोशनी के लिए सकारात्मक पूर्णांक, रिक्त स्थान के लिए शून्य और बैटरी के लिए -1 स्टोर करता है। एक और अच्छा विकल्प रोशनी की एक सूची हो सकती है, जहां एक प्रकाश एक टपल है जिसमें प्रकाश की स्थिति और आवश्यक कनेक्शन की संख्या होती है।

आउटपुट के लिए मैं कनेक्शनों की एक सूची का उपयोग करूंगा, जहां एक कनेक्शन एक टपल है जिसमें प्रारंभिक स्थिति और समाप्ति स्थिति होती है। यदि एक कनेक्शन दोगुना हो जाता है, तो मेरे पास सूची में उनमें से 2 होंगे (एक अन्य विकल्प इस पैरामीटर को ट्यूपल में शामिल करने के लिए है)। एक और अच्छा विकल्प किसी प्रकार का ग्रिड लेआउट हो सकता है।

यदि आप एक समन्वय प्रणाली का उपयोग कर रहे हैं, तो आप आरंभिक सूचकांक और जहाँ से आप अनुक्रमणिका निर्दिष्ट कर सकते हैं। मेरे उदाहरण 0-अनुक्रमित होंगे और शीर्ष बाएं कोने (पंक्ति, स्तंभ) के रूप में (0, 0) का उपयोग करेंगे। (मैं {} का उपयोग केवल दूसरे प्रकार के सीमांकक को शुरू करने के लिए कर रहा हूं ताकि यह पढ़ना आसान हो, इसलिए नहीं कि वे सेट हैं।)

यहाँ परीक्षण मामलों का एक ग्राफिकल दृश्य है: टेस्ट 1-12

टेस्ट 1:

[-1 | 0 | 1 ] => [{(0, 0), (0, 2)}]

टेस्ट 2:

[-1 | 0 | 2 ] => [{(0, 0), (0, 2)}, {(0, 0), (0, 2)}]

टेस्ट 3:

[-1 ] [ 0 ] => [{(0, 0), (2, 0)), ((0, 0), (2, 0)}] [ 2 ]

टेस्ट 4:

[ 1 | 0 |-1 | 0 | 2 ] => [{(0, 0), (0, 2)}, {(0, 2), (0, 4)}, {(0, 2), (0, 4)}]

टेस्ट 5:

[ 2 ] [ 0 ] [-1 ] => [{(0, 0), (2, 0)}, {(0, 0), (2, 0)}, {(2, 0), (4, 0)}] [ 0 ] [ 1 ]

टेस्ट 6:

[ 1 | 0 | 0 ] [ 0 | 0 | 0 ] => [{(0, 0), (2, 0)}, {(2, 0), (2, 2)}] [ 2 | 0 |-1 ]

टेस्ट 7:

[ 4 | 0 | 0 |-1 ] [ 0 | 0 | 0 | 0 ] => [{(0, 0), (0, 3)}, {(0, 0), (0, 3)}, [ 2 | 0 | 0 | 0 ] {(0, 0), (3, 0)}, {(0, 0), (3, 0)}]

टेस्ट 8:

[ 2 | 0 |-1 | 0 | 2 ] [{(0, 0), (0, 2)}, {(0, 0), (0, 2)}, [ 0 | 0 | 0 | 0 | 0 ] => {(0, 2), (0, 4)}, {(0, 2), (0, 4)}, [ 0 | 0 | 1 | 0 | 0 ] {(0, 2), (2, 2)}]

टेस्ट 9:

[ 0 | 0 | 2 | 0 | 0 ] [ 0 | 0 | 0 | 0 | 0 ] [ 1 | 0 |-1 | 0 | 1 ] => [{(0, 2), (2, 2)}, {(0, 2), (2, 2)}, {(2, 0), (2, 2)}, [ 0 | 0 | 0 | 0 | 0 ] {(4, 2), (2, 2)}, {(2, 4), (2, 2)}, {(2, 4), (2, 2)}] [ 0 | 0 | 2 | 0 | 0 ]

टेस्ट 10:

[-1 | 2 | 3 | 2 ] => [{(0, 0), (0, 3)}, {(0, 0), (0, 3)}, {(0, 0), (0, 3)}, {(0, 0), (0, 3)}]

टेस्ट 11:

[-1 | 0 | 0 | 0 ] [ 3 | 0 | 0 | 0 ] [ 3 | 0 | 0 | 3 ] => [{(0, 0), (1, 0)}, {(1, 0), (2, 0)}, {(1, 0), (2, 0)}, [ 0 | 0 | 0 | 0 ] {(2, 0), (2, 3)}, {(2, 3), (4, 3)}, {(2, 3), (4, 3)}] [ 0 | 0 | 0 | 2 ]

टेस्ट 12:

[ 2 | 0 | 0 ] [{(0, 0), (1, 0)}, {(0, 0), (1, 0)}, {(1, 0), (1, 1)}, [ 3 |-1 | 0 ] => {(1, 1), (2, 1)}, {(1, 1), (2, 1)}, {(2, 0), (2, 1)}, [ 2 | 5 | 1 ] {(2, 0), (2, 1)}, {(2, 1), (2, 2)}]

Comments

सैंडबॉक्स

— संगीतज्ञ ५२३

मेरा सुझाव है कि एक परीक्षण मामला है कि वहाँ मौजूद है हर समाधान को संतुष्ट करने के अलावा "बैटरी से प्रत्येक प्रकाश के लिए एक रास्ता होना चाहिए।" उदाहरण के लिए [1 | -1] [1 1]।

— user202729

कुछ हद तक ब्लॉसम एल्गोरिथ्म की याद दिलाता है।

— user202729

@ user202729 मैं गारंटी इनपुट एक समाधान सभी शर्तों को पूरा किया है कि

— musicman523

यह हशी पहेली के समान लगता है। मुझे लगता है कि दोनों में से किसी एक को हल करने के लिए समान चरण समान हैं।

— Οurous

Answer 1

जावास्क्रिप्ट (Node.js) , 393 391 378 बाइट्स

a=>(R=[],f=(a,[x,...y],z,Y)=>x?f(a.map(t=>[...t]),y,z,Y)||f(a,y,[...z,x],Y.map(p=>p.map(q=>q-Y[x[0]][x[1]]?q:Y[x[2]][x[3]])),--a[x[0]][x[1]],--a[x[2]][x[3]]):/[1-9]/.test(a)|Y.some(t=>t.some(u=>u-Y[I][J]&&u))?0:z)(a=a.map(A=(b,i)=>b.map((x,j)=>x&&(A[i]+1&&R.push([i,A[i],i,j]),f[j]+1&&R.push([f[j],j,i,j]),A[I=i]=j,f[J=j]=i,x/=x>0))),[...R,...R],C=[],a.map(p=>p.map(q=>q&&++C)))

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

a=>(
    a=a.map(
        A=(b,i)=>
            b.map(
                (x,j)=>
                    x&&(                                  // A[i]+1 <==> A[i] is NOT NaN
                        A[i]+1&&R.push([i,A[i],i,j]),     // Use A and f to store last
                        f[j]+1&&R.push([f[j],j,i,j]),     // existance of row and column
                        A[I=i]=j,f[J=j]=i,x/=x>0          // -1 => -Inf, +n => n
                    )
            ),
            R=[],
            f=([x,...y],z,Y)=>
                x?
                    f(
                        y,[...z,x],
                        Y.map(p=>p.map(q=>q-Y[x[0]][x[1]]?q:Y[x[2]][x[3]])), // merge
                        --a[x[0]][x[1]],--a[x[2]][x[3]]
                    )||
                    f(y,z,Y,++a[x[0]][x[1]],++a[x[2]][x[3]])
                :
                    /[1-9]/.test(a)|
                    Y.some(t=>t.some(u=>u-Y[I][J]&&u)) // not totally merged
                    ?0:z
    ),f)([...R,...R],[],a.map(p=>p.map(q=>q&&++C),C=0)
)

Comments

इस परीक्षण के मामले में विफल रहता है ।

— user202729

जावास्क्रिप्ट रेग में / [1-9] / के लिए एक शॉर्टकट है?

— ज़ाचरी

@ Zacharý मुझे ऐसा नहीं लगता। आमतौर [0-9]पर इस्तेमाल किया जाता है

— l4m2

मुझे मूर्ख! मुझे लगा कि आपने जो लिखा है

— Zacharý

@ Zacharý क्या ??

— l4m2