কোন মান কোন পথে কোন দিকটি উপস্থাপন করে তা নির্ধারণ করুন

Question

গুরুত্বপূর্ণ সম্পাদনা: আগে উদাহরণ 1 এ একটি ভুল মান ছিল। এটি ঠিক করা হয়েছে।

আপনাকে একটি দ্বি-মাত্রিক অ্যারে দেওয়া হবে যাতে প্রতিটি ঘরে চারটি মানের একটি থাকে।

উদাহরণ:

1 2 2 2 2 1        @ . .        X X V
1 3 1 4 1 4        e . @        I C V
2 3 1 3 4 2        H H @        X I V
1 4 4 2 1 3                     V C C
2 2 2 3 2 3                     X X X

চারটি মান নির্দেশমূলক তীরগুলি (উপরে, নীচে, বাম এবং ডান) উপস্থাপন করে, যদিও আপনি জানেন না কোন মানটি কোন দিকটি উপস্থাপন করে।

দিকনির্দেশক তীরগুলি একটি অবিচ্ছিন্ন পথ তৈরি করে যা অ্যারের প্রতিটি কক্ষকে অন্তর্ভুক্ত করে, যদিও আপনি জানেন না যে শুরু বা শেষ পয়েন্টগুলি কোথায়।

এমন কয়েকটি কোড লিখুন যা নির্ধারণ করে যে চারটি মানগুলির প্রতিটি নির্দেশ করে এবং প্রারম্ভ এবং শেষের পয়েন্টগুলি কোথায়।

অ্যারের জন্য একটি গ্রহণযোগ্য রিটার্ন মান যা A, B, C এবং D এর মান ধারণ করে তা এমন কিছু হবে:

{ up: A, down: C, left: D, right: B, start: [2, 0], end: [4, 2] }

যেহেতু আপনি উভয় পথে (প্রথম থেকে শেষ পর্যন্ত এবং শেষ থেকে শুরু করে) পথটি অতিক্রম করতে পারেন, সর্বদা একাধিক সঠিক সমাধান থাকবে এবং সেখানে দুটিরও বেশি হতে পারে। ধরে নিন যে আপনি প্রাপ্ত উপকরণগুলির (উপরের উদাহরণগুলির মতো) সর্বদা কমপক্ষে একটি সঠিক সমাধান রয়েছে। একাধিক সঠিক সমাধান রয়েছে এমন ক্ষেত্রে, সঠিক সমাধানগুলির মধ্যে একটির কাছে ফিরে পাওয়া যথেষ্ট।

সংক্ষিপ্ততম কোড জিতেছে। আমি কোনও নতুন জমা ছাড়াই 7 দিন বা 24 ঘন্টা পরে বিজয়ীকে বেছে নেব, যেটি প্রথমে আসে।

আমি উপরের উদাহরণগুলির সমাধানগুলি সহ অন্তর্ভুক্ত করছি, তবে আপনি একবার আপনার কোডটি লিখেছেন তবে সেগুলি পরীক্ষা করার জন্য আপনাকে উত্সাহিত করব:

এক:

{আপ: 3, নিচে: 1, বাম: 4, ডান: 2, শুরু: [0,0], শেষ: [2,5]

দুই:

{আপ: '@', ডাউন: 'ই', বাম: '।', ডান: 'এইচ', শুরু: [1,1], সমাপ্তি: [0,0]}

তিন:

{আপ: 'আমি', নীচে: 'ভি', বাম: 'সি', ডান: 'এক্স', শুরু: [0,2], শেষ: [4,2]}

Comments

"আপনি উভয় পথেই পথটি অতিক্রম করতে পারেন" - দিকনির্দেশগুলি যদি নিখুঁত হয় তবে আপেক্ষিক না হয়, এটি সত্য নয়। দিকনির্দেশগুলি কি নিরঙ্কুশ, নাকি আপেক্ষিক? এছাড়াও, শুরু এবং শেষ অ্যারের বাইরে থাকা হিসাবে পরিচিত?

— জন ডিভোরাক

@ জনডভোরাক শুরু এবং শেষের পয়েন্টগুলি অ্যারের মধ্যে থাকা ঘরগুলি। দিকনির্দেশ হিসাবে, ধরুন তারা সর্বদা একটি সংলগ্ন ঘরে (উত্তর, দক্ষিণ, পূর্ব বা পশ্চিম) গতিবেগ নির্দেশ করে indicate

— jawns317

কোন ক্ষেত্রে পিছনের দিকে কোনও পথ অতিক্রম করা সম্ভব নয়। আমি কোনও গ্যারান্টি দেখতে পাচ্ছি না সবসময় একাধিক সমাধান থাকবে।

— জন ডিভোরাক

যদি আমরা "ধরে নিই যে তারা সর্বদা একটি সংলগ্ন কোষে চলাচল নির্দেশ করে", তবে আপনার দ্বিতীয় উদাহরণটি এখনও কার্যকর? আমি কিছু মিস করছি তবে মনে হচ্ছে @ "সীমার বাইরে" না গিয়ে চার দিকের কোনওটিই হতে পারে না।

— নিক সরবেন

উদাহরণ 1 এর কোনও সমাধান নেই।

— ডেভিডসি

Answer 1

সি শার্প

সম্পাদনা: একটি বিভাগ এবং ফর্ম্যাটিং স্থির করে। এবং হেল্পার ক্লাস যুক্ত করেছে।

এটি হ'ল গল্ফ কোড, 807 টি অক্ষর

class M{public int c,x,y,u;}
void G(string[] z){
M K;int[]x={0,0,-1,1},y={-1,1,0,0},I={0,0,0,0};
string[]T={"Up","Down","Left","Right"};
int X,Y,R,n=0,H=z.Length,W=z[0].Length;W-=W/2;var D= string.Join(" ", z).Where(c=>c!=' ').Select(c=>new M(){c=c,x=n%W,y=n++/W}).ToList();n=0;var S=D.GroupBy(k=>k.c).ToDictionary(k=>k.Key,k =>n++);
for(;I[0]<4;I[0]++)for(I[1]=0;I[1]<4;I[1]++)for(I[2]=0;I[2]<4;I[2]++)for(I[3]=0;I[3]<4;I[3]++){
if ((1<<I[0]|1<<I[1]|1<<I[2]|1<<I[3])!=15)continue;
foreach (var Q in D){D.ForEach(p=>p.u=-1);R=1;K=Q;j:if((X=K.x+x[n=I[S[K.c]]])>=0&&X<W&&(Y=K.y+y[n])>=0&&Y<H&&(K=D[X+Y*W]).u<0){
K.u=1;if(++R==D.Count){Console.WriteLine("{4} Start({0}:{1}) End({2}:{3})",Q.x,Q.y,K.x,K.y,string.Join(", ",S.Select(k=>string.Format("{1}: '{0}'",(char)k.Key,T[I[k.Value]])).ToArray()));return;}goto j;}}}
}    

তিনটি পরীক্ষার ক্ষেত্রে ফলাফল:

ডাউন: '1', ডান: '2', উপরে: '3', বাম: '4' শুরু (0: 0) শেষ (5: 2)
উপরে: '@', বাম: '।', ডাউন: ' e ', ডান:' এইচ 'শুরু (1: 1) সমাপ্তি (0: 0)
ডান:' এক্স ', ডাউন:' ভি ', উপরে:' আমি ', বাম:' সি 'শুরু (0: 2) শেষ (2: 4)

এটি "গল্ফ" ছাড়াই কাঁচা কোড, প্রায় 4,000 অক্ষর:

class Program
{
    static string[] input1 =  { "1 2 2 2 2 1",
               "1 3 4 4 1 4",       
               "2 3 1 3 4 2",
               "1 4 4 2 1 3",       
               "2 2 2 3 2 3"};

    static string[] input2 =  { "@ . .",
                                "e . @",       
                                "H H @",
               };

    static string[] input3 =  { "0 0 1",
                                "0 0 1",       
                                "3 2 2",
               };

    static void Main(string[] args)
    {
        Resolve(input1);
        Resolve(input2);
        Resolve(input3);
        Console.ReadLine();
    }


    class N { public int c; public int x, y, i, u; }

    static void Resolve(string[] input)
    {
        int[] ox = { -1, 1, 0, 0 }, oy = { 0, 0, -1, 1 }, I = { 0, 0, 0, 0 };
        string[] TXT = { "Left", "Right", "Up", "Down" };
        int X, Y, R, n = 0, H = input.Length, W = input[0].Length;
        W -= W / 2;
        N K = null;
        var data = string.Join(" ", input).Where(c => c != ' ').Select(c => new N() { c = c, x = (n % W), y = (n / W), i = n++, u = -1 }).ToList();
        n = 0;
       var S = data.GroupBy(k => k.c).ToDictionary(k => k.Key, k => n++);

        for (; I[0] < 4; I[0]++)
            for (I[1] = 0; I[1] < 4; I[1]++)
                for (I[2] = 0; I[2] < 4; I[2]++)
                    for (I[3] = 0; I[3] < 4; I[3]++)
                    {
                        if (((1 << I[0]) | (1 << I[1]) | (1 << I[2]) | (1 << I[3])) != 15) continue;
                        foreach(var Q in data)
                        {
                            data.ForEach(p => p.u = -1);
                            R = 0;
                            K = Q;
                            while (K != null)
                            {
                                n = I[S[K.c]];
                                X = K.x + ox[n];
                                Y = K.y + oy[n];
                                if (X >= 0 && X < W && Y >= 0 && Y < H)
                                {
                                    n = X + Y * W;
                                    if (data[n].u < 0)
                                    {
                                         data[n].u = K.i;
                                         K = data[n];
                                        R++;
                                        if (R == data.Count - 1)
                                        {
                                            Console.WriteLine();
                                            Console.WriteLine("Start({0}:{1}) End({2}:{3})", Q.x, Q.y, K.x, K.y);
                                            Console.WriteLine(string.Join(", ", S.Select(k => string.Format("'{0}': {1}", (char)k.Key, TXT[I[k.Value]])).ToArray()));
                                            Action<N> Write = null;
                                            Write = (k) =>
                                             {
                                                 if (k.u != -1)
                                                 {
                                                     Write(data[k.u]);
                                                 }
                                                 Console.Write(string.Format("({0}:{1}){2}", k.x, k.y, k == K ? "\n" : " => "));
                                             };

                                            Write(K);
                                            return;
                                        }
                                        continue;
                                    }
                                }
                                K = null;
                            }
                        }
                    }
        Console.WriteLine("Solution not found");
    }
 }
}

এই তিনটি উদাহরণের ফলাফল:

সমাধান পাওয়া যায় নি

শুরু (1: 1) শেষ (0: 0) '@': উপরে, '।': বাম, 'ই': ডাউন, 'এইচ': ডান

(1: 1) => (0: 1) => (0: 2) => (1: 2) => (2: 2) => (2: 1) => (2: 0) => ( 1: 0) => (0: 0)

শুরু (0: 0) শেষ (1: 1) '0': ডান, '1': ডাউন, '3': উপরে, '2': বাম

(0: 0) => (1: 0) => (2: 0) => (2: 1) => (2: 2) => (1: 2) => (0: 2) => ( 0: 1) => (1: 1)

Comments

আপনি আপনার কোডটি গল্ফ করতে চাইতে পারেন, কারণ এটি একটি কোড-গল্ফ প্রতিযোগিতা।

— টিমটেক

আমি এটি করছি :)

— ব্লু

ঠিক আছে, কোনও তাড়াহুড়ো নয় :) এটি ঠিক যে কিছু লোক গল্ফড কোড ছাড়াই একটি নতুন ব্যবহারকারী দেখেন এবং ডাউনওয়েট হন down

— টিমটেক

এটি আমার প্রথমবারের মতো ... তবে আমি পরামর্শ দিচ্ছি যে এটি এখনও গল্ফ হয় নি ... যদিও আমি মনে করি যে আমি মেটেমাথিকার কোডটি পরাজিত করব না ... :)

— ব্লু

এই প্রশ্নের যে কোনও উত্তরের দক্ষতা প্রয়োজন। +1

— টিমটেক

Answer 2

গণিত 278

"স্পষ্টতা" জন্য স্পেস যুক্ত করা হয়েছে

k@l_ := (s = #~Join~-# &@{{1, 0}, {0, 1}};
         f@r_ := Flatten[MapIndexed[#2 -> #2 + (#1 /. r) &, l, {2}], 1];
         g     = Subgraph[#, t = Tuples@Range@Dimensions@l] & /@ 
                       Graph /@ f /@ (r = Thread[# -> s] & /@ Permutations[Union @@ l]);
        {t[[#]] & /@ Ordering[Tr /@ IncidenceMatrix@g[[#]]][[{1, -1}]], r[[#]]} & @@@ 
                                                                 Position[PathGraphQ /@ g, True])

সেশন এবং আউটপুট:

 l = l1 = {{1, 2, 2, 2, 2, 1}, {1, 3, 1, 4, 1, 4}, {2, 3, 1, 3, 4, 2}, 
            {1, 4, 4, 2, 1, 3}, {2, 2, 2, 3, 2, 3}}; ;
 k@l1
 {{{{1, 1}, {3, 6}}, 
    {1 -> {1, 0}, 2 -> {0, 1}, 3 -> {-1, 0},  4 -> {0, -1}}}}

প্রারম্ভটি ভার্টেক্স, শেষ প্রান্তি এবং প্রতিটি চিহ্নের সাথে সম্পর্কিত ট্রানজিশন নিয়ম কোনটি।

ওরিয়েন্টেড গ্রাফটি দেখানোর জন্য এখানে পরিপূরক কোডটি রয়েছে:

sol = sg[[Position[PathGraphQ /@ sg, True][[1, 1]]]];
Framed@Graph[
  VertexList@sol,
  EdgeList@sol,
  VertexCoordinates -> VertexList@sol /. {x_, y_} :> {y, -x},
  VertexLabels -> MapThread[Rule, {VertexList@sol, Flatten@l}], 
  EdgeShapeFunction -> GraphElementData["FilledArcArrow", "ArrowSize" -> 0.03],
  ImagePadding -> 20]

Answer 3

গণিত (151)

L = {{1, 2, 2, 2, 2, 1}, {1, 3, 1, 4, 1, 4}, {2, 3, 1, 3, 4, 2}, 
   {1, 4, 4, 2, 1, 3}, {2, 2, 2, 3, 2, 3}};

PathGraphQ@#~If~Print@{TopologicalSort[#]〚{1,-2}〛,r}&@
Graph@Flatten@MapIndexed[#2->#2+(#/.r)&,L,{2}]~Do~{r,
Thread[Union@@L->#]&/@{-1,0,1}~Tuples~{4,2}}

এটি সূচনা পয়েন্ট, শেষ পয়েন্ট এবং ট্রানজিশনের নিয়মগুলি ফেরত দেয়। প্রথম সূচকটি সারি, দ্বিতীয়টি কলাম

{{{1,1},{3,6}},{1->{1,0},2->{0,1},3->{-1,0},4->{0,-1}}}

মনে রাখবেন যে আমার কোডটি এর সাথেও কাজ করে {-1,0,1}~Tuples~{4,2}। গতি বাড়ানোর জন্য আপনি Permutations@{{1, 0}, {0, 1}, {-1, 0}, {0, -1}}পরিবর্তে ব্যবহার করতে পারেন ।

Answer 4

এপিএল (207)

আমি এটিকে ম্যাথমেটিকার চেয়ে ছোট করতে পারি না, কারণ টপোলজিক্যালসোর্ট এবং এর মতো শর্তে আমি যুক্তি করতে পারি না। আরও স্মার্ট লোকেরা এটি আরও চেপে ধরে স্বাগত জানায়।

Golfed:

{u←∪,t←⍵⋄q r←↑(0≠+/¨r)/⊂[2]p,⍪r←{m←,⍵[u⍳t]⋄v r←⊂[1]⊃{{(↑⍴∪⍵),⊂(↑⍵)(↑⌽⍵)}n↑{3::⍬⋄i←↑⌽⍵⋄⍵,i+i⌷m}⍣n,⍵}¨⍳n←↑⍴,t⋄↑(v=n)/r}¨p←⊂[2]{1≥⍴⍵:⊃,↓⍵⋄⊃⍪/⍵,∘∇¨⍵∘~¨⍵}d←¯1 1,¯1 1×c←¯1↑⍴t⋄⊃('←→↑↓',¨u[q⍳d]),{1+(⌊⍵÷c)(c|⍵)}¨r-1}

Ungolfed:

D←{⎕ML ⎕IO←3 1
    pmat←{1≥⍴⍵:⊃,↓⍵⋄⊃⍪/⍵,∘∇¨⍵∘~¨⍵}   ⍝ utility: permutations of the given vector
    u←∪,t←⍵                    ⍝ the 4 unique symbols in t←⍵
    n←↑⍴,t                     ⍝ number of elements in t
    d←¯1 1,¯1 1×c←¯1↑⍴t        ⍝ the four ∆i (+1, -1, +cols, -cols)
    p←⊂[2]pmat d               ⍝ list of permutations of the four ∆i
    r←{                        ⍝ for each permutation ⍵∊p (=interpretation of the 4 symbols)
        m←,⍵[u⍳t]              ⍝ (ravelled) t-shaped matrix of ∆i, using interpretation ⍵
        v r←⊂[1]⊃{             ⍝ for each starting index ⍵∊⍳n
            v←n↑{              ⍝ trail of visited cells after n steps 
                3::⍬           ⍝ if index out of bounds return empty list
                i←↑⌽⍵          ⍝ take last visited index
                ⍵,i+i⌷m        ⍝ follow the directions and add it to the list
            }⍣n,⍵
            (↑⍴∪v),⊂(↑v),↑⌽v   ⍝ number of unique cells, plus start/end indices
        }¨⍳n
        ↑(v=n)/r               ⍝ 1st couple of start/end indices to visit all cells (if any)
    }¨p
    q r←↑(0≠+/¨r)/⊂[2]p,⍪r     ⍝ select first perm. and start/end indices to visit all cells
    ⊃('←→↑↓',¨u[q⍳d]),{1+(⌊⍵÷c)(c|⍵)}¨r-1   ⍝ return char mapping and start/end indices
}

উদাহরণ:

(সূচকগুলি 1 এ শুরু হবে)

     D⊃'122221' '131414' '231342' '144213' '222323'
 ←  4 
 →  2 
 ↑  3 
 ↓  1 
 1  1 
 3  6 
     D⊃'@..' 'e.@' 'HH@'
 ←  . 
 →  H 
 ↑  @ 
 ↓  e 
 2  2 
 1  1 
     D⊃'XXV' 'ICV' 'XIV' 'VCC' 'XXX'
 ←  C 
 →  X 
 ↑  I 
 ↓  V 
 3  1 
 5  3