দ্বীপ গল্ফ # 2: এক্সেন্ট্রিক হার্মিটস

Question

^{এটি দ্বীপ গল্ফ চ্যালেঞ্জের সিরিজের দ্বিতীয়। পূর্ববর্তী চ্যালেঞ্জ}

দু'জন হার্মিট মরুভূমির দ্বীপে এসেছেন। যেহেতু তারা নির্জনতা চেয়েছিল, তাই তারা যথাসম্ভব একে অপরের থেকে দূরে থাকতে চায়। তাদের মধ্যে হাঁটার দূরত্ব সর্বাধিক করতে তাদের ঝুপড়িগুলি কোথায় তৈরি করা উচিত?

সম্পর্কিত পড়া

ইনপুট

আপনার ইনপুটটি একটি আয়তক্ষেত্রাকার গ্রিড হবে যেখানে দুটি অক্ষর থাকবে, স্থল এবং জলের প্রতিনিধিত্ব করবে। নীচের উদাহরণগুলিতে, জমি হ'ল #এবং জল হ'ল .তবে আপনি যে কোনও দুটি স্বতন্ত্র চরিত্রের ইচ্ছামত স্থান নিতে পারেন।

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

সর্বদা কমপক্ষে দুটি স্থল টাইল থাকবে। ল্যান্ড টাইলগুলি সমস্ত মিলবে (যেমন কেবল একটি দ্বীপ রয়েছে)। জলের টাইলগুলিও সংলগ্ন হবে (যেমন কোনও হ্রদ নেই)। গ্রিডের বাইরের সীমানা সমস্ত জলের টাইলস হবে। ল্যান্ড টাইলগুলি তির্যকভাবে সংযুক্ত হবে না : অর্থাত্, আপনি কখনও এর মতো দেখতে পাবেন না

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

আউটপুট

আপনার কোডকে একই গ্রিড আউটপুট করতে হবে, এতে দুটি কুঁড়েঘরের লোকেশন চিহ্নিত রয়েছে। নীচের উদাহরণগুলিতে, কুঁড়েঘরের অবস্থানগুলি এক্স সহ চিহ্নিত করা হয়েছে, তবে আপনি যতক্ষণ না এটি আপনার জমি এবং জলের অক্ষর থেকে পৃথক হওয়া পর্যন্ত কোনও চরিত্রের বিকল্প নিতে পারেন।

কুঁড়েঘরের অবস্থানগুলি দুটি ল্যান্ড টাইলস হতে হবে, যাতে তাদের মধ্যে চলার দূরত্ব সর্বাধিকতর করতে বেছে নেওয়া হয় । আমরা দুটি পয়েন্টের মধ্যে পুরোপুরি স্থলভাগে দীর্ঘতম পথের দৈর্ঘ্য হিসাবে হাঁটার দূরত্বকে সংজ্ঞায়িত করি। ল্যান্ড টাইলগুলি অনুভূমিকভাবে বা উলম্বভাবে সংলগ্ন হিসাবে বিবেচিত হয় তবে ত্রিভুজ নয় ।

উপরের দ্বীপের সম্ভাব্য সমাধান:

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

এই দুটি পয়েন্টের মধ্যে হাঁটার দূরত্ব 11, যা এই দ্বীপের কোনও দুটি পয়েন্টের মধ্যে সর্বাধিক দূরত্ব। আর একটি দূরত্ব -11 সমাধান রয়েছে:

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

বিস্তারিত

আপনার সমাধানটি একটি সম্পূর্ণ প্রোগ্রাম বা কোনও ফাংশন হতে পারে । কোনও ডিফল্ট ইনপুট এবং আউটপুট পদ্ধতি গ্রহণযোগ্য।

আপনার ইনপুট এবং আউটপুটটি একাধিক স্ট্রিং, স্ট্রিংগুলির একটি তালিকা বা 2D অ্যারে / অক্ষর / একক-অক্ষরের স্ট্রিংগুলির তালিকাযুক্ত তালিকা হতে পারে। আপনার আউটপুটে (allyচ্ছিকভাবে) একক ট্রেলিং নিউলাইন থাকতে পারে। উপরে উল্লিখিত হিসাবে, আপনি জায়গায় তিনটি স্বতন্ত্র অক্ষর ব্যবহার করতে পারেন #.X(আপনি কোন অক্ষর ব্যবহার করছেন তা দয়া করে আপনার জমা দেওয়ার ক্ষেত্রে উল্লেখ করুন)।

পরীক্ষার মামলা

উ : অনন্য হাট প্লেসমেন্ট সহ দ্বীপপুঞ্জ:

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

....
.XX.
....

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

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

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

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

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

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

খ। একাধিক সম্ভাব্য সমাধান সহ একটি দ্বীপের উদাহরণ:

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

সম্ভাব্য আউটপুট:

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

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

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

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

সি একটি সারকথা মত বৃহৎ পরীক্ষা ক্ষেত্রে

---

এটি কোড-গল্ফ : প্রতিটি ভাষার মধ্যে সংক্ষিপ্ততম কোড জিততে পারে।

Comments

এগুলি দুর্দান্ত ছোট চ্যালেঞ্জগুলি (বিশেষত কোনও সীমানা পরীক্ষা করা না করানো আমার পছন্দ!): পরেরটির জন্য অপেক্ষা!

— ভিজ্যুমেলন 21 '23

হাঁটার দূরত্ব কি ম্যানহাটনের দূরত্ব?

— সার্জে বোর্শ

@ সার্জবার্চ নিবিড়ভাবে সম্পর্কিত, তবে সবসময় একই নয়। ম্যানহাটনের দূরত্ব মাত্র Δx + isy, তবে হাঁটার দূরত্ব আরও দীর্ঘ হতে পারে কারণ আপনি সমুদ্রের টাইলগুলি পেরিয়ে যেতে পারবেন না। (উদাহরণস্বরূপ 'ক' বিভাগের শেষ উদাহরণটি দেখুন two দুটি এক্স এর মধ্যে ম্যানহাটনের দূরত্ব is, তবে হাঁটার দূরত্ব - সর্পিল অনুসরণ করে - ২২))

— DLosc

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:]

পূর্ববর্তী সংস্করণ:

ইনপুটটি একক স্ট্রিং, 'সহ'। এবং '#' যথাক্রমে জল এবং জমি প্রতিনিধিত্ব করে। 'এক্স' আউটপুটে ঝুপড়িগুলিকে প্রতিনিধিত্ব করে।

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 [(কে, আই)] + ১ টি ইতিমধ্যে ডি-তে থাকা পাথগুলি অন্তর্ভুক্ত করবেন না। আপনি যদি খালি না থাকেন তবে ডি তে নতুন দীর্ঘ পাথ যুক্ত করুন এবং পুনরাবৃত্তি করুন। আপনি যখন খালি থাকেন, তার অর্থ আর কোনও পথ তৈরি করা যায়নি। এখন 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
    }
}