Editar: ¡otorgaré una recompensa de 100 reputación por el primer solucionador del rompecabezas de bonificación al final de la pregunta!

Agregaré la recompensa a la pregunta solo cuando aparezca la respuesta, ya que esta recompensa no tiene fecha límite.

Dada una lista no decreciente de enteros positivos de un dígito, debes determinar qué tan profundo cavarán los dígitos.

███  ███  A dungeon with 5 blocks removed and a depth of 3.
███  ███
███ ████
████████

Antes del inicio de la excavación, el suelo está nivelado.

Cada dígito puede eliminar exactamente un bloque de tierra debajo de sí mismo, pero debe alcanzar esa posición desde el exterior de la mazmorra y, después de eliminarlo, el bloque debe abandonar la mazmorra. Al hacerlo, un dígito no puede descender ni ascender más que su valor numérico en ningún paso horizontal.

Los dígitos utilizan la siguiente estrategia para excavar:

• El dígito con el valor más pequeño excava primero y luego el siguiente buscador es siempre el siguiente valor más pequeño del resto de los dígitos.
• El primer dígito puede excavar en cualquier posición. (Todo el terreno es el mismo)
• Los siguientes dígitos siempre cavan en la columna más a la izquierda ya iniciada donde pueden ir y salir. Si no existe tal columna, comienzan a cavar una nueva columna en el lado derecho de la derecha.

Por ejemplo, los dígitos 1 1 1 2 3 3cavarían la siguiente mazmorra (visualización paso a paso con números que marcan qué tipo de dígito cava esa posición):

███1████    ███11███    ███11███    ███11███    ███11███    ███11███
████████    ████████    ███1████    ███1████    ███1████    ███13███
████████    ████████    ████████    ███2████    ███2████    ███2████
████████    ████████    ████████    ████████    ███3████    ███3████
████████    ████████    ████████    ████████    ████████    ████████

Explicación para el ejemplo:

• El segundo 1no podría salir de la única columna disponible si lo profundizara a profundidad para que 2cavara directamente.
• El tercero 1puede cavar en la columna más a la izquierda creando una 2columna profunda ya que puede moverse hacia la 1columna profunda y luego al nivel del suelo.
• El siguiente 2y 3ambos pueden cavar en la columna más a la izquierda.
• El último 3no puede cavar en la columna más a la izquierda, pero puede en la siguiente.

Entrada

• Una lista no decreciente de enteros positivos de un dígito con al menos un elemento.

Salida

• Un solo entero positivo, la profundidad de la mazmorra construida.

Ejemplos

Entrada => Salida (con las profundidades de las columnas de la mazmorra de izquierda a derecha como explicación que no forma parte de la salida)

[3]  =>  1
(column depths are [1])

[1, 1, 1, 2, 3, 3]  =>  4
(column depths are [4, 2])

[1, 1, 1, 1, 1, 1, 1, 1]  =>  3
(column depths are [3, 2, 2, 1])

[1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5]  =>  11
(column depths are [11, 6, 2])

[1, 1, 1, 1, 1, 2, 2, 9, 9, 9]  =>  7
(column depths are [7, 2, 1])

[2, 2, 2, 2, 2, 5, 5, 5, 7, 7, 9]  =>  9
(column depths are [9, 2])

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]  =>  10
(column depths are [10, 5])

[1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 7, 7, 9]  =>  13
(column depths are [13, 5])

[1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]  =>  13
(column depths are [13, 5])

[1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9]  =>  21
(column depths are [21, 12, 3])

Este es el código de golf, por lo que gana la entrada más corta.

Rompecabezas de bonificación

¿Puedes probar (o refutar) que la estrategia descrita en la sección "Los dígitos usan la siguiente estrategia para cavar" siempre ofrece la mazmorra más profunda posible para los dígitos dados?

Pyth, 21 bytes

huXf>+H@GhT@GT0G1Qm0Q

Pruébelo en línea: demostración individual o conjunto de pruebas

Explicación:

                  m0Q   generate a list of zeros of length len(input)
                        This will simulate the current depths
 u               Qm0Q   reduce G, starting with G=[0,...,0], for H in input():
   f          0             find the first number T >= 0, which satisfies:
    >+H@GhT@GT                  H + G[T+1] > G[T]
  X            G1           increase the depth at this position by one
                            update G with this result
h                       print the first element in this list

Java, 199

import java.util.*;a->{List<Integer>l=new ArrayList();l.add(0);int x,y,z=0;s:for(int i:a){for(x=0;x<z;x++)if((y=l.get(x))-l.get(x+1)<i){l.set(x,l.get(x)+1);continue s;}l.add(z++,1);}return l.get(0);}

Versión ampliada y ejecutable

import java.util.*;
class DIGits {
    public static void main(String[] args) {
        java.util.function.Function<int[], Integer> f =
                a->{
                    List<Integer> l = new ArrayList();
                    l.add(0);
                    int x, y, z = 0;
                    s:
                    for (int i : a) {
                        for (x = 0; x < z; x++) {
                            if ((y = l.get(x)) - l.get(x + 1) < i) {
                                l.set(x, l.get(x) + 1);
                                continue s;
                            }
                        }
                        l.add(z++, 1);
                    }
                    return l.get(0);
                };
        System.out.println(f.apply(new int[]{1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 7, 7, 9}));
    }
}