द्वीप गोल्फ # 2: सनकी साधु

Question

^{यह द्वीप गोल्फ चुनौतियों की एक श्रृंखला में दूसरा है। पिछली चुनौती}

एक रेगिस्तानी द्वीप पर दो हर्मिट्स आए हैं। चूँकि वे एकांत की तलाश में आए थे, वे एक-दूसरे से यथासंभव दूर रहना चाहते हैं। उनके बीच की पैदल दूरी को अधिकतम करने के लिए उन्हें अपनी झोपड़ियों का निर्माण कहाँ करना चाहिए?

संबंधित पढ़ना

इनपुट

आपका इनपुट एक आयताकार ग्रिड होगा जिसमें दो वर्ण होंगे, जो भूमि और पानी का प्रतिनिधित्व करेंगे। नीचे दिए गए उदाहरणों में, भूमि है #और पानी है ., लेकिन आप अपनी इच्छा के अनुसार दो अलग-अलग वर्णों का विकल्प चुन सकते हैं।

...........
...##......
..#####....
..#######..
.#########.
...#######.
...#####.#.
....####...
...........

हमेशा कम से कम दो भूमि टाइलें होंगी। भूमि की टाइलें सभी सन्निहित होंगी (यानी केवल एक द्वीप है)। पानी की टाइलें भी सन्निहित होंगी (यानी झीलें नहीं हैं)। ग्रिड की बाहरी सीमा सभी में पानी की टाइलें होंगी। जमीन की टाइलें तिरछे नहीं जुड़ी होंगी : यानी, आपको कभी ऐसा कुछ दिखाई नहीं देगा

....
.#..
..#.
....

उत्पादन

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

हट स्थान दो भूमि टाइल होने चाहिए, ताकि उनके बीच चलने की दूरी को अधिकतम करने के लिए चुना जा सके । हम चलने की दूरी को सबसे कम पथ की लंबाई के रूप में परिभाषित करते हैं, पूरी तरह से जमीन पर, दो बिंदुओं के बीच। भूमि टाइल को निकट या क्षैतिज रूप से लंबवत माना जाता है, लेकिन तिरछे नहीं ।

उपरोक्त द्वीप के लिए एक संभावित समाधान:

...........
...X#......
..#####....
..#######..
.#########.
...#######.
...#####.X.
....####...
...........

इन दो बिंदुओं के बीच की पैदल दूरी 11 है, जो इस द्वीप पर किसी भी दो बिंदुओं के बीच की सबसे बड़ी दूरी है। एक और दूरी -11 समाधान है:

...........
...##......
..X####....
..#######..
.#########.
...#######.
...#####.X.
....####...
...........

विवरण

आपका समाधान एक पूर्ण कार्यक्रम या फ़ंक्शन हो सकता है । का कोई भी डिफ़ॉल्ट इनपुट और आउटपुट तरीकों स्वीकार्य हैं।

आपका इनपुट और आउटपुट एक मल्टीलाइन स्ट्रिंग, स्ट्रिंग्स की एक सूची या 2 डी सरणी / नेस्टेड वर्णों / एकल-वर्ण स्ट्रिंग्स की सूची हो सकती है। आपके आउटपुट (वैकल्पिक रूप से) में एक एकल अनुगामी न्यूलाइन हो सकती है। जैसा कि ऊपर उल्लेख किया गया है, आप के स्थान पर किसी भी तीन अलग-अलग वर्णों का उपयोग कर सकते हैं #.X(कृपया अपनी प्रविष्टि में निर्दिष्ट करें कि आप किन वर्णों का उपयोग कर रहे हैं)।

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

ए अद्वितीय झोपड़ी नियुक्तियों के साथ द्वीप:

....
.##.
....

....
.XX.
....

......
......
..##..
...#..
......
......

......
......
..X#..
...X..
......
......

........
.#####..
.##..##.
.#..###.
.##..##.
........

........
.#####..
.##..##.
.#..###.
.#X..#X.
........

.........
.#####.#.
.#...#.#.
.#.###.#.
.#.....#.
.#######.
.........

.........
.#####.X.
.#...#.#.
.#.X##.#.
.#.....#.
.#######.
.........

बी कई संभावित समाधान के साथ एक द्वीप का उदाहरण:

........
....##..
...####.
..###...
.#####..
.#####..
..##....
........

संभव आउटपुट:

........
....#X..
...####.
..###...
.#####..
.X####..
..##....
........

........
....#X..
...####.
..###...
.#####..
.#####..
..X#....
........

........
....##..
...###X.
..###...
.#####..
.X####..
..##....
........

........
....##..
...###X.
..###...
.#####..
.#####..
..X#....
........

सी। बड़े परीक्षण का मामला एक जिस्ट के रूप में

---

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

Comments

ये बहुत छोटी चुनौतियां हैं (मुझे विशेष रूप से किसी भी सीमा की जाँच नहीं करना पसंद है!): अगले एक की प्रतीक्षा में!

— विजुअलमेल

पैदल दूरी मैनहट्टन दूरी है?

— सर्ज बोरश

@SgegeBorsch निकटता से संबंधित, लेकिन हमेशा समान नहीं। मैनहट्टन की दूरी सिर्फ +x + buty है, लेकिन पैदल दूरी लंबी हो सकती है क्योंकि आप समुद्र की टाइलों पर नहीं चल सकते। (अनुभाग 'ए' में अंतिम उदाहरण देखें, उदाहरण के लिए। दो एक्स के बीच मैनहट्टन की दूरी 6 है, लेकिन चलने की दूरी - सर्पिल का पीछा करते हुए - 22 है।)

— DLosc 5

Answer 1

पायथन 3, 249 246 बाइट्स

3 बाइट्स को शेव किया, धन्यवाद DLosc।

इनपुट और आउटपुट एकल स्ट्रिंग्स हैं, जिनमें '।', '@', और 'एक्स' क्रमशः पानी, झोपड़ियों और भूमि का प्रतिनिधित्व करते हैं।

A='@'
def f(s):
 w=s.find('\n')+1;d=u={(k,k):0for k,c in enumerate(s)if A<c}
 while u:d.update(u);u={(k,j):d[(k,i)]+1for k,i in d for j in{i+1,i+w,i-1,i-w}if A<s[j]and(k,j)not in d}
 k,j=sorted(max(d,key=d.get))
 return s[:k]+A+s[k+1:j]+A+s[j+1:]

पिछला संस्करण:

इनपुट एकल स्ट्रिंग है, '।' और '#' क्रमशः पानी और भूमि का प्रतिनिधित्व करते हैं। 'X' आउटपुट में हट्स को दर्शाता है।

def f(s):
 w=s.find('\n')+1;d=u={(k,k):0for k,c in enumerate(s)if'#'==c}
 while u:d.update(u);u={(k,j):d[(k,i)]+1 for k,i in d for j in{i+1,i+w,i-1,i-w}if'#'==s[j]and(k,j)not in d}
 k,j=sorted(max(d,key=d.get))
 return s[:k]+'X'+s[k+1:j]+'X'+s[j+1:]

स्पष्टीकरण:

यह मूल रूप से एक ही समय में हर शुरुआती शुरुआती बिंदु से चौड़ाई खोज कर रहा है। मार्ग की शुरुआत और अंत के द्वारा तय किए गए पथ की लंबाई का एक शब्दकोश, डी रखें, जैसे, डी [(के, आई)] कश्मीर से आई की दूरी है। फिर शब्दकोश में कुंजियों पर पुनरावृति करें, डी, और एक नया शब्दकोश बनाएं, यू, उन रास्तों के साथ जो 1 इकाई हैं जो अंतिम बिंदु 1 इकाई को एन, एस, ई, डब्ल्यू, जैसे, यू [(के, i + 1)] = d [(k, i)] + 1. वे पथ शामिल न करें जो पहले से ही d में हैं। यदि यू खाली नहीं है, तो डी और दोहराने के लिए नए लंबे रास्तों को जोड़ें। जब यू खाली होता है, तो इसका मतलब है कि कोई और रास्ता नहीं बनाया जा सकता है। अब d में सभी संभावित पथ और उनकी लंबाई समाहित है। तो यह सिर्फ सबसे लंबे रास्ते के साथ कुंजी प्राप्त करने की बात है।

कम गोल्फ वाला, टिप्पणी वाला संस्करण:

def f(s):
  w=s.find('\n')+1                    # width of a row, or a move N or S

  d = {}                              # dictionary of all the paths.
                                      # The key is a tuple (k,j) and the
                                      # value is the distance from k to j.
  for k,c in enumerate(s):            # Initialize. Distance from k to k is 0
    if'#'==c:                         # Only do land.
      d[(k,k)] = 0

  u = d                               # dictionary of new paths. initialize it to d
                                      # so loop is entered. first d.update is
                                      # basically a NOP

  while u:                            # while there are new paths
    d.update(u)                       # add the new paths to the dict of old paths
    u={}                              #
    for k,i in d:                     # iterate over the known paths. k is the start, i is the end
      for j in{i+1,i+w,i-1,i-w}:      # iterate over squares 1 move to the E,S,W,N from i
        if'#'==s[j]and(k,j)not in d:  # if it's still land, and the path (k,j) isn't already in d,
          u[(k,j)] = d[(k,i)]+1       # then add the new path to u

  k,j=sorted(max(d,key=d.get))        # find the longest path

  return s[:k]+'X'+s[k+1:j]+'X'+s[j+1:]  # X marks the endpoints.

Answer 2

सी #, 387 बाइट्स

चलिए गेंद घुमाते हैं ...

using C=System.Console;class P{static void Main(){string D="",L;int W=0,H=0,z,n,q,h,b=0,c,a,i=0,j=0;for(;(L=C.ReadLine())!=null;H+=W=L.Length)D+=L+="\n";for(z=H;z-->0;){int[]S=new int[H],Q=new int[H*8];for(Q[h=q=0]=z;q<=h;)if((c=S[n=Q[q++]]-1)<0&D[S[n]=n]==35)for(a=4;a-->0;b=c<b?c+(i=z)*(j=n)*0:b)S[Q[++h]=new[]{1,-1,W,-W}[a]+n]=S[Q[h]]<1?c:1;}for(;++z<H;)C.Write(z==i|z==j?'X':D[z]);}}

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

पूरा कार्यक्रम, STDIN से पढ़ता है, STDOUT को लिखता है। यह बस प्रत्येक सेल के ऊपर जाता है, और बीएफएस को सबसे दूर के सेल की गणना करने के लिए चलाता है, दोनों को रिकॉर्ड करते हुए अगर यह रिकॉर्ड पर सबसे दूर है। यह वास्तव में कुछ भी नहीं है, और निराशा से थोड़ा मैं गोल्फ को पा सकता हूं।

प्रारूपित और टिप्पणी की गई कोड:

using C=System.Console;

class P
{
    // \n 10
    // \r 13
    // . 46
    // # 35
    // x 88

    static void Main()
    {
        string D="", // map
            L; // line of input

        int W=0, // width
            H=0, // length
            z, // outer position
            n, // next position to expand
            q, // queue position pointer
            h, // queue head pointer
            b=0, // best
            c, // distance to this cell (negative)
            a, // counter
            i=0, // hermit 1 pos
            j=0; // hermit 2 pos

        for(;(L=C.ReadLine())!=null; // read a line, while we can
                H+=W=L.Length) // record the width, and add to length
            D+=L+="\n"; // add a newline, and add the line to the map

        for(z=H;z-->0;) // for each cell
        {
            int[]S=new int[H], // 'seen' >0 -> seen, else it is the distance we have found to it
                Q=new int[H*8]; // due queue (fewer than H*4 expantions, two ints each)

            // standard BFS
            for(Q[h=q=0] // reset currect 
                =z; // expand z first
                q<=h;)
                if((c=S[n=Q[q++]]-1)<0& // record 'seen', and check we havn't been seen
                    D[S[n]=n]==35) // mark as seen, and check we are a hash #
                    // 'move'
                    for(a=4;a-->0; // for each of the 4 neighbours
                            b=c<b? // if we have beaten the best
                            c+(i=z)*(j=n)*0: // set new best, record hermit positions
                            b)
                        S[Q[++h]=new[]{1,-1,W,-W}[a]+n]= // queue it for expantion
                        S[Q[h]]<1? // not seen? (this is BFS, don't need to check c is less thatn S[l+n]
                        c: // distance
                        1; // mark as seen (means it won't actually be expanded)
        }

        // z = -1
        for(;++z<H;) // for each cell
            C.Write(z==i|z==j?'X':D[z]); // print either the original char, or X if it is a hermit's home
    }
}