गोल्फ एक नि: शुल्क दोपहर का भोजन

Question

विनिमय दर तालिका को दिए गए एक्सचेंजों के अधिकतम लाभदायक अनुक्रम का पता लगाएं।

---

एक उदाहरण के रूप मुद्राओं पर विचार एक riary (अपने घर मुद्रा), बी aht, सी ईडीआई, और डी ENAR जहां एक से दूसरे की दर (के बाद किसी भी लेन-देन दर लगाया गया है) (पंक्ति, स्तंभ) में प्रवेश द्वारा दिया जाता है नीचे विनिमय दर तालिका:

                       TO
       A          B          C          D

   A   0.9999     1.719828   4.509549   0.709929

F  B   0.579942   0.9999     2.619738   0.409959
R
O  C   0.219978   0.379962   0.9999     0.149985
M
   D   1.39986    2.429757   6.409359   0.9999

जाहिर है ए के लिए ए का आदान-प्रदान करना एक महान विचार नहीं है क्योंकि यह डेस्क आपको कुछ भी नहीं करने के लिए खुशी से चार्ज करेगा।

कम स्पष्ट रूप से, लेकिन इस तालिका के साथ सच है, किसी भी अन्य मुद्रा के लिए ए का आदान-प्रदान करना और फिर वापस विनिमय करना एक नुकसान निर्माता है:

via B: 1.719828 × 0.579942 = 0.997400489976
via C: 4.509549 × 0.219978 = 0.992001569922
via D: 0.709929 × 1.39986  = 0.99380120994

हालांकि, ए से डी फिर डी से बी और फिर बी बैक टू ए का आदान-प्रदान लाभ करता है (पर्याप्त पूंजी गोल करने के लिए नहीं ली जाती है):

0.709929 × 2.429757 × 0.579942 = 1.0003738278192194

अवसर मिलने पर कोई भी इसे बार-बार "फ्री लंच" ले सकता है।

लेकिन एक और भी आकर्षक श्रृंखला यहाँ मौजूद है, अर्थात् A से D फिर D से C और फिर C से B और अंत में B से A :

0.709929 × 6.409359 × 0.379962 × 0.579942 = 1.0026612752037345

---

चुनौती का विवरण

किसी भी उचित प्रारूप में विनिमय दर तालिका को देखते हुए जो घर-मुद्रा के अर्थ को ठीक करती है (जैसे 1 ^सेंट पंक्ति और 1 ^सेंट कॉलम हमेशा होम-मुद्रा होती है)
(या ऐसी तालिका और होम-मुद्रा इंडेक्स दिया गया है)
एक * खोजें एक्सचेंजों के रूप में घरेलू मुद्रा के साथ शुरू और समाप्त होने वाले एक्सचेंजों की अधिकतम मध्यस्थता अनुक्रम किसी भी विनिमय के उपयोग को दोहराए बिना मुद्रा सूची में (यानी एक वाई-> एक्स एक्सचेंज एक एक्स-> वाई एक का पालन कर सकता है, लेकिन एक एक्स-> वाई नहीं हो सकता है X-> Y) का पालन करें।

यदि ऐसा कोई लाभदायक अवसर मौजूद नहीं है, तो एक खाली सूची प्राप्त होती है, या कुछ अन्य परिणाम किसी पहचाने गए अवसर के साथ भ्रमित नहीं होते हैं।
- उपरोक्त उदाहरण के लिए ( A-> D, D-> C, C-> B, B-> A ):

• 0-इंडेक्सिंग का उपयोग करके कोई वापस आ सकता है [[0,3],[3,2],[2,1],[1,0]]या[0,3,2,1,0]
• 1-अनुक्रमण का उपयोग करके कोई वापस आ सकता है [[1,4],[4,3],[3,2],[2,1]]या[1,4,3,2,1]

अन्य प्रारूप ठीक हैं, जब तक कि कोई अस्पष्टता न हो।
- इसके लिए एक बात और ध्यान रखना चाहिए कि घर से एक ही लेन-देन करने का सबसे अच्छा अवसर संभव है-> घर (एक मूर्ख डेस्क)। यदि आप ऊपर (यानी [3,2,1]या [4,3,2]) फ्लैट विकल्प के दोनों सिरों से होम करेंसी इंडेक्स को छोड़कर जाने का निर्णय लेते हैं और "कोई अवसर नहीं है" के लिए एक खाली सूची तो सुनिश्चित करें कि घर-> घर भी एक खाली सूची नहीं है।

* यदि कई समान रूप से लाभदायक वैध अवसर मौजूद हैं, तो उनमें से कुछ, या उनमें से सभी को वापस कर दें।

^{बेलमैन-फोर्ड एल्गोरिथ्म यह दृष्टिकोण करने का एक तरीका है, लेकिन शायद गोल्फ के लिए सबसे उपयुक्त नहीं है।}

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

दिखाए गए इनपुट उदाहरण में उपयोग की गई व्यवस्था में हैं, और परिणाम दिखाए गए हैं 0-इंडेक्सिंग का उपयोग करेंसी-इंडेक्स को सूचीबद्ध करने के लिए (जब एक अवसर मौजूद है घरेलू मुद्रा केवल अनुगामी छोर पर है; कोई अवसर एक खाली सूची नहीं है)।

[[0.999900, 1.719828, 4.509549, 0.709929],
 [0.579942, 0.999900, 2.619738, 0.409959],
 [0.219978, 0.379962, 0.999900, 0.149985],
 [1.399860, 2.429757, 6.409359, 0.999900]]  ->  [3, 2, 1, 0]

[[0.9999, 1.5645, 0.9048, 1.0929],
 [0.6382, 0.9999, 0.5790, 0.6998],
 [1.1051, 1.7269, 0.9999, 1.2087],
 [0.9131, 1.4288, 0.8262, 0.9999]]  ->  [1, 2, 0]

[[0.9999, 1.4288, 0.8262, 0.9131],
 [0.6998, 0.9999, 0.5790, 0.6382],
 [1.2087, 1.7269, 0.9999, 1.1051],
 [1.0929, 1.5645, 0.9048, 0.9999]]  ->  [1, 2, 3, 1, 0]

[[1.002662, 1.719828, 4.509549, 0.709929],
 [0.579942, 0.999900, 2.619738, 0.409959],
 [0.219978, 0.379962, 0.999900, 0.149985],
 [1.399860, 2.429757, 6.409359, 0.999900]]  ->  [3, 2, 1, 0, 0]

[[1.002662, 1.719828, 4.509549, 0.709929],
 [0.579942, 1.002604, 2.619738, 0.409959],
 [0.219978, 0.379962, 1.003000, 0.149985],
 [1.399860, 2.429757, 6.409359, 1.002244]]  ->  [3, 3, 2, 2, 1, 1, 0, 0]

[[0.9999, 1.4288, 0.8262, 0.9131],
 [0.6998, 0.9999, 0.5790, 0.6382],
 [1.2087, 1.7269, 1.0001, 1.1051],
 [1.0929, 1.4974, 0.9048, 0.9999]]  ->  [1, 2, 2, 0]

[[0.9999, 1.3262, 0.7262, 0.9131],
 [0.6998, 0.9999, 0.5490, 0.6382],
 [1.2087, 1.7269, 0.9999, 1.2051],
 [1.0929, 1.5645, 0.9048, 0.9999]]  ->  [3, 2, 3, 1, 0]

[[0.9999, 1.5645, 0.9048, 0.5790],
 [0.6382, 0.9999, 0.5790, 0.3585],
 [1.1051, 1.7269, 0.9999, 0.6391],
 [1.7271, 2.6992, 1.5645, 0.9999]]  ->  [1, 2, 0]  and/or  [3, 2, 0]

[[0.9999, 1.2645, 0.7048, 0.3790],
 [0.4382, 0.9999, 0.3790, 0.1585],
 [1.0001, 1.5269, 1.0001, 0.4391],
 [1.5271, 2.4992, 1.3645, 0.9999]]  ->  []

[[0.9999, 1.2645, 0.7048, 0.3790],
 [0.4382, 0.9999, 0.3790, 0.1585],
 [0.9999, 1.5269, 1.4190, 0.4391],
 [1.5271, 2.4992, 1.3645, 0.9999]]  ->  [2, 2, 0]

---

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा समाधान है, लेकिन प्रतियोगिता को इंट्रा-भाषा भी बनाया जाना चाहिए, इसलिए कोड-गोल्फिंग भाषाओं को अपने पसंदीदा में जमा करने से न दें!

Answer 1

जावास्क्रिप्ट (ईएस 6), 122 113 103 बाइट्स

चुनौती में वर्णित प्रारूप के संबंध में एक प्रत्यारोपित मैट्रिक्स के रूप में इनपुट लेता है। (from,to)प्रारूप में आदान-प्रदान का वर्णन करने वाली एक स्ट्रिंग लौटाता है ।

a=>(g=(s,x=b=0,h='')=>a.map((r,y)=>~h.search(k=`(${x},${y})`)||g(s*r[x],y,h+k),x|s<b||(b=s,p=h)))(1)&&p

पहला परीक्षण मामला: इसे ऑनलाइन आज़माएं!

अधिक परीक्षण के मामले: इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

a => (                  // given the exchange rate matrix a[][]
  g = (                 // g = recursive function taking:
    s,                  //   s = current amount of money
    x = b = 0,          //   x = ID of current currency, b = best result so far
    h = ''              //   h = exchange history, as a string
  ) =>                  //  
  a.map((r, y) =>       // for each row at position y in a[]:
    ~h.search(          //   if we can't find in h ...
      k = `(${x},${y})` //     ... the exchange key k from currency x to currency y
    ) ||                //   then:
    g(                  //   do a recursive call to g() with:
      s * r[x],         //     s = new amount obtained by applying the exchange rate
      y,                //     x = y
      h + k             //     h = h + k
    ),                  //   end of recursive call
    x | s < b ||        //   if x is our home currency and s is greater than or equal to b
    (b = s, p = h)      //   then set b to s and set p to h
  )                     // end of map()
)(1)                    // initial call to g() with s = 1
&& p                    // return p

Answer 2

पायथन 2 , 143 125 124 बाइट्स

lambda M:g(M)[1]
g=lambda M,s=[],p=1,x=0:max([(p,s)]*-~-x+[g(M,s+[(x,y)],p*M[x][y],y)for y in range(len(M))if(x,y)not in s])

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

0-आधारित अनुक्रमण का उपयोग करता है (0 घरेलू मुद्रा है); अधिक से अधिक भुगतान करने वाले एक्सचेंजों के ट्यूपल्स की सूची देता है।

दृष्टिकोण जानवर बल है: प्रत्यावर्तन के माध्यम से, हम प्रत्येक गैर-एज-दोहरा पथ पर शुरू जाकर खत्म 0(के लिए nमुद्राओं की संख्या में किया जा रहा है, यह एक अधिकतम देता है गहराई से n^2)। '0' के साथ समाप्त होने वाले इन रास्तों के सबसेट के लिए, हम भुगतान को अधिकतम करते हैं।

Answer 3

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

e?l|e`elem`l=0|2>1=1
w[]=[]
w l=[maximum l];0!q=[q]
n!c@(v,i,(h,l))=do{j<-[0..3];c:((n-1)!(v*l!!i!!j*(i,j)?h,j,((i,j):h,l)))}
z l=w$filter(\(v,e,_)->v>1&&e==0)$12!(1,0,([],l))

इसे यहाँ आज़माएँ