ค้นหาลำดับการแลกเปลี่ยนที่ให้ผลกำไรสูงสุดโดยมีตารางอัตราแลกเปลี่ยน

ยกตัวอย่างเช่นพิจารณาสกุลเงินA riary (สกุลเงินที่ใช้ในบ้านของคุณ), B aht, C edi และD 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

เห็นได้ชัดว่าการแลกเปลี่ยนAสำหรับAไม่ใช่ความคิดที่ดีเพราะโต๊ะนี้จะคิดเงินคุณอย่างมีความสุขที่ไม่ได้ทำอะไรเลย

เห็นได้ชัดน้อยลง แต่เป็นความจริงกับตารางนี้การแลกเปลี่ยนAสำหรับสกุลเงินอื่น ๆ และจากนั้นการแลกเปลี่ยนกลับมาอีกครั้งเป็นผู้สร้างขาดทุน:

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

อย่างไรก็ตามการแลกเปลี่ยนAถึงDจากนั้นDถึงBจากนั้นBกลับไปที่A ทำกำไร (ให้ทุนมากพอที่จะไม่ยอมให้ปัดเศษ):

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 ^{เซนต์}คอลัมน์อยู่เสมอที่บ้านสกุลเงิน)
(หรือที่ได้รับดังกล่าวเป็นตารางและดัชนีที่บ้านสกุลเงิน)
หา * ลำดับการเก็งกำไรสูงสุดของการแลกเปลี่ยนเริ่มต้นและสิ้นสุดด้วยสกุลเงินบ้านเป็นดัชนีในรายการสกุลเงินโดยไม่ต้องใช้การแลกเปลี่ยนซ้ำ (เช่นการแลกเปลี่ยน Y-> X อาจตาม X-> Y หนึ่ง แต่ X-> Y อาจไม่ ติดตาม 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]) และรายการว่างสำหรับ "ไม่มีโอกาส" ให้แน่ใจว่าบ้าน -> บ้านนั้นไม่ใช่รายการที่ว่างเปล่า

* หากมีโอกาสที่ถูกต้องที่ทำกำไรได้เท่ากันเกิดขึ้นให้ส่งคืนใด ๆ ของพวกเขาบางส่วนหรือทั้งหมด

^{อัลกอรึทึมของ Bellman-Fordเป็นวิธีหนึ่งในการเข้าถึงสิ่งนี้ แต่อาจจะไม่ใช่วิธีที่ดีที่สุดสำหรับการเล่นกอล์ฟ}

กรณีทดสอบ

อินพุตที่แสดงอยู่ในการจัดเรียงที่ใช้ในตัวอย่างและผลลัพธ์ที่แสดงใช้การจัดทำดัชนี 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]

นี่คือcode-golfดังนั้นทางออกที่สั้นที่สุดในการชนะ bytes แต่การแข่งขันควรทำในภาษาด้วยดังนั้นอย่าให้ภาษา code-golfing นำคุณออกจากการส่งในรายการโปรดของคุณ!

JavaScript (ES6), 122 113 103 ไบต์

รับอินพุตเป็นเมทริกซ์ transposed ตามรูปแบบที่อธิบายในความท้าทาย ส่งคืนสตริงที่อธิบายถึงการแลกเปลี่ยนใน(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

Python 2 , 143 125 124 bytes

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 คือสกุลเงินหลัก) ส่งคืนรายการ tuples ของการแลกเปลี่ยนที่ให้ผลตอบแทนสูงสุด

วิธีการคือการใช้กำลังดุร้าย: ผ่านการเรียกซ้ำเราสิ้นสุดการเยี่ยมชมทุกเส้นทางที่ไม่ซ้ำกันเริ่มต้นที่0(สำหรับnจำนวนของสกุลเงินซึ่งจะทำให้ความลึกสูงสุดของn^2) สำหรับส่วนย่อยของเส้นทางเหล่านี้ลงท้ายด้วย '0' เราจะเพิ่มผลตอบแทนให้สูงสุด

Haskell, 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))

ลองที่นี่