Вы должны написать программу или функцию, которая принимает неотрицательное целое число kи отсортированный список целых чисел в Lкачестве входных данных и выводит или возвращает сглаженный список M.

Mсоздается из восходящего списка L, вставляя не более kцелых элементов, сохраняя список отсортированным. Вставленные целые числа должны быть выбраны таким образом, чтобы максимальная разность вперед Mбыла настолько малой, насколько это возможно. Мы будем называть это наименьшее значение «гладкостью».

Прогнозные различия в списке -1 3 8 11 15являются 4 5 3 4и максимальной вперед разница есть 5.

С 2вставками гладкость 2 10 15IS 4и возможный выход 2 6 10 11 15с форвардным различиями 4 4 1 4.

вход

• Неотрицательное целое число k.
• Восходящий список целых чисел, Lпо крайней мере, с 2 элементами.

Выход

• Восходящий список целых чисел M.
• Если существует несколько правильных ответов, выведите ровно один из них (достаточно одного).
• Ваше решение должно разрешить любой пример теста менее чем за минуту на моем компьютере (я буду тестировать только закрытые случаи. У меня компьютер ниже среднего.)

Примеры

Input ( k, L) => Возможный вывод и максимальная прямая разница (которая не является частью вывода) в скобках

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)

Это код-гольф, поэтому выигрывает самый короткий вход.

Pyth, 28 27 байтов

S+Qu?smt%hHrFdC,QtQ>GvzGhvz

Ввод дан как:

3
[2, 10, 15]

Демонстрация. Тестовый жгут.

Примечание: в то время, когда был задан вопрос, в Pyth была небольшая ошибка, связанная с использованием rFdinside u, которую я только что исправил. Ошибка сделала невозможным использование Fвнутри u, что определенно не было предназначено.

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.

Вот версия, которая работала бы с переводчиком в момент, когда был задан вопрос. Это 28 байтов, и работает точно так же:

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

Демонстрация.

Git commit соответствующей версии, 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)

Пытается разные максимальные приращения d, начиная с 1 и считая. Заполняет пропуски каждой пары (p,x)последовательных элементов, беря каждое dчисло в пропуске. Если Mэто больше, чем позволяет квота, рекурсоры пытаются увеличить d. В противном случае возвращает список добавленных и исходных элементов, отсортированный.

Это делает все тесты без задержки на моей машине.