Modifica: assegnerò una ricompensa di 100 reputazione per il primo risolutore del puzzle bonus alla fine della domanda!

Aggiungerò la generosità alla domanda solo quando appare la risposta poiché questa generosità non ha scadenza.

Dato un elenco non decrescente di numeri interi positivi a una cifra, è necessario determinare la profondità della scavatura delle cifre.

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

Prima dell'inizio dello scavo il terreno è a livello.

Ogni cifra può rimuovere esattamente un blocco di terreno dal basso ma deve raggiungere quella posizione dall'esterno del sotterraneo e dopo aver rimosso il blocco deve lasciare il sotterraneo. Nel fare ciò una cifra non può scendere o salire più del suo valore numerico in nessun passo orizzontale.

Le cifre utilizzano la seguente strategia per scavare:

• La cifra con il valore più piccolo scava i primi e dopo quello il prossimo scavatore è sempre il valore più piccolo successivo dal resto delle cifre.
• La prima cifra può scavare in qualsiasi posizione. (Tutto il terreno è uguale.)
• Le seguenti cifre scavano sempre nella colonna già iniziata all'estrema sinistra, dove possono andare ed uscire. Se tale colonna non esiste, iniziano a scavare una nuova colonna sul lato destro di quella più a destra.

Ad esempio, le cifre 1 1 1 2 3 3scaverebbero il seguente dungeon (visualizzazione dettagliata con numeri che segnano il tipo di cifra che scava quella posizione):

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

Spiegazione per l'esempio:

• Il secondo 1non potrebbe uscire dall'unica colonna disponibile se la approfondisse fino a 2-deep in modo da scavare fino ad essa.
• Il terzo 1può scavare nella colonna più a sinistra creando una 2colonna -deep in quanto può spostarsi nella 1colonna -deep e quindi al livello del suolo.
• Il prossimo 2ed 3entrambi possono scavare nella colonna più a sinistra.
• L'ultimo 3non può scavare nella colonna più a sinistra, ma può nella successiva.

Ingresso

• Un elenco non decrescente di numeri interi a una cifra positivi con almeno un elemento.

Produzione

• Un singolo numero intero positivo, la profondità del dungeon costruito.

Esempi

Input => Output (con la profondità delle colonne del dungeon da sinistra a destra come spiegazione che non fa parte dell'output)

[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])

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

Puzzle bonus

Puoi provare (o confutare) che la strategia descritta nella sezione "Le cifre usano la seguente strategia per scavare" fornisce sempre il dungeon più profondo possibile per le cifre indicate?

Pyth, 21 byte

huXf>+H@GhT@GT0G1Qm0Q

Provalo online: dimostrazione singola o suite di test

Spiegazione:

                  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);}

Versione espandibile e eseguibile

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}));
    }
}