16

আপনার লক্ষ্য একটি প্রোগ্রাম যা একটি র্যান্ডম 10x10 মানচিত্র তৈরি করে ব্যবহার লিখতে হয় 0, 1এবং 2, এবং থেকে শীর্ষ-বাম নীচে ডানদিকে, অভিমানী যে সবচেয়ে কম পথ খুঁজে বের করে:

0 একটি ঘাসের ক্ষেত্রের প্রতিনিধিত্ব করে: যে কেউ এটির উপর দিয়ে চলতে পারে;
1 একটি প্রাচীরের প্রতিনিধিত্ব করে: আপনি এটি অতিক্রম করতে পারবেন না;
2 একটি পোর্টাল প্রতিনিধিত্ব করে: একটি পোর্টাল প্রবেশ করার সময়, আপনি মানচিত্রের অন্য কোনও পোর্টালে যেতে পারেন।

চশমা:

উপরের-বাম উপাদান এবং নীচে-ডান এক হতে হবে 0 ;
এলোমেলো মানচিত্র তৈরি করার সময়, প্রতিটি ক্ষেত্রের 0 হওয়ার সম্ভাবনা 60% হওয়া উচিত , 1 হওয়ার 30% এবং 2 হবার 10% হওয়া উচিত ;
আপনি যে কোনও সংলগ্ন ক্ষেত্রে (এমনকি ডায়াগোনালগুলিও) যেতে পারেন;
আপনার প্রোগ্রামটির মানচিত্র এবং সবচেয়ে দীর্ঘতম ধাপগুলির সংখ্যা নির্ধারণ করা উচিত;
নীচে-ডান ক্ষেত্রের দিকে পরিচালিত কোনও বৈধ পথ না থাকলে, আপনার প্রোগ্রামটি কেবল মানচিত্রটি আউটপুট করে;
আপনি চাইলে যে কোনও সংস্থান ব্যবহার করতে পারেন;
সংক্ষিপ্ততম কোড জিতেছে।

পদক্ষেপের গণনা:
একটি পদক্ষেপ একটি আসল চলাচল; প্রতিবার আপনি ক্ষেত্র পরিবর্তন করুন, আপনি পাল্টা বৃদ্ধি।

আউটপুট:

code-golf path-finding maze

— Vereos
সূত্র

আমরা কি সংক্ষিপ্ততম পথের জন্য প্রোগ্রামটি তৈরি করতে পারি না? জেনারেট করা আরেকটি প্রশ্ন।

— মিকায়েল মায়ার

আপনি উল্লেখ করেননি যে প্রতিটি সময় এলোমেলো মানচিত্র অবশ্যই আলাদা হতে হবে :)

— মেরিনাস

@ মারিনাস লুওল! হ্যাঁ, চশমাগুলিতে আমি উত্পাদক সম্ভাবনাগুলি লিখেছিলাম, সুতরাং আমি অনুমান করি যে 60 0, 30 1 এবং 10 2 দিয়ে একটি মানচিত্র লেখা কোনও সঠিক সমাধান হবে না: পি

— ভেরিয়াস

@ মিকায়েলমায়ার আমি অনুমান করি আপনি একটি পয়েন্ট পেয়েছেন তবে আমি মনে করি এটি এর চেয়ে চ্যালেঞ্জিং হবে। আমি কি ভূল?

— ভেরিওস

এটি একটি কোড-গল্ফ প্রশ্ন হিসাবে, জয়ের মানদণ্ডটি সবচেয়ে সংক্ষিপ্ত কোড। যদি সেই কোডটি সত্যই ধীর হয় এবং সেঞ্চুরিটি চালাতে লাগে তবে কী হবে?

— ভিক্টর স্টাফুসা

3

গল্ফস্ক্রিপ্ট, 182 টি অক্ষর

;0`{41 3 10rand?/3%`}98*0`]10/n*n+.[12n*.]*.0{[`/(,\+{,)1$+}*;]}:K~\2K:P+${[.12=(]}%.,,{.{\1==}+2$\,{~;.P?0<!P*3,{10+}%1+{2$1$-\3$+}%+~}%`{2$~0<@@?-1>&2$[~;@)](\@if}++%}/-1=1=.0<{;}*

উদাহরণ:

— হাওয়ার্ড
সূত্র

4

গণিত (344)

বোনাস: পথটি হাইলাইট করা

n = 10;
m = RandomChoice[{6, 3, 1} -> {0, 1, 2}, {n, n}];
m[[1, 1]] = m[[n, n]] = 0;

p = FindShortestPath[Graph@DeleteDuplicates@Join[Cases[#, Rule[{ij__}, {k_, l_}] /; 
      0 < k <= n && 0 < l <= n && m[[ij]] != 1 && m[[k, l]] != 1] &@
   Flatten@Table[{i, j} -> {i, j} + d, {i, n}, {j, n}, {d, Tuples[{-1, 0, 1}, 2]}], 
  Rule @@@ Tuples[Position[m, 2], 2]], {1, 1}, {n, n}];

Grid@MapAt[Style[#, Red] &, m, p]
If[# > 0, #-1] &@Length[p]

এখানে চিত্র বর্ণনা লিখুন

আমি প্রতিবেশী শিখুনে সমস্ত সম্ভাব্য চলচ্চিত্রের গ্রাফ তৈরি করেছি এবং সম্ভাব্য সমস্ত "টেলিপোর্ট" যুক্ত করছি।

— ybeltukov
সূত্র

3

গণিত, 208 202 চর cha

ডেভিড ক্যারাহার এবং ইবেলটুকভের সমাধানগুলির ভিত্তিতে। এবং ইবেলটুকভের পরামর্শের জন্য ধন্যবাদ।

m=RandomChoice[{6,3,1}->{0,1,2},n={10,10}];m〚1,1〛=m〚10,10〛=0;Grid@m
{s,u}=m~Position~#&/@{0,2};If[#<∞,#]&@GraphDistance[Graph[{n/n,n},#<->#2&@@@Select[Subsets[s⋃u,{2}],Norm[#-#2]&@@#<2||#⋃u==u&]],n/n,n]

— alephalpha
সূত্র

চমৎকার, +1! আরও অপ্টিমাইজেশন: এর n/nপরিবর্তে n/10:)

— ybeltukov

ভাল স্ট্রিমলাইনিং। এবং আপনি এখনই মানচিত্রটি মুদ্রণ করুন।

— ডেভিডসি

এবং 〚〛বন্ধনীগুলির জন্য (এটি সঠিক ইউনিকোড প্রতীক)

— ybeltukov

আপনি কি নির্বাচনের মানদণ্ডটি ব্যাখ্যা করতে পারেনNorm[# - #2] & @@ # < 2 || # \[Union] u == u &

— ডেভিডসি

@ ডেভিডকারেরার Norm[# - #2] & @@ # < 2অর্থ দুটি পয়েন্টের মধ্যে দূরত্ব 2 এর চেয়ে কম, সুতরাং সেগুলি অবশ্যই সংলগ্ন হতে হবে। # ⋃ u == uউভয় পয়েন্ট আপনার হয় মানে।

— আলেফাল্ফ

2

পাইথন 3, 279

কিছু Dijkstra বৈকল্পিক। কুরুচিপূর্ণ, তবে আমি যতটা পারি গল্ফ করেছিলাম ...

from random import*
R=range(10)
A={(i,j):choice([0,0,1]*3+[2])for i in R for j in R}
A[0,0]=A[9,9]=0
for y in R:print(*(A[x,y]for x in R))
S=[(0,0,0,0)]
for x,y,a,c in S:A[x,y]=1;x*y-81or print(c)+exit();S+=[(X,Y,b,c+1)for(X,Y),b in A.items()if a+b>3or~-b and-2<X-x<2and-2<Y-y<2]

নমুনা রান

0 1 1 1 0 0 1 0 1 0
0 0 0 1 0 1 0 1 0 0
0 1 2 1 2 1 0 0 1 0
0 1 0 1 0 0 0 0 0 1
0 1 0 1 0 0 1 0 0 1
0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 1 0 1
1 0 0 1 0 0 1 1 1 0
0 0 0 0 1 0 0 0 0 1
0 1 2 1 0 1 1 0 0 0
10

— মনিকা পুনরায় স্থাপন করুন
সূত্র

1

গণিত 316 279 275

বেসিক অবজেক্টটি 10x10 অ্যারে যা প্রায় 60 0, 30 1 এবং 10 2 এর হয়। অ্যারেটি 10x10 সংশোধন করতে ব্যবহৃত হয় GridGraph, সমস্ত প্রান্ত সংযুক্ত করে। অ্যারেতে থাকা 1 টি কক্ষের সাথে মিলিত সেই নোডগুলি গ্রাফ থেকে সরানো হবে। এই নোডগুলি "হোল্ডিং 2 এর" সমস্ত একে অপরের সাথে সংযুক্ত। তারপরে সংক্ষিপ্তপথটি 1 টি এবং ভার্টেক্স 100 এর মধ্যবর্তী স্থানে অনুসন্ধান করা হয়েছে; যদি এই জাতীয় পথটি না থাকে তবে মানচিত্রটি ফিরে আসবে; যদি এই জাতীয় কোনও পথ উপস্থিত থাকে তবে মানচিত্র এবং সংক্ষিপ্ততম পথের দৈর্ঘ্য প্রদর্শিত হবে।

m = Join[{0}, RandomChoice[{6, 3, 1} -> {0, 1, 2}, 98], {0}];
{s,t,u}=(Flatten@Position[m,#]&/@{0,1,2});
g=Graph@Union[EdgeList[VertexDelete[GridGraph@{10,10},t]],Subsets[u,{2}] 
/.{a_,b_}:>a \[UndirectedEdge] b];
If[IntegerQ@GraphDistance[g,1,100],{w=Grid@Partition[m,10],  
Length@FindShortestPath[g,1,100]-1},w]

নমুনা রান :

চিত্রলেখ

— DavidC
সূত্র

1

"আপনি যে কোনও সংলগ্ন ক্ষেত্রে (এমনকি তির্যকগুলি) স্থানান্তর করতে পারেন"।

— আলেফাল্ফ

0

পাইথন (1923)

ব্যাকট্র্যাকিং অনুসন্ধান

স্বীকারোক্তিটি স্বল্পতম বা সবচেয়ে দক্ষ নয়, যদিও এখানে কিছু স্মৃতিচারণ রয়েছে।

import random
l = 10
map = [
    [(lambda i: 0 if i < 7 else 1 if i < 10 else 2)(random.randint(1, 10))
     for i in range(0, l)]
    for i in range(0, l)
    ]
map[0][0] = map[l-1][l-1] = 0
print "\n".join([" ".join([str(i) for i in x]) for x in map])

paths = {}
def step(past_path, x, y):
    shortest = float("inf")
    shortest_path = []

    current_path = past_path + [(x, y)]
    pos = map[x][y]
    if (x, y) != (0, 0):
        past_pos = map[past_path[-1][0]][past_path[-1][1]]

    if (((x, y) in paths or str(current_path) in paths)
        and (pos != 2 or past_pos == 2)):
        return paths[(x, y)]
    elif x == l-1 and y == l-1:
        return ([(x, y)], 1)

    if pos == 1:
        return (shortest_path, shortest)
    if pos == 2 and past_pos != 2:
        for i2 in range(0, l):
            for j2 in range(0, l):
                pos2 = map[i2][j2]
                if pos2 == 2 and (i2, j2) not in current_path:
                    path, dist = step(current_path, i2, j2)
                    if dist < shortest and (x, y) not in path:
                        shortest = dist
                        shortest_path = path
    else:
        for i in range(x - 1, x + 2):
            for j in range(y - 1, y + 2):
                if i in range(0, l) and j in range(0, l):
                    pos = map[i][j]
                    if pos in [0, 2] and (i, j) not in current_path:
                        path, dist = step(current_path, i, j)
                        if dist < shortest and (x, y) not in path:
                            shortest = dist
                            shortest_path = path
    dist = 1 + shortest
    path = [(x, y)] + shortest_path
    if dist != float("inf"):
        paths[(x, y)] = (path, dist)
    else:
        paths[str(current_path)] = (path, dist)
    return (path, dist)

p, d = step([], 0, 0)
if d != float("inf"):
    print p, d

— বিনোদ
সূত্র

1

বাহ, এখন এটি একটি কোড গল্ফের জন্য একটি চরিত্র গণনা! আমার মনে হয় আপনার বলটি রুক্ষ হয়ে উঠেছে।

— টিম সেগুইন

হাহ হ্যাঁ আমি কোডটি গল্ফ করা বা সংক্ষিপ্ত বাস্তবায়ন সন্ধান করার চেষ্টা করলাম না, তবে চরিত্রটি গণনা করলাম যাতে লোকেরা জানতে পারে যে তারা এই সমাধানটিকে উপেক্ষা করতে পারে। দেখে মনে হচ্ছিল মজাদার সমস্যা like

— বিনোদ

0

জাভাস্ক্রিপ্ট (541)

z=10
l=[[0]]
p=[]
f=[[0]]
P=[]
for(i=0;++i<z;)l[i]=[],f[i]=[]
for(i=0;++i<99;)P[i]=0,l[i/z|0][i%z]=99,f[i/z|0][i%z]=(m=Math.random(),m<=.6?0:m<=.9?1:(p.push(i),2))
f[9][9]=0
l[9][9]=99
Q=[0]
for(o=Math.min;Q.length;){if(!P[s=Q.splice(0,1)[0]]){P[s]=1
for(i=-2;++i<2;)for(j=-2;++j<2;){a=i+s/z|0,b=j+s%z
if(!(a<0||a>9||b<0||b>9)){q=l[a][b]=o(l[s/z|0][s%z]+1,l[a][b])
if(f[a][b]>1){Q=Q.concat(p)
for(m=0;t=p[m];m++)l[t/z|0][t%z]=o(l[t/z|0][t%z],q+1)}!f[a][b]?Q.push(a*z+b):''}}}}for(i=0;i<z;)console.log(f[i++])
console.log((k=l[9][9])>98?"":k)

গ্রাফ জেনারেশন প্রথম পাঁচ লাইনে ঘটে। fক্ষেত্রগুলি pধারণ করে, পোর্টালগুলি ধারণ করে। আসল অনুসন্ধানটি বিএফএসের মাধ্যমে প্রয়োগ করা হয়েছে।

উদাহরণ আউটপুট:

> নোড maze.js
[0, 0, 0, 0, 1, 0, 0, 0, 2, 0]
[0, 1, 1, 0, 0, 1, 0, 0, 0, 2]
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0]
[1, 1, 1, 0, 2, 2, 0, 1, 0, 1]
[1, 1, 0, 0, 0, 0, 1, 0, 0, 0]
[1, 1, 0, 0, 1, 0, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 1, 0, 0, 2, 0]
[0, 0, 1, 0, 1, 2, 0, 1, 0, 1]
[1, 0, 0, 0, 1, 1, 1, 0, 1, 1]
[0, 1, 0, 0, 0, 0, 0, 0, 1, 0]

> নোড maze.js
[0, 0, 0, 0, 1, 0, 1, 0, 0, 1]
[0, 2, 0, 1, 1, 2, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 1, 2, 1, 1, 0, 1, 0]
[2, 0, 1, 0, 2, 2, 2, 0, 1, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 1, 0, 0]
[0, 1, 2, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 2, 1, 0, 1, 2, 0, 0, 1]
[0, 1, 2, 0, 0, 0, 0, 0, 0, 0]
5

— ZETA
সূত্র

0

পাইথন 3 (695)

import random as r
if __name__=='__main__':
    x=144
    g,t=[1]*x,[]
    p=lambda i:12<i<131 and 0<i%12<11
    for i in range(x):
        if p(i):
            v=r.random()
            g[i]=int((v<=0.6 or i in (13,130)) and .1 or v<=0.9 and 1 or 2)
            if g[i]>1:t+=[i]
            print(g[i],end='\n' if i%12==10 else '')
    d=[99]*x
    d[13]=0
    n = list(range(x))
    m = lambda i:[i-1,i+1,i-12,i+12,i-13,i+11,i+11,i+13]
    while n:
        v = min(n,key=lambda x:d[x])
        n.remove(v)
        for s in m(v)+(t if g[v]==2 else []):
            if p(s) and g[s]!=1 and d[v]+(g[s]+g[v]<4)<d[s]:
                d[s]=d[v]+(g[s]+g[v]<3)
    if d[130]<99:print('\n'+str(d[130]))

ডিজকস্ট্রা!

উদাহরণ আউটপুট:

— muede
সূত্র

0

পাইথন, 314

import random,itertools as t
r=range(10)
a,d=[[random.choice([0]*6+[1]*3+[2])for i in r]for j in r],eval(`[[99]*10]*10`)
a[0][0]=a[9][9]=d[0][0]=0
for q,i,j,m,n in t.product(r*10,r,r,r,r):
 if a[m][n]!=1and abs(m-i)<2and abs(n-j)<2or a[i][j]==a[m][n]==2:d[m][n]=min(d[i][j]+1,d[m][n])
w=d[9][9]
print a,`w`*(w!=99)

এটি বেলম্যান-ফোর্ডের একটি জঘন্য বাস্তবায়ন। এই অ্যালগরিদম হ'ল হে (এন ^ 6)! (যা এন = 10 এর জন্য ঠিক আছে)

— সঞ্জীব মুর্তি
সূত্র

মানচিত্রটি দেখতে খুব কুরুচিপূর্ণ দেখাচ্ছে। 10 টিরও বেশি পদক্ষেপের প্রয়োজন হলে এটি কাজ করে?

— মনিকা

@WolframH অবশ্যই: en.wikipedia.org/wiki/...

— সঞ্জীব Murty

আমি এটা করতে পারে print '\n'.join(map(str,a)); আমি print aগল্ফের জন্য করেছি

— সঞ্জীব মুর্তি

আমি অ্যালগরিদমের সঠিকতা :-) সন্দেহ করি নি। আমি ঠিক বুঝতে পারি নি যে আপনি প্রায়শই যথেষ্ট লুপ হন (যা আপনি করেন; r*10100 টি উপাদান রয়েছে)।

— মনিকা

হ্যাঁ। আসলে 100 ওভারকিল হয়; 99 প্রয়োজন হয়।

— সঞ্জীব মুর্তি

পোর্টাল গোলকধাঁধার সবচেয়ে ছোট পথ

গল্ফস্ক্রিপ্ট, 182 টি অক্ষর

গণিত (344)

গণিত, 208 202 চর cha

পাইথন 3, 279

গণিত 316 279 275

পাইথন (1923)

জাভাস্ক্রিপ্ট (541)

উদাহরণ আউটপুট:

পাইথন 3 (695)

উদাহরণ আউটপুট:

পাইথন, 314