Lavoro in una panetteria che serve pane di frumento, segale, orzo, grano e francese, ma il fornaio è un po 'strano: impila i pani in ordine casuale e a volte lascia vuoti alcuni scaffali alla fine.

Ogni giorno arriva lo stesso cliente e chiede uno di ogni pezzo di pane, ma la cosa difficile è che è un germofobo, quindi quando riempio la sua borsa, non posso prendere pagnotte da due scaffali adiacenti in selezioni consecutive.

Ci vuole un secondo per camminare tra gli scaffali adiacenti. È un negozio affollato; per qualsiasi configurazione casuale di pagnotte, vorrei ridurre al minimo il tempo necessario per ottenere una di ogni pagnotta unica. Posso iniziare e finire in qualsiasi scaffale.

Se l'ordinamento odierno è W B W G F R W, un possibile percorso è 0, 3, 5, 1, 4, per un totale di 12 secondi:abs(3-0) + abs(5-3) + abs(1-5) + abs(4-1) = 12

( 1, 2, 3, 4, 5non funziona, perché il pane viene raccolto consecutivamente dagli scaffali adiacenti.)

Se lo è B W B G B F B R B W B F, un possibile percorso è 1, 3, 5, 7, 10, per un totale di 9 secondi.

Il gestore si assicura sempre che ci sia una possibile soluzione, quindi non devo preoccuparmi di rilevare input errati. Di solito mi invia l'ordine in un file, ma se voglio, posso scriverlo su STDIN o leggerlo in un modo diverso. Vorrei che il programma stampasse gli indici del percorso migliore, così come il suo tempo, secondo le regole di I / O predefinite .

In breve:

1. 5 tipi di pane.
2. Gli ordini di pagnotta vengono visualizzati come stringhe di ordine casuale e lunghezza.
3. Devi selezionare uno di ciascun pane unico.
4. Impossibile effettuare selezioni consecutive adiacenti.
5. Ridurre al minimo la distanza tra gli indici di selezione.
6. Non è necessario preoccuparsi di input non validi.
7. Si applicano le regole I / O predefinite .

Questo è code-golf , vince il conteggio dei byte più corto.

JavaScript (ES6), 114 byte

Salvato 1 byte grazie a @Oliver

Accetta input come una matrice di caratteri. Emette una stringa separata da virgola in cui il primo valore è il tempo totale e quelli successivi descrivono il percorso.

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)``

Provalo online!

Commentate

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 byte

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*

Provalo online!

2 byte grazie a Jonathan Frech .