পটভূমি

আপনি একজন শক্তিশালী উইজার্ডের শিক্ষানবিশ এবং আপনার মাস্টার তার শত্রুদের ফাঁদে ফেলার জন্য একটি আন্ত-মাত্রিক গোলকধাঁধা তৈরি করার জন্য বর্তমানে একটি স্পেল তৈরি করছেন He এই ডায়াবোলিকাল মেশিনটিকে প্রোগ্রামিং করা অত্যন্ত বিপজ্জনক, সুতরাং আপনি কোডটি যতটা সম্ভব সংক্ষিপ্ত রাখতে চাইবেন।

ইনপুট

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

এই গ্রিডটি একটি অসীম গোলকধাঁধার ব্লুপ্রিন্ট, যা একে অপরের পাশে গ্রিডের অনুলিপি অনেকগুলি অনুলিপি তৈরি করে তৈরি করা হয়। গোলকধাঁধাটি গহ্বরগুলিতে বিভক্ত , যা খালি জায়গাগুলির সাথে সংযুক্ত উপাদান (ত্রিভুজ সংলগ্ন স্থানগুলি সংযুক্ত নয়)। উদাহরণস্বরূপ, গ্রিড

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

নিম্নলিখিত গোলকধাঁধার ফলাফল (সমস্ত দিক দিয়ে অসীম অব্যাহত):

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

এই বিশেষ গোলকধাঁধায় অসীম ক্ষেত্রের গহ্বর রয়েছে। অন্যদিকে, এই ব্লুপ্রিন্টের ফলে কেবল সীমাবদ্ধ গহ্বরযুক্ত গোলকধাঁধার ফলাফল:

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

আউটপুট

যদি গোলকধাঁধাঁটিতে একটি অসীম গহ্বর থাকে এবং যদি না থাকে তবে একটি মিথ্যা মান থাকে তবে আপনার আউটপুটটি সত্যই মূল্য হবে। মনে রাখবেন যে গোলকধাঁধায় সীমাবদ্ধ এবং অসীম গহ্বর উভয়ই থাকতে পারে; সেক্ষেত্রে আউটপুট সত্য হবে।

বিধি

আপনি একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন। সর্বনিম্ন বাইট গণনা জয়, এবং মান লুফোলগুলি অনুমোদিত নয়।

অতিরিক্ত পরীক্ষার কেস

অসীম গহ্বর:

.#

#.#
...
#.#

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

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

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

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

সীমাবদ্ধ গহ্বর:

###
#.#
###

.#
#.

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

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

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

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

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


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

— Zgarb
সূত্র

সেখানে কি কোনও নতুন লাইনের চরিত্র রয়েছে?

— FUZxxl

@FUZxxl- এটি আপনার কাছে।

— জাগারব

অসীম গোলকধাঁধা কি এমন সরল রেখা হতে পারে যা অনন্তের দিকে যায়।

1

@ নীল আমি আপনার অর্থ কী তা নিশ্চিত নই not প্রথম এবং দ্বিতীয় অসীম উদাহরণগুলিতে অসীম রেখা রয়েছে তবে ইনপুটটিতে কমপক্ষে একটি .এবং একটি #রয়েছে।

— জাগারব

1

দুর্দান্ত চ্যালেঞ্জ, এটির থেকে মনে হচ্ছে আরও কঠিন

— edc65

2

জাভাস্ক্রিপ্ট (ES6), 235 253

@ ম্যাক দ্বারা ব্যবহৃত একই পদ্ধতি। প্রতিটি বিনামূল্যে কক্ষের জন্য, আমি পুনরাবৃত্ত ফিল পূরণ করে চেষ্টা করি, আমি যে স্থানাঙ্ক ব্যবহার করছি তার সাথে ব্যবহৃত সেলগুলি চিহ্নিত করে (এটি অরজিনাল টেম্প্লেটের বাইরে থাকতে পারে)। যদি পূরণের সময় আমি ইতিমধ্যে একটি পৃথক স্থানাঙ্কযুক্ত চিহ্নিত কক্ষে পৌঁছে যাই তবে আমি অসীম পথে আছি।

বিচিত্র উপায় মডিউল নিয়ন্ত্রণ জাতীয় এটা বেশ বিরক্তিকর।

L=g=>(
  g=g.split('\n').map(r=>[...r]),
  w=g[0].length,h=g.length,
  F=(x,y,t=((x%w)+w)%w,u=((y%h)+h)%h,v=g[u][t],k=0+[x,y])=>
    v<'.'?0:v>'.'?v!=k
    :[0,2,-3,5].some(n=>F(x+(n&3)-1,y+(n>>2)),g[u][t]=k),
  g.some((r,y)=>r.some((c,x)=>c=='.'&&F(x,y)))
)

টেস্ট সালে ফায়ারফক্স / ফায়ারবাগ কনসোলটি

অসীম

['##.###\n#..###\n..##..\n###..#\n##..##'
,'#.#\n...\n#.#'
,'#.###.#.###.#\n#.#...#...#.#\n#.#.#####.#.#\n..#.#...#.#..\n###.#.#.#.###\n#...#.#.#...#\n#.###.#.###.#'
,'##.###\n#..###\n..##..\n###..#\n##..##'
,'#.####.###.###.####\n#...#..#...###..###\n###.#..#.######..##\n....####.#######...\n###..###...########\n##########.##....##\n..###......##.##...\n#.........##..#####\n###########..###..#\n#...........####..#\n#.###########.##..#\n#.##....##.....####\n#.####.###.###.####'
].forEach(g=>console.log(g,L(g)))

আউটপুট

"##.###
#..###
..##..
###..#
##..##" true

"#.#
...
#.#" true

"#.###.#.###.#
#.#...#...#.#
#.#.#####.#.#
..#.#...#.#..
###.#.#.#.###
#...#.#.#...#
#.###.#.###.#" true

"##.###
#..###
..##..
###..#
##..##" true

"#.####.###.###.####
#...#..#...###..###
###.#..#.######..##
....####.#######...
###..###...########
##########.##....##
..###......##.##...
#.........##..#####
###########..###..#
#...........####..#
#.###########.##..#
#.##....##.....####
#.####.###.###.####" true

সসীম

['###\n#.#\n###', '.#\n#.', '####\n.#..\n####'
,'#.#.#\n..#..\n#####\n..#..\n#.#.#'
,'#.#.#.#.#.#\n..#...#.#..\n###.###.###\n..#.#......\n#.#.#######\n#.#.......#\n#.#######.#\n#.#.....#.#\n#.#.#.#.#.#'
,'##....#####\n.#..#...##.\n.##.#..#...\n..###.###..\n#..##.#####\n#...##....#\n#.#.#####.#\n###..####.#\n....####...\n###...#####'
,'###....##.#########\n####...##....#...##\n..####.#######.###.\n....##..........##.\n###..#####.#..##...\n####..#..#....#..##\n..###.####.#.#..##.\n..###...#....#.#...\n..####..##.###...##\n#.####.##..#####.##\n####...##.#####..##'
].forEach(g=>console.log(g,L(g)))

আউটপুট

"###
#.#
###" false

".#
#." false

"####
.#..
####" false

"#.#.#
..#..
#####
..#..
#.#.#" false

"#.#.#.#.#.#
..#...#.#..
###.###.###
..#.#......
#.#.#######
#.#.......#
#.#######.#
#.#.....#.#
#.#.#.#.#.#" false

"##....#####
.#..#...##.
.##.#..#...
..###.###..
#..##.#####
#...##....#
#.#.#####.#
###..####.#
....####...
###...#####" false

"###....##.#########
####...##....#...##
..####.#######.###.
....##..........##.
###..#####.#..##...
####..#..#....#..##
..###.####.#.#..##.
..###...#....#.#...
..####..##.###...##
#.####.##..#####.##
####...##.#####..##" false

— edc65
সূত্র

হ্যাঁ, ডাফ্ট মডুলোও সি # তে ব্যথা পেয়েছিল, তবে আমি মনে করি যে আমি আমার কার্যকরী অনুলিখনের কোডের সাথে এটির যথাযথ ব্যবহার করার একটি উপায় খুঁজে পেয়েছি (যদি আমি 10% পেতে পারি তবে আমি কেবল পুনরায় পোস্ট করব) হ্রাস বা আরও ভাল): (j%4-1)%2একটি দুর্দান্ত পুনরাবৃত্তি প্যাটার্ন দেয়।

— ভিজুয়ালমেলন

আমি বিশ্বাস করি নামবিহীন ফাংশনগুলি জায়েজ এবং এইভাবে, যদি না থাফঙ্কশনে নিজের কাছে একটি কল অন্তর্ভুক্ত থাকে (এটি প্রদর্শিত হবে না) এটি L=বাইট গণনার দিকে গণনা না করার জন্য অনুমোদিত ।

— সুপারজেডি ২৪

@ সুপারজেডি ২২৪ আপনি সম্ভবত সঠিক, তবে যথারীতি এটি যথেষ্ট সংক্ষিপ্ত

— edc65

21

সি # - 423 375 বাইট

সম্পূর্ণ সি # প্রোগ্রাম, এসটিডিএন এর মাধ্যমে ইনপুট গ্রহণ করে, যথাযথ হিসাবে "সত্য" বা "মিথ্যা" কে এসটিডিআউট আউটপুট করে।

আমি এই লিঙ্কটিকে সেখানে রেখে দিতে পারলাম না ... ধন্যবাদ, এর অপসারণ বন্ধ হয়ে গেল! এটি এখন অ্যারেতে দেখা এবং পরিদর্শন করা কক্ষগুলিকে ট্র্যাক করে রাখে (এটি প্রদত্ত যে কোনওভাবেই সীমাবদ্ধ সংখ্যার দিকে নজর দেওয়া হয়)। আমি লাম্বদার প্রয়োজনীয়তা অপসারণ করে এবং সাধারণত কোডটি বোঝার পক্ষে আরও অসম্ভব করে দিয়েছি (তবে যথেষ্ট বাইট সঞ্চয় সহ) আমি আবার দিকনির্দেশক কোডটিও লিখেছিলাম।

using C=System.Console;struct P{int x,y;static void Main(){int w=0,W,k=0,o,i,j;P t;string D="",L;for(;(L=C.ReadLine())!=null;D+=L)w=L.Length;for(i=W=D.Length;i-->0&k<W;){k=1;P[]F=new P[W];for(F[j=0].x=i%w+W*W,F[0].y=i/w+W*W;D[i]>35&j<k;)for(t=F[j++],o=1;o<5&k<W;t.y+=(o++&2)-1){t.x+=o&2;if(D[--t.x%w+t.y%(W/w)*w]>35&System.Array.IndexOf(F,t)<0)F[k++]=t;}}C.WriteLine(k>=W);}}

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

অবিরত কোড:

using C=System.Console;

struct P
{
    int x,y;

    static void Main()
    {
        int w=0, // w is the width
        W, // W is the length of the whole thing
        k=0, // k is visited count
        o, // o is offset, or something (gives -1,0 0,-1 +1,0 0,+1 t offset pattern)
        i, // i is the start cell we are checking currently
        j; // j is the F index of the cell we are looking at

        P t; // t is the cell at offset from the cell we are looking at

        string D="", // D is the map
        L;

        for(;(L=C.ReadLine())!=null; // read a line, while we can
            D+=L) // add the line to the map
            w=L.Length; // record the width

        for(i=W=D.Length;i-->0&k<W;) // for each cell
        {
            k=1;

            P[]F=new P[W]; // F is the list of visited cells,

            for(F[j=0].x=i%w+W*W,F[0].y=i/w+W*W; // there are reasons (broken modulo)
                D[i]>35&j<k;) // for each cell we've visited, until we've run out
                for(t=F[j++], // get the current cell
                    o=1; // o is just a counter which we use to kick t about
                    o<5& // 4 counts
                    k<W; // make sure we havn't filled F
                    t.y+=(o++&2)-1) // kick and nudge y, inc o
                {
                    t.x+=o&2; // kick x
                    if(D[--t.x%w+t.y%(W/w)*w]>35 // nudge x, it's a dot
                       &System.Array.IndexOf(F,t)<0) // and we've not seen it before
                        F[k++]=t; // then add it
                }
        }

        C.WriteLine(k>=W); // result is whether we visited lots of cells
    }
}

— VisualMelon
সূত্র

1

সম্ভবত প্রথমবার আমি C#এখানে শীর্ষ ভোট প্রাপ্ত হিসাবে একটি উত্তর দেখেছি ।

— মাইকেল ম্যাকগ্রিফ

1

কাঠামোতে প্রধান () এখন সুন্দর cute

— PTwr

10

পাইথন 2 - 258 210 244 বাইট

পুনরাবৃত্তভাবে পাথগুলি পরীক্ষা করুন, যদি স্ট্যাক ওভারফ্লো 1 ফিরে আসে (সত্য) অন্য কোনওটি (মিথ্যা নয়) ফেরত দেয়।

import sys
def k(s):
 a=len(s);m=[[c=='.'for c in b]*999for b in s.split('\n')]*999;sys.setrecursionlimit(a)
 for x in range(a*a):
  try:p(m,x/a,x%a)
  except:return 1
def p(m,x,y):
 if m[x][y]:m[x][y]=0;map(p,[m]*4,[x,x,x+1,x-1],[y+1,y-1,y,y])

— কাইল গুলিয়ান
সূত্র

1

আপনি ;লাইনগুলি ব্যবহার করে কিছু বাইট সংরক্ষণ করতে পারেন p, যেহেতু আপনি সেগুলি একই লাইনে পাবেন if।

— পুর্কাকুডারী

11

"যদি স্ট্যাক ওভারফ্লো সত্য হয়ে যায়" - আমি সেই পুনরাবৃত্তির সমাপ্তি শর্ত পছন্দ করি :)

— schnaader

3

আমি নিশ্চিত নই যে এটি একটি বৈধ পন্থা। "অসীম" অঞ্চল সনাক্ত করতে স্ট্যাক ওভারফ্লোগুলি ব্যবহার করা মিথ্যা ধনাত্মকতা তৈরি করবে। সমস্যা স্পেক ইনপুট রেঞ্জের কোনও সীমাবদ্ধতার বিবরণ দেয় না তবে 300x300 গোলকধাঁধা এর মতো কিছু অযৌক্তিক বলে মনে হয় না এবং খুব দীর্ঘ সীমাবদ্ধ পথগুলি আবদ্ধ করতে পারে।

— 14

4

প্রায় সমস্ত সসীম মেজগুলি স্ট্যাকের ওভারফ্লোও ঘটায়। এটি কোনও বৈধ প্রোগ্রাম নয়।

— পাইরুলেজ

@ জোহনে আপডেট হয়েছে তাই পুনরাবৃত্তি সীমাটি গোলকধাঁধার আকারের ক্রম অনুসারে। দুর্ভাগ্যক্রমে 34 বাইট যুক্ত হয়েছে তবে এটি এখনই সঠিক হওয়া উচিত (কমপক্ষে হ্যাকের মতো এটি সঠিক হতে পারে)।

— কাইল গুলিয়ন

5

পাইথন 2 - 297 286 275 বাইট

থেকে একটি বন্যা পূরণ শুরু করতে একটি স্বেচ্ছাসেবী "খোলা" সেল চয়ন করে। ভরাট চলাকালীন যদি আমরা ইতিমধ্যে পরিদর্শন করা একটি কক্ষটি আবার দেখি তবে ল্যাবরেথ অসীম। যদি এইরকম কোনও ঘর না পেয়ে বন্যা ভরাট পুরো অঞ্চলটি পূরণ করে, তবে একটি আলাদা অঞ্চল চেষ্টা করুন। যদি এই জাতীয় অঞ্চল খুঁজে পাওয়া যায় না, তবে গোলকধাঁধা সীমাবদ্ধ।

কমান্ড লাইনে প্রক্রিয়া করার জন্য ফাইল নেয়, 1অসীমের 0জন্য এবং সীমাবদ্ধতার জন্য প্রস্থান কোড ফেরৎ দেয় ।

সমস্ত পরীক্ষার ক্ষেত্রে সঠিক ফলাফল দেয়।

import sys
e=enumerate
C=dict([((i,j),1)for i,l in e(open(sys.argv[1]))for j,k in e(l)if'.'==k])
while C:
 d={}
 def f(r,c):
  n=(r%(i+1),c%j)
  if n in d:return(r,c)!=d[n]
  if C.pop(n,0):d[n]=(r,c);return any(map(f,[r-1,r,r+1,r],[c,c+1,c,c-1]))
 if f(*C.keys()[0]):exit(1)

— ম্যাক
সূত্র

1

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