ฉันทำงานที่ร้านเบเกอรี่ที่ให้บริการข้าวสาลีข้าวไรย์ข้าวบาร์เลย์ธัญพืชและขนมปังฝรั่งเศส แต่คนทำขนมปังแปลก ๆ เล็กน้อย - เขากองก้อนเรียงตามลำดับแบบสุ่มและบางครั้งก็ออกจากชั้นวางที่ว่าง

ในแต่ละวันลูกค้ารายเดิมเข้ามาและขอขนมปังหนึ่งก้อน แต่สิ่งที่ยุ่งยากก็คือเขาเป็น germophobe ดังนั้นเมื่อฉันเติมกระเป๋าของเขาฉันไม่สามารถนำก้อนจากชั้นวางติดกันสองชั้นในการเลือกต่อเนื่อง

ใช้เวลาหนึ่งวินาทีในการเดินระหว่างชั้นวางที่อยู่ติดกัน มันเป็นร้านยุ่ง สำหรับการกำหนดค่าแบบสุ่มใด ๆ ของก้อนฉันต้องการลดเวลาที่ใช้ในการรับหนึ่งในแต่ละก้อนที่ไม่ซ้ำกัน ฉันสามารถเริ่มต้นและสิ้นสุดที่ชั้นวางใดก็ได้

หากการสั่งซื้อของวันนี้เป็นW B W G F R Wเส้นทางที่เป็นไปได้0, 3, 5, 1, 4รวมเป็น 12 วินาที:abs(3-0) + abs(5-3) + abs(1-5) + abs(4-1) = 12

( 1, 2, 3, 4, 5ใช้งานไม่ได้เนื่องจากมีการหยิบขนมปังติดต่อกันจากชั้นวางที่อยู่ติดกัน)

หากB W B G B F B R B W B Fเป็นเส้นทางที่เป็นไปได้คือ1, 3, 5, 7, 10รวมเป็น 9 วินาที

ผู้จัดการมักจะทำให้แน่ใจว่ามีทางออกที่เป็นไปได้ดังนั้นฉันไม่ต้องกังวลเกี่ยวกับการจับอินพุทที่ไม่ดี เขามักจะส่งคำสั่งในไฟล์ แต่ถ้าฉันต้องการฉันสามารถพิมพ์ไปยัง STDIN หรืออ่านมันในวิธีที่แตกต่างกัน ฉันต้องการโปรแกรมที่จะพิมพ์ออกมาดัชนีของเส้นทางที่ดีที่สุดเช่นเดียวกับเวลาของตนตามค่าเริ่มต้นของ I / O กฎ

ในระยะสั้น:

1. ขนมปัง 5 ประเภท
2. คำสั่งแบบโลฟปรากฏขึ้นเป็นสตริงของคำสั่งแบบสุ่มและความยาว
3. ต้องเลือกหนึ่งในแต่ละก้อนที่ไม่ซ้ำกัน
4. ไม่สามารถทำการเลือกที่อยู่ติดกันติดกัน
5. ลดระยะห่างระหว่างดัชนีการเลือก
6. ไม่จำเป็นต้องกังวลเกี่ยวกับอินพุตที่ไม่ถูกต้อง
7. ใช้กฎ I / O เริ่มต้น

นี่คือโค้ดกอล์ฟการนับจำนวนไบต์ที่สั้นที่สุดชนะ

JavaScript (ES6), 114 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @Oliver

รับอินพุตเป็นอาร์เรย์ของอักขระ ส่งออกสตริงที่คั่นด้วยเครื่องหมายจุลภาคโดยที่ค่าแรกคือเวลาทั้งหมดและสตริงถัดไปจะอธิบายถึงเส้นทาง

a=>(b=g=(r,s=o='',c,p)=>s[c>b|4]?o=(b=c)+r:a.map((v,i)=>s.match(v)||(d=p<i?i-p:p-i)<2||g([r,i],s+v,~~c+d,i))&&o)``

ลองออนไลน์!

แสดงความคิดเห็น

a => (                          // a[] = input array
  b =                           // b = best score so far (initially a non-numeric value)
  g = (                         // g = recursive function taking:
    r,                          //   r = path
    s =                         //   s = string of collected loaves of bread
    o = '',                     //   o = final output
    c,                          //   c = current cost
    p                           //   p = index of the last visited shelf 
  ) =>                          //
    s[c > b                     // if the final cost is not greater than our best score
            | 4] ?              // and we've successfully collected 5 loaves of bread:
      o = (b = c) + r           //   update the current output and the best score
    :                           // else:
      a.map((v, i) =>           //   for each loaf of bread v at shelf i in a[]:
        s.match(v) ||           //     if we've already collected this kind of bread
        (d =                    //     or the distance d
          p < i ? i - p : p - i //     defined as the absolute value of p - i
        ) < 2 ||                //     is less than 2: stop recursion
        g(                      //     otherwise, do a recursive call to g() with:
          [r, i],               //       r updated with the index of the current shelf
          s + v,                //       s updated with the current loaf of bread
          ~~c + d,              //       c updated with the last distance
          i                     //       i as the index of the last shelf
        )                       //     end of recursive call
      )                         //   end of map()
      && o                      //   return the current output
  )``                           // initial call to g() with r = [""]

Python 2 , 212 210 ไบต์

lambda s:min((sum(h(p)),p)for b in combinations(range(len(s)),5)for p in permutations(b)if(len(set(s[i]for i in p))==5)&all(d>1for d in h(p)))
h=lambda p:[abs(y-x)for x,y in zip(p,p[1:])]
from itertools import*

ลองออนไลน์!

2 ไบต์ขอบคุณไปยังโจนาธาน Frech