पोर्टल भूलभुलैया सबसे छोटा रास्ता

Question

अपने लक्ष्य एक प्रोग्राम है जो एक यादृच्छिक 10x10 मानचित्र बनाता का उपयोग कर लिखने के लिए है 0, 1और 2, और से ऊपर-बाईं ओर निचले-दाएं कोने, यह सोचते हैं कि कम से कम पथ पाता है:

0 एक घास के मैदान का प्रतिनिधित्व करता है: कोई भी उस पर चल सकता है;
1 एक दीवार का प्रतिनिधित्व करता है: आप इसे पार नहीं कर सकते;
2 एक पोर्टल का प्रतिनिधित्व करता है: एक पोर्टल में प्रवेश करते समय, आप नक्शे में किसी अन्य पोर्टल पर जा सकते हैं।

ऐनक:

• ऊपरी बाएं भाग तत्व और निचले दाएं से एक होना चाहिए 0 ;
• जब यादृच्छिक नक्शा बनाने, हर क्षेत्र एक होने का 60% अवसर होता है 0 , 30 एक होने का% 1 एक होने का और 10% 2 ;
• आप किसी भी निकटवर्ती क्षेत्र (यहां तक ​​कि विकर्ण वाले) में जा सकते हैं;
• आपके कार्यक्रम को नक्शे और सबसे छोटे पथ के चरणों की संख्या का उत्पादन करना चाहिए;
• यदि कोई मान्य पथ नहीं है जो नीचे-दाएं फ़ील्ड की ओर जाता है, तो आपके प्रोग्राम को केवल नक्शे का उत्पादन करना चाहिए;
• आप अपने इच्छित किसी भी संसाधन का उपयोग कर सकते हैं;
• सबसे छोटा कोड जीतता है।

चरणों की गणना:
एक कदम एक वास्तविक आंदोलन है; हर बार जब आप फ़ील्ड बदलते हैं, तो आप काउंटर को बढ़ाते हैं।

आउटपुट:

0000100200
0100100010
1000000111
0002001000
1111100020
0001111111
0001001000
0020001111
1100110000
0000020100

9

Comments

क्या हम केवल सबसे छोटे मार्ग के लिए कार्यक्रम नहीं बना सकते? सृजन एक और सवाल है।

— मिकैल मेयर

आपने निर्दिष्ट नहीं किया कि यादृच्छिक नक्शा हर बार अलग होना चाहिए :)

— marinus

@marinus LoooL! खैर, ऐनक में मैंने जनरेटिंग चांस लिखे हैं, इसलिए मुझे लगता है कि 60 0, 30 1 और 10 2 के साथ एक मानक मानचित्र लिखना एक सही समाधान नहीं होगा: P

— Vereos

@ MikaëlMayer मुझे लगता है कि आपको एक बिंदु मिल गया है, लेकिन मुझे लगता है कि यह इस तरह से अधिक चुनौतीपूर्ण होगा। क्या मै गलत हु?

— वीरोस

जैसा कि यह एक कोड-गोल्फ प्रश्न है, जीतने का मापदंड सबसे छोटा कोड है। क्या होगा यदि वह कोड वास्तव में धीमा है और उसे चलाने में सदियां लगती हैं?

— विक्टर स्टैफुसा

Answer 1

गोल्फस्क्रिप्ट, 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<{;}*

उदाहरण:

0000001002
1010000001
0011010000
2001020000
0100100011
0110100000
0100000100
0010002010
0100110000
0012000210
6

0000100000
0100000001
1100000000
1011010000
0010001100
0101010200
0000200012
1100100110
0000011001
2201010000
11

0012010000
1000100122
0000001000
0111010100
0010012001
1020100110
1010101000
0102011111
0100100010
2102100110

Answer 2

गणितज्ञ (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]

मैं पड़ोसी कोने में सभी संभव फिल्मों का ग्राफ बनाता हूं और सभी संभव "टेलीपोर्ट" जोड़ता हूं।

Answer 3

गणितज्ञ, २०hem २०२ वर्ण

डेविड कर्रेर और ybeltukov के समाधान के आधार पर। और ybeltukov के सुझाव के लिए धन्यवाद।

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]

Comments

अच्छा लगा, +1! इसके अलावा अनुकूलन: :) के n/nबजायn/10

— ybeltukov

अच्छा प्रवाह। और आप तुरंत नक्शा बाहर प्रिंट करें।

— डेविड जेएन

और 〚 〛कोष्ठक के लिए (यह सही है यूनिकोड प्रतीकों)

— ybeltukov

क्या आप चयन मानदंड की व्याख्या कर सकते हैं,Norm[# - #2] & @@ # < 2 || # \[Union] u == u &

— डेविड जेएन

@ दाविद कररहर का Norm[# - #2] & @@ # < 2मतलब है दो बिंदुओं के बीच की दूरी कम है तो 2, इसलिए उन्हें आसन्न होना चाहिए। # ⋃ u == uइसका मतलब है कि दोनों बिंदु यू में हैं।

— एलेफाल्फा

Answer 4

अजगर 3, 279

कुछ दिक्जस्त्र संस्करण। बदसूरत, लेकिन जितना मैं कर सकता था ...

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

Answer 5

गणितज्ञ 316 279 275 275

मूल वस्तु लगभग 10 0, 30 1 और 10 2 के साथ 10x10 सरणी है। सरणी का उपयोग 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]

नमूना रन :

Comments

"आप किसी भी निकटवर्ती क्षेत्र (यहां तक ​​कि विकर्ण वाले) में जा सकते हैं"।

— एलेफाल्पा

Answer 6

पायथन (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

Comments

वाह, अब यह एक कोड गोल्फ के लिए एक चरित्र गणना है! मुझे लगता है कि आपकी गेंद रफ में उतरी।

— टिम सेग्यूनी

हाहा हाँ, मैं कोड को कम करने या कम से कम कार्यान्वयन को खोजने की कोशिश नहीं कर रहा था, लेकिन चरित्र की गणना की ताकि लोग जान सकें कि वे इस समाधान को अनदेखा कर सकते हैं। यह एक मजेदार समस्या की तरह लग रहा था।

— विनोद

Answer 7

जावास्क्रिप्ट (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पोर्टल रखती है। वास्तविक खोज BFS के माध्यम से कार्यान्वित की जाती है।

उदाहरण आउटपुट:

> नोड भूलभुलैया। जेएस
[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]
[१, १, १, ०, २, २, ०, १, ०, १]
[१, १, ०, ०, ०, ०, १, ०, ०, ०]
[१, १, ०, ०, १, ०, ०, ०, १, १]
[0, 0, 1, 1, 0, 1, 0, 0, 2, 0]
[०, ०, १, ०, १, २, ०, १, ०, १]
[१, ०, ०, ०, १, १, १, ०, १, १]
[0, 1, 0, 0, 0, 0, 0, 0, 1, 0]

> नोड भूलभुलैया। जेएस
[0, 0, 0, 0, 1, 0, 1, 0, 0, 1]
[०, २, ०, १, १, २, ०, ०, ०, ०]
[0, 0, 0, 0, 0, 0, 0, 0, 1]
[०, ०, ०, १, २, १, १, ०, १, ०]
[२, ०, १, ०, २, २, २, ०, १, ०]
[१, ०, ०, ०, १, ०, ०, ०, १, ०]
[0, 0, 1, 0, 0, 1, 0, 1, 0, 0]
[०, १, २, ०, ०, ०, ०, ०, १]
[१, ०, २, १, ०, १, २, ०, ०, १]
[0, 1, 2, 0, 0, 0, 0, 0, 0, 0]
5

Answer 8

पायथन 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]))

दिक्जस्त्र!

उदाहरण आउटपुट:

0000202000
2011000111
0000002000
0101001000
0000100110
1110100101
0020101000
0011200000
1010101010
0000001000

6

Answer 9

पायथन, 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)

यह बेलमैन-फोर्ड का घृणित कार्यान्वयन है। यह एल्गोरिथ्म हे (n ^ 6)! (जो n = 10 के लिए ठीक है)

Comments

नक्शा वास्तव में बदसूरत दिखता है। 10 से अधिक चरणों की आवश्यकता होने पर क्या यह काम करता है?

— मोनिका

@WolframH का पाठ्यक्रम: en.wikipedia.org/wiki/…

— संजीव मूर्ति

मैं इसे बना सकता था print '\n'.join(map(str,a)); मैंने print aगोल्फ के लिए किया।

— संजीव मूर्ति

मुझे एल्गोरिथ्म की शुद्धता पर संदेह नहीं था :-)। मुझे अभी एहसास नहीं हुआ था कि आप अक्सर पर्याप्त रूप से लूप करते हैं (जो आप करते हैं; r*10100 तत्व हैं)।

— मोनिका

हाँ। वास्तव में 100 ओवरकिल है; 99 सभी की जरूरत है।

— संजीव मूर्ति