Edit: je vais attribuer une prime de 100 points de réputation pour le premier résolveur du puzzle bonus à la fin de la question!

J'ajouterai la prime à la question uniquement lorsque la réponse apparaîtra car cette prime n'a pas de date limite.

Étant donné une liste non décroissante d'entiers positifs à un chiffre, vous devez déterminer à quelle profondeur le donjon creusera les chiffres.

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

Avant le début du creusement, le sol est de niveau.

Chaque chiffre peut retirer exactement un bloc de terre en dessous de lui-même, mais il doit atteindre cette position depuis l'extérieur du donjon et après avoir retiré le bloc, il doit quitter le donjon. Ce faisant, un chiffre ne peut pas descendre ou monter plus que sa valeur numérique à un pas horizontal.

Les chiffres utilisent la stratégie suivante pour creuser:

• Le chiffre avec la plus petite valeur creuse en premier et après cela, le digger suivant est toujours la prochaine valeur la plus petite du reste des chiffres.
• Le premier chiffre peut creuser à n'importe quelle position. (Tout le terrain est le même.)
• Les chiffres suivants creusent toujours dans la colonne déjà commencée la plus à gauche où ils peuvent aller et sortir. Si une telle colonne n'existe pas, ils commencent à creuser une nouvelle colonne sur le côté droit de la plus à droite.

Par exemple, les chiffres 1 1 1 2 3 3creuseraient le donjon suivant (visualisation étape par étape avec des chiffres indiquant quel type de chiffre déterrer cette position):

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

Explication de l'exemple:

• Le second 1ne pourrait pas sortir de la seule colonne disponible s'il l'approfondissait jusqu'à 2-de profondeur pour qu'il y creuse directement.
• Le troisième 1peut creuser dans la colonne la plus à gauche en créant une 2colonne -deep car il peut se déplacer dans la 1colonne -deep puis au niveau du sol.
• Le suivant 2et les 3deux peuvent creuser dans la colonne la plus à gauche.
• Le dernier 3ne peut pas creuser dans la colonne la plus à gauche mais peut le faire dans la suivante.

Contribution

• Une liste non décroissante d'entiers positifs à un chiffre avec au moins un élément.

Production

• Un seul entier positif, la profondeur du donjon construit.

Exemples

Entrée => Sortie (avec les profondeurs des colonnes du donjon de gauche à droite comme explication qui ne fait pas partie de la sortie)

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

Il s'agit de code-golf, donc l'entrée la plus courte l'emporte.

Puzzle bonus

Pouvez-vous prouver (ou réfuter) que la stratégie décrite dans la section "Les chiffres utilisent la stratégie suivante pour creuser" donne toujours le donjon le plus profond possible pour les chiffres donnés?

Pyth, 21 octets

huXf>+H@GhT@GT0G1Qm0Q

Essayez-le en ligne: démonstration unique ou suite de tests

Explication:

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

Version étendue et exécutable

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