একটি ম্যাট্রিক্সে সাপ সন্ধান করা

32

চ্যালেঞ্জ

একটি বাইনারি ম্যাট্রিক্স এবং একটি বাইনারি স্ট্রিং দেওয়া, নির্ধারণ করুন যে বাইনারি স্ট্রিংটি ম্যাট্রিক্সের যে কোনও বিন্দুতে শুরু হয়ে বাইনারি স্ট্রিং গঠনের জন্য পরবর্তী কোনও বিন্দুতে কোনও দিকে অগ্রসর হতে পারে কিনা। অর্থাৎ, ম্যাট্রিক্সের অভ্যন্তরে তবে স্ট্রিংটি ভাঁজ করে পাওয়া যাবে?

স্ট্রিংটি কেবল 90 ডিগ্রি বা 180 ডিগ্রি (প্রান্ত সংযোগগুলি; ম্যানহাটন দূরত্ব 1) এ ভাঁজ করা যায় এবং কোনও পয়েন্টে নিজেকে ওভারল্যাপ করতে পারে না।

উদাহরণ

আসুন নীচের উদাহরণটি ধরুন:

Matrix:

010101
111011
011010
011011

Snake: 0111111100101

এটি একটি সত্যবাদী পরীক্ষার মামলা। আমরা দেখতে পাচ্ছি যে সাপটি নিম্নলিখিত অবস্থানে ভাঁজ হয়েছে:

0-1 0 1 0 1
  |
1 1 1-0 1 1
  | | |   |
0 1 1 0-1-0
  | |
0 1-1 0 1 1

বিধি

  • স্ট্যান্ডার্ড লুফোলস প্রয়োগ করুন
  • আপনি চাইলে স্ট্রিংয়ের দৈর্ঘ্য এবং ম্যাট্রিক্সের প্রস্থ এবং উচ্চতা ইনপুট হিসাবে নিতে পারেন
  • আপনি বাইনারি ম্যাট্রিক্স এবং বাইনারি স্ট্রিংকে স্ট্রিংয়ের একাধিক স্ট্রিং / অ্যারে / নিউলাইন-যুক্ত স্ট্রিং / অন্য যে কোনও কিছুতে যুক্ত-স্ট্রিং এবং একটি স্ট্রিং হিসাবে নিতে পারেন
  • আপনি কয়েকটি যুক্তির পরিবর্তে ফ্ল্যাট অ্যারে হিসাবে মাত্রা নিতে পারেন
  • আপনার প্রোগ্রামটি অবশ্যই এক মিনিটের মধ্যে 10 দৈর্ঘ্য পর্যন্ত কোনও স্ট্রিং সহ 5 x 5 ম্যাট্রিক্সের জন্য শেষ করতে হবে

সীমাবদ্ধতা

  • ম্যাট্রিক্স অগত্যা বর্গক্ষেত্রের নয়
  • স্ট্রিংটি খালি থাকবে না
  • স্ট্রিং দৈর্ঘ্য -1 হতে পারে
  • স্ট্রিংটিতে উপলব্ধের চেয়ে বেশি স্কোয়ার থাকবে না (এটি হ'ল len(string) <= width(matrix) * height(matrix)

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

Truthy

01010
10101
01010
10101
01010

0101010101010101010101010



01110
01100
10010
10110
01101

011111000110100



0

0



10
01

1010



100
010
001

100010001

Falsy

00000
00000
00000
00000
00000

1



10101
01010
10101
01010
10101

11



100
010
001

111



10001
01010
00100
01010
10001

1000100010001000101010100
code-golf  decision-problem  binary-matrix 
— HyperNeutrino
সূত্র
— হাইপারনিউটারিনো
4
বা: বাইনারি বগল! এছাড়াও, আপনি আরও কয়েকটি পরীক্ষার কেস যুক্ত করতে পারেন?
— জোনা
1
এই প্রসঙ্গে ফ্ল্যাট, তীক্ষ্ণ এবং গোলাকার অর্থ কী? বর্গের অর্থ এই নয় যে প্রস্থ এবং উচ্চতা সম্ভবত সমান নয়, বা অ্যারেটি জাজ করা যায়?
— তাহগ
পৃথিবীতে কি গোলাকার অ্যারে
— কনর ও'ব্রায়েন
— মার্টিন এণ্ডার

উত্তর:

13

পাইথন 2 , 275 271 264 249 বাইট

  • প্রতিস্থাপন চার বাইট সংরক্ষিত -1সঙ্গে Hএবং এক slicing অপারেশন সরানোর ( [:])।
  • হালভার্ড হুমেলের জন্য সাতটি বাইট সংরক্ষণ করা ; আরও একটি স্লাইসিং অপারেশন ( [:]) অপসারণ করে, একটি পরিদর্শন করা এন্ট্রিকে একটি মান v not in "01"( S=S[1:];M[y][x]=H;-> S=M[y][x]=S[1:];) দেওয়ার জন্য একাধিক-টার্গেট অ্যাসাইনমেন্ট ব্যবহার করে এবং / অন্য কোনও সরল যৌক্তিক বা ( any(...)if S else 1-> not S or any(...)) এ সারণী থেকে স্যুইচ করা ।
  • আপনি যদি কিছুটা সত্য ও মিথ্যা সংজ্ঞাটি প্রসারিত করেন তবে আপনি এই 257 বাইট দীর্ঘ সমাধানের অনুমতি দিতে পারবেন । ZeroDivisionErrorসাপ পাওয়া গেলে এটি একটি ব্যতিক্রম ( ) উত্থাপন করে এবং []যখন কোনও সাপ খুঁজে পাওয়া যায় না তখন একটি খালি তালিকা ( ) সরবরাহ করে, যা দুটি স্বতন্ত্র আচরণ।
  • 202029 ব্যবহারকারীর জন্য চৌদ্দ বাইট সংরক্ষণ করা ; দুটি অ্যারে গভীর কপি গল্ফিং
  • একটি বাইট সংরক্ষণ করা; golfed not S orকরতে S<[1]or~ S==[]or।
lambda M,S,w,h:any(H(eval(`M`),S,w,h,x,y)for y in range(h)for x in range(w)if S[0]==M[y][x])
def H(M,S,w,h,x,y):S=M[y][x]=S[1:];return S<[1]or any(H(eval(`M`),S,w,h,x+X,y+Y)for X,Y in[(~0,0),(1,0),(0,~0),(0,1)]if~0<x+X<w>0<=y+Y<h!=S[0]==M[y+Y][x+X])

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ল্যাম্বদা ফাংশন যা ম্যাট্রিক্সকে স্ট্রিংয়ের দ্বি-মাত্রিক তালিকা হিসাবে (উভয় "0"বা "1") হিসাবে গ্রহণ করে, সাপকে একটি মাত্রিক তালিকা হিসাবে এবং ম্যাট্রিক্সের মাত্রা দুটি পূর্ণসংখ্যার হিসাবে গ্রহণ করে।
ল্যাম্বদা ফাংশন স্নানের প্রথম উপাদানটির সাথে মেলে এমন প্রবেশের জন্য ম্যাট্রিক্স অনুসন্ধান করে। প্রতিটি পাওয়া ম্যাচের জন্য, এটি Hম্যাট্রিক্সের একটি গভীর অনুলিপি, সাপের কোনও অনুলিপি, ম্যাট্রিক্সের মাত্রা এবং ম্যাচের অবস্থানের সাথে কল করে।

যখন Hডাকা হয়, এটি S'প্রথম এন্ট্রি সরিয়ে দেয় এবং প্রদত্ত পজিশনের ম্যাট্রিক্স এন্ট্রিটি অন্য কোনও কিছুতে সেট করে "0", "1"। যদি S'দৈর্ঘ্য শূন্য হয়, এটি ফিরে আসে True; যেহেতু এটি নিজেকে পুনরাবৃত্তভাবে ডাকে, সাপটি ম্যাট্রিক্সের কোথাও পাওয়া গেল।
যদি S'দৈর্ঘ্য শূন্য-না হয়, তবে এটি চারটি মূল নির্দেশিকাগুলির মধ্য দিয়ে যায়, সেই অবস্থানটি ম্যাট্রিক্সে থাকে কিনা পরীক্ষা করে, সেই অবস্থানের ম্যাট্রিক্সের উপাদানটির প্রথম উপাদানের সাথে তুলনা করে Sএবং - যদি এটি মেলে - নিজেকে পুনরাবৃত্তি বলে calls
Hস্ট্যাকের ফ্রেমগুলি ফেরতের মানগুলি সজ্জিত করে সর্বদা চূড়ান্তভাবে পরীক্ষা করা হয় যে কমপক্ষে কোনও কার্যক্রমে কোনও সম্ভাব্য সাপ পাওয়া গেছে কিনা checking

ফর্ম্যাট করা আউটপুট

আমি আমার প্রোগ্রামটি সাপ স্লিটারগুলির আউটপুট আউটপুট করার জন্য বাড়িয়েছি (যদি থাকে তবে)। এটি প্রশ্নের মতো একই ASCII আউটপুট ডিজাইন ব্যবহার করে। টিআইও লিঙ্ক ।

— জোনাথন ফ্রেচ
সূত্র
— হালওয়ার্ড হুমেল
1
@ হালওয়ার্ডহুমেল ধন্যবাদ; বিশেষত অতিরিক্ত অতিরিক্ত কাটা অপারেশন চিহ্নিত করার জন্য।
— জোনাথন ফ্রেচ
@ user202729 আপনি কি ভাবেন m[:]for~> m*1for? কাজ করতেও পারে.
— জোনাথন ফ্রেচ
@ ব্যবহারকারী202729 ধন্যবাদ, লিঙ্কযুক্ত টিপটি যেমন কাজ করেছে আমি মনে করি এটির একটি গভীর অনুলিপি প্রয়োজন।
— জোনাথন ফ্রেচ
9

জাভাস্ক্রিপ্ট (ES6), 138 134

@ নীল এর থেকে এতটা আলাদা না, তবে এটি আর কী হতে পারে?

ইনপুট: একাধিক লাইন স্ট্রিং হিসাবে ম্যাট্রিক্স, বাইনারি স্ট্রিং, প্রস্থ (নতুন লাইন গণনা করা হচ্ছে না)

নোট: পুনরাবৃত্তি ফাংশনে যুক্তি rকিছুটা বাইট সংরক্ষণ করতে কিছুটা উল্টে যায়

(m,s,w)=>[...m].some((c,p,m,r=(p,o)=>s[m[p]=r,o]&&([~w,-~w,1,-1].every(d=>m[d+=p]!=s[o]||r(d,o+1))&&(m[p]=s[o-1])))=>c==s[0]&&!r(p,1))

কম গল্ফড

(m,s,w)=>(
  m=[...m],
  r= (p, o) => 
    (m[p] = -w, s[o])
    && (
         [~w, -~w, 1, -1].every( d =>
            m[d+=p] != s[o] || r(d, o+1)
         )
         && (m[p]=s[o-1])
    ),
  m.some((c,p) =>c == s[0] && !r(p,1))
)

পরীক্ষা

var F=
(m,s,w)=>[...m].some((c,p,m,r=(p,o)=>s[m[p]=r,o]&&([~w,-~w,1,-1].every(d=>m[d+=p]!=s[o]||r(d,o+1))&&(m[p]=s[o-1])))=>c==s[0]&&!r(p,1))

// this slightly modified version tracks the path
var Mark=
(m,s,w)=>(m=[...m]).some((c,p,m,r=(p,o)=>s[m[p]=-o,o]&&([~w,-~w,1,-1].every(d=>m[d+=p]!=s[o]||r(d,o+1))&&(m[p]=s[o-1])))=>c==s[0]&&!r(p,1))
?m.map((c,p)=>c<-1?'.───│┘└.│┐┌.│'[((m[p-1]-c)**2<2)+((m[p+1]-c)**2<2)*2+((m[p+~w]-c)**2<2)*4+((m[p-~w]-c)**2<2)*8]:c<0?'*':c).join``:''

function go()
{
  O.textContent =F(M.value, S.value, M.value.search('\n'))+'\n\n'
  +Mark(M.value, S.value, M.value.search('\n'))
}

go()
#M {width:100px; height:100px }
<textarea id=M>010101
111011
011010
011011</textarea><br>
<input id=S value='0111111100101' oninput='go()'>
<button onclick='go()'>go</button>
<pre id=O></pre>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
6

জাভাস্ক্রিপ্ট (ES6), 149 বাইট

(m,s,w)=>[...m].some((c,i)=>c==s[0]&&g(m,s,i),g=(m,s,i)=>!(s=s.slice(1))||[~w,-1,1,-~w].some(o=>m[o+=i]==s[0]&&g(m.slice(0,i)+' '+m.slice(i+1),s,o)))

ম্যাট্রিক্সকে একটি নতুন লাইন-বিস্মৃত স্ট্রিং, সাপটিকে একটি স্ট্রিং এবং প্রস্থ হিসাবে (পূর্ণসংখ্যা হিসাবে) গ্রহণ করে। আলগাভাবে @ জোনাথন ফ্রেচের উত্তরের উপর ভিত্তি করে।

— নিল
সূত্র
4

গণিত, 180 156 141 153 138 136 104 বাইট

MemberQ[#|Table[""<>Part[Join@@#,p],{x,1##4},{y,1##4},{p,FindPath[GridGraph@{##4},x,y,#3,All]}],#2,All]&

উদাহরণ ইনপুট

[{{"1","1","1","1","1"},{"0","0","0","0","0"}},"10011001",8,5,2]

ব্যাখ্যা

  1. GridGraph@{##4}একটি হল Graphপ্রান্ত দ্বারা সংযুক্ত সংলগ্ন ছেদচিহ্ন, মাত্রা সঙ্গে ছেদচিহ্ন একটি গ্রিড জন্য বস্তু {##4}যে, - {#4,#5}বা {width,height}।
  2. আমরা বারবার উপর সব শুরু ছেদচিহ্ন x(সংখ্যাযুক্ত 1করতে 1##4 = width*height), সব শেষ ছেদচিহ্ন y, এবং সমস্ত পাথ pসর্বাধিক দৈর্ঘ্য #3থেকে xথেকে y।
  3. এই জাতীয় প্রতিটি পাথের ""<>Part[Join@@#,p]জন্য, ম্যাট্রিক্সের সাথে সম্পর্কিত অক্ষরগুলি বের করে এবং সেগুলিকে একটি স্ট্রিংয়ে রাখে।
  4. আমরা ম্যাট্রিক্স নিজেই অন্তর্ভুক্ত করেছি, যার অক্ষরগুলি এর মধ্যে পাওয়া যায় এমন দৈর্ঘ্যের 1 টি স্ট্রিং।
  5. এই স্ট্রিংগুলির মধ্যে একটি মেলে কিনা তা আমরা দেখতে পাচ্ছি s, সমস্ত স্তরে অনুসন্ধান করা কারণ এটি আমাদের নির্মিত অনেকগুলি বহুমাত্রিক তালিকা।

নোট: প্রতিস্থাপন #3দ্বারা {#3-1}মধ্যে FindPath, যাতে আমরা শুধুমাত্র ঠিক ঠিক দৈর্ঘ্যের পাথ খুঁজে, গতি পরিপ্রেক্ষিতে বিপুল উন্নতি - কিন্তু আরো 4 বাইট খরচ।

-24 বাইট: ইনপুট হিসাবে জিনিস মাত্রা গ্রহণ

-15 বাইট: ব্যবহার StringPartএবং StringJoinসঠিকভাবে

+12 বাইট: দৈর্ঘ্য -1 কেস স্থির করে

-15 বাইট: ...

-২ বাইট: ম্যাট্রিক্সের আকারটি অ্যারের হিসাবে ইনপুট হিসাবে নেওয়া

-32 বাইট: Tableপথ ধরে পুনরাবৃত্তি করতে ব্যবহার করা আমাদের ব্যবহার এড়াতে দেয় Functionএবং MemberQ[...,s,All]1 দৈর্ঘ্যের সাপের সাথে লেনদেন করার সময় টেবিলের উপরে ম্যাট্রিক্সকে কেবল সাজানোর চেষ্টা করি using

— মিশা লাভরভ
সূত্র
3

সি # (.নেট কোর) , 346 341 336 302 297 বাইট

(m,h,w,s,l)=>{for(int y=0;y<h;y++)for(int x=0;x<w;x++)if(N(x,y,l-1))return 0<1;return 1<0;bool N(int x,int y,int p){if(p<0)return 0<1;if(y<0|x<0|y==h|x==w||m[y,x]>1||s[p]!=m[y,x])return 1<0;int g=m[y,x];m[y,x]=2;if(N(x,y-1,--p)||N(x-1,y,p)||N(x,y+1,p)||N(x+1,y,p))return 0<1;m[y,x]=g;return 1<0;}}

এটি অনলাইন চেষ্টা করুন!

pইনক্রিমেন্ট গল্ফ করে 5 বাইট সংরক্ষণ করা হয়েছে

সাপের দৈর্ঘ্য গ্রহণ করে এবং এর লেজটি শুরু করে এবং একটি অপ্রয়োজনীয় স্থান সরিয়ে 5 বাইট সংরক্ষণ করা হয়েছে

চ্যালেঞ্জটি সঠিকভাবে পড়ে এবং আমি ম্যাট্রিক্সের উচ্চতা এবং প্রস্থ নিয়ে যেতে দেখে 34 বাইট সংরক্ষণ করা হয়েছে

5 বাইট সংরক্ষণ করা হয়েছে, একক উপাদান পরীক্ষার কেস ব্যর্থ হয়েছে এবং ঠিক করা উপকারী ছিল

Ungolfed

(m,h,w,s,l)=>{
    // Go through every potential starting point
    for(int y=0; y<h; y++)
        for(int x=0; x<w; x++)
            if(N(x,y,l-1)) // start the recursive steps
                return 0<1; // return true if N returns true, otherwise check the next element

    return 1<0; // return false as the snake doesn't fit into the matrix

    // C#7 local function in a Func
    bool N(int x, int y, int p)
    {
        // if there is no more snake to fit return true
        if(p<0)
            return 0<1;

        // if m element has part of the snake or 
        // snake part doesn't match matrix element then return false
        if(y<0 | x<0 | y==h | x==w || m[y,x]>1 || s[p] != m[y,x])
            return 1<0;

        // hold the current matrix element
        int g=m[y,x];
        // set the current matrix element to 2 to indicate it has a part of the snake
        m[y,x]=2;

        // check each of the four neighbours and recurse down that neighbour 
        // except if they are outside the matrix
        if(N(x,y-1,--p) ||
           N(x-1,y,p) ||
           N(x,y+1,p) ||
           N(x+1,y,p))
               return 0<1; // return true if remainder of the snake fits into the matrix

        // if snake doesn't fit then set the matrix element as not having part of the snake
        m[y,x]=g;
        // return false to indicate this neighbour direction doesn't fit the snake
        return 1<0; 
    }
}
— Ayb4btu
সূত্র
একটি গল্ফিং শুরু
— হ'ল
if(...)return true;-> return ...;।
— জোনাথন ফ্রেচ
@ জোনাথনফ্রেচ সম্মত হয়েছে, তবে আমি এটির মতো ছেড়ে দিয়েছি যাতে অন্যরা যাতে এটির কাছে ফিরে আসার সুযোগ না পায় (কালকের কিছুকাল) আরও সহজেই এটি পড়তে পারে।
— আইয়ব
@ জোনাথানফ্রেচ কাজ করে না, b[y,x]কিছু সময় পুনরায় সেট করা দরকার। (আমার উত্তরে আপনার নামের ভুল বানান করার জন্যও দুঃখিত))
— নীল
মানে if(N(x,y,0)>0)return 0<1;; প্রথম উপস্থিতি return।
— জোনাথন ফ্রেচ
1

কোটলিন , 413 বাইট

var x:(Array<Array<Char>>,String)->Boolean={b,s->fun f(s:String,x:Int,y:Int):Boolean{if(b[x][y]!=s[0])
return 0>1
if(s.length<2)
return 1>0
val v=b[x][y]
b[x][y]='Z'
try{return(-1..1).map{x+it}.flatMap{t->(-1..1).map{y+it}.map{t to it}}.filter{(X,Y)->(x-X)*(x-X)+(y-Y)*(y-Y)==1&&X in b.indices&&Y in b[0].indices&&f(s.substring(1),X,Y)}.any()}finally{b[x][y]=v}}
b.indices.any{x->(0..b[0].size-1).any{f(s,x,it)}}}

শোভিত

var x: (Array<Array<Char>>, String) -> Boolean = { b, s ->
    fun f(s: String, x: Int, y: Int): Boolean {
        if (b[x][y] != s[0])
            return 0 > 1
        if (s.length < 2)
            return 1 > 0
        val v = b[x][y]
        b[x][y] = 'Z'
        try {
            return (-1..1).map{ x + it }
                    .flatMap { t -> (-1..1).map{y+it}.map { t to it } }
                    .filter { (X, Y) ->
                        (x - X)*(x - X) + (y - Y)*(y - Y) == 1 &&
                                X in b.indices && Y in b[0].indices &&
                                f(s.substring(1), X, Y) }
                    .any()
        } finally {
            b[x][y] = v
        }
    }
    b.indices.any { x -> (0..b[0].size - 1).any { f(s, x, it) } }
}

পরীক্ষা

var x:(Array<Array<Char>>,String)->Boolean={b,s->fun f(s:String,x:Int,y:Int):Boolean{if(b[x][y]!=s[0])
return 0>1
if(s.length<2)
return 1>0
val v=b[x][y]
b[x][y]='Z'
try{return(-1..1).map{x+it}.flatMap{t->(-1..1).map{y+it}.map{t to it}}.filter{(X,Y)->(x-X)*(x-X)+(y-Y)*(y-Y)==1&&X in b.indices&&Y in b[0].indices&&f(s.substring(1),X,Y)}.any()}finally{b[x][y]=v}}
b.indices.any{x->(0..b[0].size-1).any{f(s,x,it)}}}

data class Test(val board: String, val snake: String, val output: Boolean)

val tests = listOf(
        Test("""01010
            |10101
            |01010
            |10101
            |01010""", "0101010101010101010101010", true),
        Test("""01110
            |01100
            |10010
            |10110
            |01101""", "011111000110100", true),
        Test("""0""", "0", true),
        Test("""10
            |01""", "1010", true),
        Test("""100
            |010
            |001""", "100010001", true),
        Test("""00000
            |00000
            |00000
            |00000
            |00000""", "1", false),
        Test("""10101
            |01010
            |10101
            |01010
            |10101""", "11", false),
        Test("""100
            |010
            |001""", "111", false),
        Test("""10001
            |01010
            |00100
            |01010
            |10001""", "1000100010001000101010100", false)
)

fun main(args: Array<String>) {
    tests.filter {(board, snake, expected) ->
        val boardR = board.trimMargin().lines().map { it.toCharArray().toTypedArray() }.toTypedArray()
        val result = x(boardR, snake)
        result != expected
    }.forEach { throw AssertionError(it) }
    println("Test Passed")
}
— jrtapsell
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.