धनात्मक पूर्णांक से मिलकर एक मैट्रिक्स को देखते हुए, ऊपरी बाएं तत्व से नीचे दाईं ओर ट्रैवर्सिंग करते समय सबसे कम राशि के साथ पथ का उत्पादन करें। आप लंबवत, क्षैतिज और तिरछे ढंग से आगे बढ़ सकते हैं। ध्यान दें कि ऊपर / नीचे, दाएं / बाएं और तिरछे दोनों तरफ बढ़ना संभव है।

उदाहरण:

 1*   9    7    3   10    2    2
10    4*   1*   1*   1*   7    8
 3    6    3    8    9    5*   7
 8   10    2    5    2    1*   4
 5    1    1    3    6    7    9*

सबसे कम राशि देने वाला मार्ग तारांकन के साथ चिह्नित है, और निम्नलिखित योग में परिणाम है: 1 + 4 + 1 + 1 + 1 + 5 + 1 + 9 = 23 ।

परीक्षण के मामलों:

1   1   1
1   1   1
Output: 3

 7    9    6    6    4
 6    5    9    1    6
10    7   10    4    3
 4    2    2    3    7
 9    2    7    9    4
Output: 28

2  42   6   4   1
3  33   1   1   1
4  21   7  59   1
1   7   6  49   1
1   9   2  39   1
Output: 27 (2+3+4+7+7+1+1+1+1)

 5    6    7    4    4
12   12   25   25   25
 9    4   25    9    5
 7    4   25    1   12
 4    4    4    4    4
Output: 34 (5+12+4+4+4+1+4)

1   1   1   1
9   9   9   1
1   9   9   9
1   9   9   9
1   1   1   1
Output: 15

 2   55    5    3    1    1    4    1
 2   56    1   99   99   99   99    5
 3   57    5    2    2    2   99    1
 3   58    4    2    8    1   99    2
 4   65   66   67   68    3   99    3
 2    5    4    3    3    4   99    5
75   76   77   78   79   80   81    2
 5    4    5    1    1    3    3    2
Output: 67 (2+2+3+3+4+5+4+3+3+3+1+2+2+1+3+1+1+4+5+1+2+3+5+2+2)

यह कोड-गोल्फ है इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है।

— स्टीवी ग्रिफिन
स्रोत

बहुत समान है , हालांकि यह विकर्ण आंदोलन की अनुमति नहीं देता है।

— मेगो

7

@WheatWizard मैं असहमत हूं। ज्यादातर सतही अंतरों के अलावा, जो इस चुनौती को विकर्ण आंदोलन के लिए अनुमति देता है और सभी स्थान उपलब्ध हैं, अन्य चुनौती के लिए केवल पथ की लागत के बजाय पथ की वापसी की आवश्यकता होती है। जब तक आप बिल्ट-इन का उपयोग नहीं कर रहे हैं, दोनों वापस आ जाते हैं, तो कोड विनिमेय नहीं होता है।

— बीकर

@ बीकर मैं वास्तव में अंतर नहीं देखता। आपको इसकी लंबाई जानने के लिए रास्ता खोजना होगा। यहाँ अंतर मेरी राय में उत्पादन में एक छोटा सा अंतर है और यह चुनौती उस चुनौती से पहले से कवर नहीं किए गए नए या दिलचस्प कुछ भी नहीं प्रदान करती है।

— गेहूं जादूगर

1

@HeatWizard मेरा समाधान यहाँ पथ नहीं ढूँढता है। यह मार्ग ढूँढ सकता है , लेकिन एक अलग पूर्ववर्ती सरणी और तर्क के बिना नोड को अपना पूर्ववर्ती बनाने से बचने के लिए नहीं। अंत में मार्ग ठीक होने का उल्लेख नहीं।

— बीकर

@ बीकर मेरी राय में संशोधन मामूली है। बावजूद इसके कि सवाल यह नहीं है कि सामान्य चुनौती के बारे में कम से कम एक प्रयास में हर एक वैध प्रविष्टि को कम से कम प्रयास के साथ चित्रित किया जा सकता है या नहीं। न केवल मुझे लगता है कि यहां अधिकांश प्रयासों को चित्रित किया जा सकता है मुझे नहीं लगता कि यह चुनौती दूसरे से कुछ भी नया या दिलचस्प प्रदान करती है।

— गेहूं जादूगर

8

जावास्क्रिप्ट, 442 412 408 358 बाइट्स

यह मेरा पहला PPCG सबमिशन है। प्रतिक्रिया की सराहना की जाएगी।

(m,h=m.length,w=m[0].length)=>{for(i=0;i<h*w;i++)for(x=0;x<w;x++){for(y=0;y<h;y++){if(m[y][x]%1==0)m[y][x]={c:m[y][x],t:m[y][x]};for(X=-1;X<=1;X++)for(Y=-1;Y<=1;Y++){t=x+X;v=y+Y;if((X==0&&Y==0)||t<0||t>=w||v<0||v>=h)continue;if(m[v][t]%1==0)m[v][t]={c:m[v][t],t:null};c=m[y][x].t+m[v][t].c;if (c<m[v][t].t||m[v][t].t==null)m[v][t].t=c}}}return m[h-1][w-1].t}

यह इनपुट के रूप में एक बहुआयामी सरणी लेता है।

व्याख्या

मूल रूप से, प्रत्येक कोशिकाओं को सभी पड़ोसियों से प्राप्त करने के लिए सबसे कम ज्ञात लागत को समायोजित करने के माध्यम से लूप। आखिरकार, ग्रिड एक ऐसी स्थिति में पहुंच जाएगा जहां नीचे दाएं पहुंचने की कुल लागत वहां पहुंचने के लिए सबसे कम लागत है।

डेमो

f=(m,h=m.length,w=m[0].length)=>{for(i=0;i<h*w;i++)for(x=0;x<w;x++){for(y=0;y<h;y++){if(m[y][x]%1==0)m[y][x]={c:m[y][x],t:m[y][x]};for(X=-1;X<=1;X++)for(Y=-1;Y<=1;Y++){t=x+X;v=y+Y;if((X==0&&Y==0)||t<0||t>=w||v<0||v>=h)continue;if(m[v][t]%1==0)m[v][t]={c:m[v][t],t:null};c=m[y][x].t+m[v][t].c;if (c<m[v][t].t||m[v][t].t==null)m[v][t].t=c}}}return m[h-1][w-1].t}

//Tests
console.log(f([[1,1,1],[1,1,1]])===3);
console.log(f([[7,9,6,6,4],[6,5,9,1,6],[10,7,10,4,3],[4,2,2,3,7],[9,2,7,9,4]])===28);
console.log(f([[2,42,6,4,1],[3,33,1,1,1],[4,21,7,59,1],[1,7,6,49,1],[1,9,2,39,1]])===27);
console.log(f([[5,6,7,4,4],[12,12,25,25,25],[9,4,25,9,5],[7,4,25,1,12],[4,4,4,4,4]])===34); 
console.log(f([[1,1,1,1],[9,9,9,1],[1,9,9,9],[1,9,9,9],[1,1,1,1]])===15)
console.log(f([[2,55,5,3,1,1,4,1],[2,56,1,99,99,99,99,5],[3,57,5,2,2,2,99,1],[3,58,4,2,8,1,99,2],[4,65,66,67,68,3,99,3],[2,5,4,3,3,4,99,5],[75,76,77,78,79,80,81,2],[5,4,5,1,1,3,3,2]])===67);

स्निपेट का विस्तार करें

संपादित करें: @ETHproductions के लिए विशेष धन्यवाद मुझे स्वादिष्ट बाइट्स के दर्जनों दाढ़ी बनाने में मदद करने के लिए ।

अपने सुझावों के लिए @Stewie ग्रिफिन के लिए और अधिक धन्यवाद जिसने 50 बाइट्स को बंद कर दिया।

— बेंजामिन कनिंघम
स्रोत

3

PPCG में आपका स्वागत है! कुछ अतिरिक्त स्थान हैं जिन्हें आप अंत की ओर हटा सकते हैं (मैं 5 कुल गिनता हूं), और आपको सीधे किसी भी अर्धविराम की आवश्यकता नहीं है }जिससे पहले कुछ बाइट्स को सहेजना चाहिए। आपको अपने चर घोषित करने की भी आवश्यकता नहीं है; मुझे लगता है कि एस को हटाने से varआपको कुल 24 बाइट बचानी चाहिए।

— ETHproductions

2

PPCG में आपका स्वागत है =) मुझे खुशी है कि आपने मेरी चुनौतियों में से एक को शुरुआती बिंदु के रूप में चुना। मेरी एकमात्र टिप्पणी: मुझे स्पष्टीकरण पसंद हैं। हालांकि यह वैकल्पिक है, इसलिए आपको इसे तब तक नहीं जोड़ना है जब तक आप नहीं चाहते हैं। :)

— स्टिव ग्रिफ़िन

मुझे लगता है कि शायद m[v][t]एक चर के रूप में भंडारण किया t=x+X;v=y+Y;k=m[v][t]जा रहा है : और भी छोटा होगा ...?

— स्टीवी ग्रिफिन

7

अजगर 3 + numpy + scipy , 239 222 186 बाइट्स

from numpy import*
from scipy.sparse.csgraph import*
def f(M):m,n=s=M.shape;x,y=indices(s);return dijkstra([(M*(abs(i//n-x)<2)*(abs(i%n-y)<2)).flatten()for i in range(m*n)])[0,-1]+M[0,0]

इसे ऑनलाइन आज़माएं!

— notjagan
स्रोत

6

ऑक्टेव + इमेज प्रोसेसिंग पैकेज, 175 162 157 151 142 139 बाइट्स

सहेजे गए 14 बाइट्स @Luis मेंडो और 1 बाइट की बदौलत @notjagan को धन्यवाद

function P(G)A=inf(z=size(G));A(1)=G(1);for k=G(:)'B=im2col(padarray(A,[1,1],inf),[3,3])+G(:)';B(5,:)-=G(:)';A=reshape(min(B),z);end,A(end)

इमेज प्रोसेसिंग पैकेज का उपयोग करता है, क्योंकि क्यों नहीं? क्या यह नहीं है कि हर कोई ग्राफ़ की समस्याओं को हल कैसे करे?

इसे ऑनलाइन आज़माएं!

विस्फोट

function P(G)
   A=inf(z=size(G));         % Initialize distance array to all Inf
   A(1)=G(1);                % Make A(1) = cost of start cell
   for k=G(:)'               % For a really long time...
      B=im2col(padarray(A,[1,1],inf),[3,3])+G(:)';
       %  B=padarray(A,[1,1],inf);     % Add border of Inf around distance array
       %  B=im2col(B,[3,3]);           % Turn each 3x3 neighborhood into a column
       %  B=B+G(:)';                   % Add the weights to each row
      B(5,:)-=G(:)';         % Subtract the weights from center of neighborhood
      A=reshape(min(B),z);   % Take minimum columnwise and reshape to original
   end
   A(end)                    % Display cost of getting to last cell

व्याख्या

भार की एक सरणी को देखते हुए:

7   12    6    2    4
5   13    3   11    1
4    7    2    9    3
4    2   12   13    4
9    2    7    9    4

एक लागत सरणी शुरू करें ताकि प्रत्येक तत्व तक पहुंचने की लागत इन्फिनिटी हो, सिवाय शुरुआती बिंदु (ऊपरी बाएं तत्व) जिसकी लागत उसके वजन के बराबर हो।

  7   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf

यह पुनरावृत्ति है। प्रत्येक बाद के पुनरावृत्ति के लिए, एक सेल तक पहुंचने की लागत न्यूनतम के लिए निर्धारित है:

वर्तमान लागत उस तत्व तक पहुँचने के लिए, और
तत्व के पड़ोसियों + तत्व के वजन तक पहुंचने के लिए वर्तमान लागत

पहले पुनरावृत्ति के बाद, पथ के तत्व (2,2) (1-आधारित अनुक्रमण का उपयोग करके) की लागत होगी

minimum([  7   Inf   Inf]   [13  13  13]) = 20
        [Inf   Inf   Inf] + [13   0  13]
        [Inf   Inf   Inf]   [13  13  13]

पहले पुनरावृत्ति के बाद पूर्ण लागत सरणी होगी:

  7    19   Inf   Inf   Inf
 12    20   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf

पुनरावृत्ति के बाद k, प्रत्येक तत्व उस तत्व तक पहुंचने की सबसे कम लागत होगी जो कि अधिकांश kचरणों में शुरू होती है । उदाहरण के लिए, 22 की लागत के लिए तत्व (3,3) को 2 चरणों (पुनरावृत्तियों) में पहुंचाया जा सकता है:

  7    19    25   Inf   Inf
 12    20    22   Inf   Inf
 16    19    22   Inf   Inf
Inf   Inf   Inf   Inf   Inf
Inf   Inf   Inf   Inf   Inf

लेकिन 4 पुनरावृति पर, 20 की लागत के साथ 4 चरणों का एक पथ पाया जाता है:

 7   19   25   24   28
12   20   22   32   25
16   19   20   30   34
20   18   30   34   35
27   20   25   40   39

चूंकि mxn मैट्रिक्स के माध्यम से कोई भी पथ मैट्रिक्स में तत्वों की संख्या से अधिक नहीं हो सकता है (एक बहुत ही ढीली ऊपरी सीमा के रूप में), m*nपुनरावृत्तियों के बाद प्रत्येक तत्व को शुरू से उस तत्व तक पहुंचने के लिए सबसे छोटे पथ की लागत शामिल होगी।

— बीकर
स्रोत

-1 बाइट के बीच whileऔर जगह को हटाकर ~।

— नॉटजगन

@notjagan मैंने से स्विच whileकिया forऔर अभी भी आपकी टिप का उपयोग करने में सक्षम था। धन्यवाद!

— बीकर

5

जावास्क्रिप्ट, 197 बाइट्स

a=>(v=a.map(x=>x.map(_=>1/0)),v[0][0]=a[0][0],q=[...(a+'')].map(_=>v=v.map((l,y)=>l.map((c,x)=>Math.min(c,...[...'012345678'].map(c=>a[y][x]+((v[y+(c/3|0)-1]||[])[x+c%3-1]||1/0)))))),v.pop().pop())

सँवारना:

a=>(
  // v is a matrix holds minimal distance to the left top
  v=a.map(x=>x.map(_=>1/0)),
  v[0][0]=a[0][0],
  q=[
     // iterate more than width * height times to ensure the answer is correct
    ...(a+'')
  ].map(_=>
    v=v.map((l,y)=>
      l.map((c,x)=>
        // update each cell
        Math.min(c,...[...'012345678'].map(
          c=>a[y][x]+((v[y+(c/3|0)-1]||[])[x+c%3-1]||1/0)
        ))
      )
    )
  ),
  // get result at right bottom
  v.pop().pop()
)

— TSH
स्रोत

4

गणितज्ञ 279 बाइट्स

मूल विचार मैट्रिक्स प्रविष्टियों के अनुरूप कोने के साथ एक ग्राफ बनाना है और किसी भी दो कोने के बीच के किनारों को निर्देशित किया गया है जो ChessboardDistanceशून्य से अधिक लेकिन 1 से कम या 1 से अलग है। संयोग से, यह एक राजा ग्राफ के रूप में जाना जाता है , क्योंकि यह मेल खाता है शतरंज की बिसात पर राजा की वैध चाल।

FindShortestPathतब न्यूनतम पथ प्राप्त करने के लिए उपयोग किया जाता है। यह काम करता है EdgeWeight, नहीं VertexWeight, इसलिए EdgeWeightप्रत्येक निर्देशित किनारे के गंतव्य के अनुरूप मैट्रिक्स प्रविष्टि के रूप में परिभाषित करने के लिए कुछ अतिरिक्त कोड है ।

कोड:

(m=Flatten[#];d=Dimensions@#;s=Range[Times@@d];e=Select[Tuples[s,2],0<ChessboardDistance@@(#/.Thread[s->({Ceiling[#/d[[1]]],Mod[#,d[[1]],1]}&/@s)])≤1&];Tr[FindShortestPath[Graph[s,#[[1]]->#[[2]]&/@e,EdgeWeight->(Last@#&/@Map[Extract[m,#]&,e,{2}])],1,Last@s]/.Thread[s->m]])&

ध्यान दें कि  चरित्र संक्रमण प्रतीक है। यह के रूप में Mathematica में पेस्ट करेंगे।

उपयोग:

%@{{2, 55, 5, 3, 1, 1, 4, 1},
  {2, 56, 1, 99, 99, 99, 99, 5},
  {3, 57, 5, 2, 2, 2, 99, 1},
  {3, 58, 4, 2, 8, 1, 99, 2},
  {4, 65, 66, 67, 68, 3, 99, 3},
  {2, 5, 4, 3, 3, 4, 99, 5},
  {75, 76, 77, 78, 79, 80, 81, 2},
  {5, 4, 5, 1, 1, 3, 3, 2}}

आउटपुट:

यदि आप सेट करते हैं g=Graph[...,GraphLayout->{"GridEmbedding","Dimension"->d},VertexLabels->Thread[s->m]और p=FindShortestPath[...फिर निम्नलिखित ग्राफिक नेत्रहीन रूप से समाधान प्रदर्शित करेगा (मैट्रिक्स के ऊपर ग्राफ के नीचे से मेल खाती है):

HighlightGraph[g,PathGraph[p,Thread[Most@p->Rest@p]]]

— केली लोवदर
स्रोत

3

हास्केल, 228 बाइट्स

पदों दो तत्वों की सूची है, क्योंकि उन के साथ उत्पन्न करने के लिए आसान है sequenceऔर बस 2-ट्यूपल्स के रूप में मैच पैटर्न के लिए आसान है।

h=g[[-1,-1]]
g t@(p:r)c|p==m=0|1<2=minimum$(sum$concat c):(\q@[a,b]->c!!a!!b+g(q:t)c)#(f(e$s$(\x->[0..x])#m)$f(not.e t)$zipWith(+)p#s[[-1..1],[-1..1]])where m=[l(c)-1,l(head c)-1]
(#)=map
f=filter
e=flip elem
s=sequence
l=length

प्रारंभ करें -1,-1और प्रत्येक चरण गंतव्य फ़ील्ड की लागत की गणना करें।

वैकल्पिक पहली दो पंक्तियाँ: 0,0प्रस्थान क्षेत्र शुरू करें, मैट्रिक्स आयामों के बराबर निर्देशांक पर समाप्त करें (इसलिए लक्ष्य से नीचे-दाएं, जिसे कानूनी स्थलों की सूची में जोड़ना होगा) - ठीक उसी लंबाई लेकिन धीमी:

j=i[[0,0]]
i t@(p@[a,b]:r)c|p==m=0|1<2=c!!a!!b+(minimum$(sum$concat c):(\q->i(q:t)c)#(f(e$m:(s$(\x->[0..x-1])#m))$f(not.e t)$zipWith(+)p#s[[-1..1],[-1..1]]))where m=[l c,l$head c]

इसके लिए एक इनफ़िक्स का उपयोग करना mapबाइट्स को नहीं बचाता है, लेकिन मैं इसे जल्द से जल्द प्रतिस्थापित करता हूं, क्योंकि इसकी कीमत एक नहीं है, क्योंकि यह केवल अधिक उपयोगों के साथ बेहतर हो सकता है, और कभी-कभी अन्य पुनर्गठन के साथ-साथ जो कोष्ठक की एक और जोड़ी को बंद कर देते हैं।

सुधार के लिए: निरर्थक filterएस। विलय / इन-अस्तर उन्हें filter(flip elem$(s$(\x->[0..x])#m)\\p)साथ import Data.Listके लिए \\3 लागत बाइट्स।

इसके अलावा, बहुत बुरा (fromEnumTo 0)2 बाइट्स की तुलना में लंबा है (\x->[0..x])।

sum$concat cक्या सभी क्षेत्रों की लागत का योग है और इस प्रकार पथ लागत पर एक संक्षिप्त रूप से व्यक्त ऊपरी सीमा जो minimumखाली सूची से बचने के लिए दी गई है (मेरे प्रकार चेकर ने पहले से ही पूरी तरह से काम करने के लिए निर्धारित किया है Integer, इसलिए अधिकतम हार्ड-कोडिंग नहीं है , हे)। कोई फर्क नहीं पड़ता कि मैं पिछले एक के आधार पर कदमों को कैसे प्रतिबंधित करता हूं (जो कि एल्गोरिथ्म को बहुत तेज करेगा, लेकिन बाइट्स भी खर्च करेगा), मैं उन मृत सिरों से बच नहीं सकता जो इस गिरावट को वापस आवश्यक बनाते हैं।

एक फिल्टर विचार ((not.e n).zipWith(-)(head r))निकालने के साथ था n=s[[-1..1],[-1..1]], जो ,[-1,-1]प्रारंभिक पथ को जोड़ने की आवश्यकता है। एल्गोरिथ्म तब जाने से बचता है, जहां वह पहले से ही पिछले चरण में जा सकता था, जो एक किनारे के क्षेत्र में एक किनारे पर एक मृत अंत में कदम रखता है।
एक और ((>=0).sum.z(*)d)निकालने के साथ था z=zipWith, जो पुनरावर्ती और प्रारंभिक मामले में dदिए गए पुनरावर्ती कार्य के लिए एक नया तर्क पेश करता है । एल्गोरिथ्म एक नकारात्मक स्केलर उत्पाद ( पिछले चरण) होने के साथ क्रमिक चरणों से बचता है , जिसका अर्थ है कि कोई तेज 45 ° -टर्न। यह अभी भी विकल्पों को काफी कम कर देता है, और पिछले तुच्छ मृत अंत से बचा जाता है, लेकिन अभी भी ऐसे रास्ते हैं जो अंत में पहले से देखे गए क्षेत्रों में संलग्न हैं (और संभवतः एक 'बच' जो हालांकि एक तेज मोड़ होगा)।(z(-)p q)[1,1]d

— लीफ़ विलर्ट्स
स्रोत

3

पायथन 2, 356 320 बाइट्स

s=input()
r=lambda x:[x-1,x,x+1][-x-2:]
w=lambda z:[z+[(x,y)]for x in r(z[-1][0])for y in r(z[-1][1])if x<len(s)>0==((x,y)in z)<len(s[0])>y]
l=len(s)-1,len(s[0])-1
f=lambda x:all(l in y for y in x)and x or f([a for b in[l in z and[z]or w(z)for z in x]for a in b])
print min(sum(s[a][b]for(a,b)in x)for x in f([[(0,0)]]))

यहाँ कोशिश करो!

-36 बाइट्स notjagan को धन्यवाद !

इनपुट के रूप में सूचियों की एक सूची प्राप्त करता है, और मैट्रिक्स को ऊपरी बाएं से नीचे दाईं ओर नेविगेट करते समय सबसे कम लागत का आउटपुट देता है।

व्याख्या

मैट्रिक्स के ऊपरी बाएँ से नीचे दाईं ओर के हर संभव मार्ग का पता लगाएं, प्रत्येक मार्ग के लिए x, y निर्देशांक की सूची बनाते हैं। मार्ग पीछे नहीं हट सकते, और उन्हें समाप्त होना चाहिए(len(s)-1,len(s[0])-1) ।

निर्देशांक के प्रत्येक पथ पर पूर्णांकों को जोड़ो, और न्यूनतम लागत लौटाओ।

printआसानी से उत्पादन के लिए सबसे छोटा मार्ग के लिए निर्देशांक की सूची बदला जा सकता है।

— solvation
स्रोत

-36 बाइट्स कुछ विविध परिवर्तनों के साथ।

— नॉटजैगन

@ नॉटजगन महान परिवर्तन, विशेष रूप orसे सशर्त के लिए उपयोग । धन्यवाद!

— सॉल्वेशन

1

APL (Dyalog Classic) , 33 बाइट्स

{⊃⌽,(⊢⌊⍵+(⍉3⌊/⊣/,⊢,⊢/)⍣2)⍣≡+\+⍀⍵}

इसे ऑनलाइन आज़माएं!

{ } तर्क के साथ कार्य करें ⍵

+\+⍀⍵ पथ दूरी पर एक निराशावादी ऊपरी सीमा स्थापित करने के लिए पंक्ति और स्तंभ द्वारा आंशिक रकम लें

( )⍣≡ अभिसरण तक दोहराएं:

(⍉3⌊/⊣/,⊢,⊢/)⍣2पड़ोसियों से दूरी की दूरी, यानी दो बार करें ( ( )⍣2): बाईं ओर के कॉलम ( ⊣/,) को स्व ( ⊢और) के सबसे दाहिने कॉलम से जोड़ें ( ,⊢/), क्षैतिज त्रिभुज में मिनीमा खोजें ( 3⌊/और स्थानांतरित करें ⍉)
⍵+ पड़ोसियों के साथ अपनी दूरी के प्रत्येक नोड के मूल्य को जोड़ें
⊢⌊ वर्तमान सर्वोत्तम दूरी को हराकर देखें

⊃⌽, अंत में, नीचे दायां सेल वापस करें

— NGN
स्रोत

एक मैट्रिक्स के माध्यम से इष्टतम पथ

उदाहरण:

परीक्षण के मामलों:

जावास्क्रिप्ट, 442 412 408 358 बाइट्स

व्याख्या

डेमो

अजगर 3 + numpy + scipy , 239 222 186 बाइट्स

ऑक्टेव + इमेज प्रोसेसिंग पैकेज, 175 162 157 151 142 139 बाइट्स

जावास्क्रिप्ट, 197 बाइट्स

गणितज्ञ 279 बाइट्स

हास्केल, 228 बाइट्स

पायथन 2, 356 320 बाइट्स

व्याख्या

APL (Dyalog Classic) , 33 बाइट्स