विलुप्त होने से गीज़ को बचाएं


13

एलेक्स ए के रूप में जानी जाने वाली जीज़ की प्रजातियों को त्रिकोणीय ग्रिड में रहने के लिए जाना जाता है जिसमें 64 कोशिकाएँ होती हैं:

प्रकोष्ठों
(चित्र इस असंबंधित प्रोजेक्ट यूलर समस्या से लिया गया है ।)

हम प्रत्येक सेल को शीर्ष पंक्ति से शुरू 0करने के लिए संख्याओं के साथ लेबल करेंगे 63और फिर नीचे प्रत्येक पंक्ति पर बाएं से दाएं की ओर बढ़ेंगे। तो शीर्ष सेल है 0और नीचे-दाएं सेल है 63

प्रत्येक कोशिका की तीन सीमाएँ होती हैं। हम प्रत्येक बॉर्डर को उस रूप में लेबल कर सकते हैं a,bजहां aऔर bउस सीमा को साझा करने वाली कोशिकाओं की संख्या होती है। उदाहरण के लिए, सेल के बीच की सीमा 0और 2कहा जाएगा 0,2या 2,0(इससे कोई फर्क नहीं पड़ता कि आप उन्हें किस क्रम में डालते हैं)।

ग्रिड के बहुत किनारे पर सीमाओं के लिए लेबलिंग प्रणाली अलग है, क्योंकि ग्रिड के किनारे की कोशिकाओं में एक सीमा होती है जो वे अन्य कोशिकाओं के साथ साझा नहीं करते हैं। यदि एक सीमा केवल एक सेल का हिस्सा है, तो हम पत्र का उपयोग करेंगे X। उदाहरण के लिए, सेल के तीन सीमाओं 0हैं 0,2, 0,X, और 0,X

कुछ कोशिकाओं में कुछ कलहंस होते हैं । हालाँकि, यदि आप उनकी रक्षा नहीं करते हैं, तो इन गीज़ को बुरे लोमड़ियों (जो कि ग्रिड की सीमाओं के बाहर से आते हैं) द्वारा मार दिया जाएगा। और अगर सभी जिये मर जाते हैं तो ब्रेनसेट दुखी होंगे। इसलिए हम एक कार्यक्रम लिखेंगे जो कि लोमड़ियों से बचाने के लिए उनके चारों ओर बाड़ बनाता है। घाटों को बाड़ के एक पूरी तरह से संलग्न बहुभुज में मौजूद होना चाहिए । हमारा बाड़ का बजट काफी कम है इसलिए कम से कम संख्या में बाड़ का उपयोग करें।

इनपुट विवरण

नंबरों की सूची, अल्पविराम से अलग कर दिया, 0के लिए 63, कोशिकाओं है कि कुछ कलहंस शामिल प्रतिनिधित्व। उदाहरण:

6,12

आउटपुट विवरण

सीमाओं की एक सूची, जो कि उन पर बनी हुई है, जिनके लिए भू-भाग की सफलतापूर्वक रक्षा करने की आवश्यकता है। यह संभव बाड़ की सबसे छोटी संख्या होनी चाहिए। उदाहरण:

5,6 6,7 11,12 12,13 

"घाटों को बाड़ के पूरी तरह से संलग्न बहुभुज में मौजूद होना चाहिए।" क्या सभी भू-भाग एक ही बहुभुज में रहते हैं, या कई (या 0) बहुभुज हो सकते हैं?
फेरेसम

@ फ़ेर्सम सभी कलहंस को एक ही बहुभुज में रहना चाहिए। मैंने इसे स्पष्ट करने के लिए प्रश्न संपादित किया है।
चिरायता

@ कटिया क्या बहुभुज के पास स्वयं-चौराहे या शून्य-चौड़ाई वाले खंड हो सकते हैं? एक घंटे के आकार की तरह सोचो।
orlp

@orlp शून्य-चौड़ाई अनुभाग क्या है?
चिरायता

2
@orlp बहुभुज में शून्य चौड़ाई वाले खंड नहीं होने चाहिए।
अनुपस्थित

जवाबों:


10

सी #, 530 बाइट्स

C # प्रोग्राम को पूरा करें, STDIN से सिंगल लाइन के रूप में इनपुट लेता है, और एक ट्रेलिंग के साथ STDOUT को सिंगल लाइन आउटपुट करता है।

यह लंबे समय तक है ... और बहुत अधिक एक्स / वाई / जेड दोहराव का रास्ता है, लेकिन मैं इसे अभी तक समझदार कुछ भी करने में सक्षम नहीं हूं, और 2 घंटे में एक परीक्षा है, कल इसे वापस आ सकता है।

using Q=System.Console;class P{static void Main(){int q=9,w=0,e=9,r=0,t=9,u=0,i=0,x=0,y=0,z=0,p=0;System.Action V=()=>{z=(int)System.Math.Sqrt(i);p=(x=i-z*z)%2;x/=2;y=(++z*z--+~i)/2;},W=()=>{Q.Write(i+","+(x<0|y++<0|z>7?"X":""+(z*z+2*x+1-p))+" ");};foreach(var g in Q.ReadLine().Split(',')){i=int.Parse(g);V();q=q>x?x:q;w=w<x?x:w;e=e>y?y:e;r=r<y?y:r;t=t>z?z:t;u=u<z?z:u;}for(i=64;i-->0;){V();if(!(x<q|x>w|y<e|y>r|z<t|z>u))if(p>0){if(y==r)W();if(x++==w)W();x--;if(z--==t)W();}else{if(y--==e)W();if(x--==q)W();x++;if(z++==u)W();}}}}

यह आरेख बताता है कि क्या चल रहा है।

उदाहरण के समाधान को दिखाते हुए ग्रिड को x / y / z / (p) के रूप में वर्णित किया गया है

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

कार्यक्रम पहले सभी इनपुट सेल सूचकांकों को x / y / z कोर्ड्स में अनुवाद करके, और x / y / z में से प्रत्येक के मिनट / अधिकतम का पता लगाकर काम करता है।

z = floor(root(i))
x = floor((i - z^2) / 2)
y = floor((z+1)^2 - i - 1) / 2)
p = (i - z^2) % 2

इसके बाद, यह प्रत्येक सेल इंडेक्स से गुजरता है, और यह जांचता है कि यह 'हेक्सागोन' बाउंड में फिट बैठता है या नहीं। यदि यह है तो यह जाँचता है कि क्या यह सीमा के किसी भी चरम किनारे पर है (यानी x = xmin, या y = ymax) और यदि है तो इसी किनारों को जोड़ता है। यह उस किनारे के सूचकांक को काम करना है जो इसके बगल में है। X और z के लिए, हम केवल उन्हें बढ़ा / घटाते हैं, हालांकि हम चाहते हैं, और फिर निम्न सूत्र का उपयोग करें:

i = z^2 + 2*x + (1-p)

ध्यान दें कि "समता" हमेशा बदलती है, और यह कि वाई शामिल नहीं है। Y के लिए, हमें कुछ भी बदलने की ज़रूरत नहीं है, लेकिन कोड थोड़ा गड़बड़ है, क्योंकि यह पता लगाने के लिए "त्रिकोण" सीमा का प्रदर्शन करना है कि सेल अगले दरवाजे "X" होना चाहिए या नहीं।

उदाहरण समाधान (तीन कोनों से सिर्फ भू के साथ कोशिकाएं):

Input
2,50,62

Output
62,63 61,X 59,X 57,X 55,X 53,X 51,X 50,49 48,X 36,X 35,X 25,X 24,X 16,X 15,X 9,X 8,X 4,X 3,X 2,0 1,X 

टिप्पणियों के साथ Tidier कोड:

using Q=System.Console;

class P
{
    static void Main()
    {
        int q=9,w=0,e=9,r=0,t=9,u=0, // min/max x/y/z/ (init min high, and max low)
        i=0, // index of cell we are looking at
        x=0,y=0,z=0,p=0; // x,y,z dimension

        System.Action V=()=>
            { // translates the index into x/y/z/p
                z=(int)System.Math.Sqrt(i);
                p=(x=i-z*z)%2; // 'parity'
                x/=2; // see p assignment
                y=(++z*z--+~i)/2; // ~i == -i - 1
            },
            W=()=>
            { // writes out the edge of i, and the cell described by x/z/inverse of p   (the inversion of p handles y +/-)
                Q.Write(i+","+ // write out the edge
                        (x<0|y++<0|z>7?"X":""+(z*z+2*x+1-p)) // either X (if we go out of 'trianlge' bounds), or we translate x/z/inverse of p into an index
                        +" "); // leaves a trailing space (as shown in example output)
            };

        foreach(var g in Q.ReadLine().Split(',')) // for each cell with geese
        {
            i=int.Parse(g); // grab index of cell
            V(); // compute x/y/z/p
            q=q>x?x:q; // sort out mins/maxes
            w=w<x?x:w;
            e=e>y?y:e;
            r=r<y?y:r;
            t=t>z?z:t;
            u=u<z?z:u;

            // code like the above suggests a solution with a couple of arrays would be better...
            // I've not had success with that yet, but maybe in a couple of days I will try again
        }

        for(i=64;i-->0;) // for each cell
        {
            V(); // compute x/y/z/p
            if(!(x<q|x>w|y<e|y>r|z<t|z>u)) // if we are inside the 'hex' bounds
                if(p>0)
                { // x max, y max, z min
                    // these checks check that we are on the extremes of the 'hex' bounds,
                    // and set up the appropriate vars for W calls to put the edges in
                    // must do y first, because W modifies it for us (saves 2 bytes in the next block)
                    if(y==r) // don't need the ++ (can't go out of 'trianlge' bounds)
                        W();
                    if(x++==w)
                        W();
                    x--;
                    if(z--==t)
                        W();
                    //z++; not used again
                }
                else
                { // x min, y min, z max
                    if(y--==e) // do need the -- (used for 'trianlge' bounds checking)
                        W();
                    // y is reset in W, as such
                    if(x--==q)
                        W();
                    x++;
                    if(z++==u)
                        W();
                    //z--; not used again
                }
        }
    }
}

आप के साथ एक बाइट बचा सकते हैं using System;
लेजियम मैमल 978

@ LegionMammal978 infact वह दो काम कर रहा है .. वह केवल Q.Write और Q.ReadLine के लिए इसका उपयोग करता है। उन, प्लस का उपयोग करते हुए बयान अब वह using Q=System.Console;Q.Write();Q.ReadLine()(45 बाइट्स) बनाम आपके सुझाव using System;Console.Write();Console.ReadLine()(47 बाइट्स) है।
काडे

इसके अलावा, आप नहीं बेकार में आरंभ से 10 बाइट्स ड्रॉप कर सकते हैं i, x, y, z, और p0 पर
LegionMammal978

@ LegionMammal978 क्या आपको यकीन है? मैंने कोशिश की है और यह एक बिना असाइन किए गए वायब्रल का उपयोग करने के लिए त्रुटियां दे रहा है।
काडे

@ Vioz- कौन सा चर? एनोटेट संस्करण पर कौन सी लाइनें?
लेजियम मैमल 978
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.