È necessario scrivere un programma o una funzione che accetta un numero intero non negativo ke un elenco di numeri interi ordinati Lcome input e output o restituisce un elenco smussato M.

Mviene creato dall'elenco crescente Linserendo al massimo kelementi interi mantenendo l'elenco ordinato. Gli interi inseriti devono essere scelti in modo tale che la differenza massima in avanti di Msia il più piccola possibile. Chiameremo questo valore più piccolo "scorrevolezza".

Le differenze in avanti dell'elenco -1 3 8 11 15sono 4 5 3 4e la differenza in avanti massima è 5.

Con 2inserimenti la scorrevolezza di 2 10 15è 4e un possibile output è 2 6 10 11 15con differenze in avanti 4 4 1 4.

Ingresso

• Un numero intero non negativo k.
• Un elenco intero crescente Lcon almeno 2 elementi.

Produzione

• L'elenco intero crescente M.
• Se esistono più risposte corrette, ne viene visualizzata esattamente una (ognuna è sufficiente).
• La tua soluzione deve risolvere qualsiasi caso di test di esempio in meno di un minuto sul mio computer (testerò solo casi chiusi. Ho un PC sotto la media.).

Esempi

Input ( k, L) => Una possibile uscita e la massima differenza diretta (che non fa parte dell'output) tra parentesi

0, 10 20 => 10 20 (10)

2, 1 10 => 1 4 7 10 (3)

2, 2 10 15 => 2 6 10 11 15 (4)

3, 2 10 15 => 2 5 8 10 12 15 (3)

5, 1 21 46 => 1 8 15 21 27 33 39 46 (7)

5, 10 20 25 33 => 10 14 18 20 24 25 29 33 (4)

3, 4 4 6 9 11 11 15 16 25 28 36 37 51 61 => 4 4 6 9 11 11 15 16 22 25 28 36 37 45 51 59 61 (8)

15, 156 888 2015 => 156 269 382 495 608 721 834 888 1001 1114 1227 1340 1453 1566 1679 1792 1905 2015 (113)

8, -399 -35 -13 56 157 => -399 -347 -295 -243 -191 -139 -87 -35 -13 39 56 108 157 (52)

5, 3 3 3 => 3 3 3 3 (0)

Questo è code-golf, quindi vince l'ingresso più breve.

Pyth, 28 27 byte

S+Qu?smt%hHrFdC,QtQ>GvzGhvz

Input dato come:

3
[2, 10, 15]

Dimostrazione. Collaudare l'imbragatura.

Nota: Al momento della domanda, c'era un piccolo bug in Pyth relativo all'uso rFdall'interno u, che ho appena risolto. Il bug rendeva impossibile usarlo Fall'interno u, cosa che sicuramente non era prevista.

S+Qu?smt%hHrFdC,QtQ>GvzGhvz

                               Implicit:
                               z is the number of insertions, in string form.
                               Q is the input list.
              C,QtQ            Pairs of elements, e.g. [(2, 10), (10, 15)]
           rFd                 d = (a, b) -> range(a, b)
        %hH                    Take every H+1th element of that range
       t                       And throw out the first one.
      m                        Perform this process for each element pair
     s                         And combine the results into one list.

                               The above is a minimal set of additional elements
                               To reduce the maximal difference to H+1.

  u                     hvz    Repeat until the result stops changing, where
                               the prior result is G, H starts at 0 and
                               increases by 1 each repetition, and
                               G is initialized to eval(z)+1.
   ?               >GvzG       If not G[eval(z):], return G. In other words,
                               if the prior result was short enough, stop.
                               Also, this is always false on the initial call.
    smt%hHrFdC,QtQ             Otherwise, recalculate with H incremented.
S+Q                            Take the result, add the original list, and sort.

Ecco una versione che avrebbe funzionato con l'interprete al momento della domanda. Ha 28 byte e funziona esattamente allo stesso modo:

S+Qu?smt%hHr.udC,QtQ>GvzGhvz

Dimostrazione.

Git commit della versione appropriata, f6b40e62

Python 2, 104

def f(L,k,d=1):
 M=[];p=L[0]
 for x in L:M+=range(p+d,x,d);p=x
 return M[k:]and f(L,k,d+1)or sorted(L+M)

Prova diversi incrementi massimi d, partendo da 1 e contando. Riempie gli spazi vuoti di ogni coppia (p,x)di elementi successivi prendendo ogni dnumero nel divario. Se Mè maggiore della quota consentita, gli infermieri devono provare un valore più alto d. Altrimenti, restituisce un elenco degli elementi aggiunti e originali, ordinati.

Questo fa senza indugio tutti i casi di test sulla mia macchina.