Aimez-vous regarder des timelapses cool de constructions ou d'autres travaux massifs effectués en quelques minutes? Permet d'en faire un ici.
Nous allons regarder une excavatrice creuser une carrière, faire des photos chaque jour pour voir l'ensemble des progrès. Et votre tâche est de nous montrer ce processus!

La carrière est définie par la largeur de sa première couche.
L'excavatrice est définie par sa capacité à creuser en une journée.

Contribution

Largeur de carrière. Nombre entier, toujours> = 1.
Vitesse d'excavation de la pelle. Nombre entier, toujours> = 1.

Production

Progression du creusement de carrière chaque jour. Commencé avec un sol plat et intact et terminé avec une carrière terminée.

Règles

• Le dernier jour, il peut y avoir moins d'unités à creuser que ne peut en faire l'excavatrice. Un travail excessif ne sera utilisé nulle part, vous devez donc simplement extraire la carrière entièrement creusée.

• La progression de tous les jours doit être présente dans la sortie à la fois. Vous ne pouvez pas effacer ou écraser la progression de la veille dans la sortie.

• Les sauts de ligne de fin et de tête pour chaque sortie journalière sont acceptables en tout nombre raisonnable.

• Il s'agit de code-golf , alors rendez votre code aussi compact que possible.

Clarifications

Le travail commence par un terrain plat. La longueur du terrain affiché est la largeur de la carrière + 2. Il y aura donc toujours un caractère de soulignement des deux côtés de la carrière.

__________

La carrière de Dug ressemble à ceci pour une largeur uniforme:

_        _      
 \      /
  \    /
   \  /
    \/

Et comme ça pour une largeur impaire

_       _      
 \     /
  \   /
   \ /
    V

Voici des exemples de progression de carrière:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Exemple de progression complète. Largeur de carrière: 8. Vitesse d'excavatrice: 4 unités par jour.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Cornercases

La pelle devra creuser le dernier jour exactement sa capacité (vitesse)

Width: 7, Speed: 3
Width: 10, Speed: 4 

Stax , 65 octets

Θ└R4∞√4Fµ■zJ┐╚▌▼ZJ╧fφ½à╘▲☼å♥s≥┤ÖòOúU╬ΩmPê|ë↕ƒ].Y┴↓á÷>}St☺┐B╒╞O☼╧O

Exécuter et déboguer

Si calcule d'abord les caractères de fouille, dans une chaîne plate. Ensuite, cela ajoute de la profondeur. Par exemple, "_V___"c'est un jour de fouille, et "_\V/_"c'est la chaîne plate terminée.

Il utilise cette méthode pour effectuer une unité de creusement.

1. Commencez par un seul "\", plus le nombre approprié de caractères "_".
2. Si "V_" est dans la chaîne, remplacez-le par "/".
3. Sinon, si "/ _" est dans la chaîne, remplacez-le par "_ /".
4. Sinon, si "\ _" est dans la chaîne, remplacez-le par "\ V".
5. La nouvelle chaîne est le résultat d'une unité de fouille. Répétez à partir de l'étape 2.

Voici le programme entier décompressé, non golfé et commenté.

'_*'\s+                 initial string e.g. "\_______"
{                       generator block to get each day's flat digging results
  {                     block to repeat digging within each day
    "V_\//__/\_\V"4/    replacement strings
    {[2:/|em|!H         find the first substring that exists and do replacement
  };*                   repeat digging within day specified number of times
gu                      get all unique results
                            when digging is complete, the result duplicates
{Dm                     drop the leading "\" characters from each result
F                       for each day's flat result, execute the rest of the program
  '_|S                  surround with "_"
  M                     split into chars; e.g. ["_", "\", "/", "_"]
  c|[                   copy and get all prefixes
  {                     mapping block to get "depth" of each character
    '\#                 get number of backslashes in this prefix (A)
    _1T'/#-             get number of forward slashes prior to last character of prefix (B)
    'V_H=+^             is the current character "V"? 1 for yes. (C)
  m                     map prefixes to A - B + C + 1
  \                     zip depths with original characters
  {E)m                  prefix each character with spaces; e.g. ["_", " \", " /", "_"]
  M                     transpose grid; e.g. ["_  _", " \/ "]
  m                     print each row

Exécuter et déboguer

Rétine 0,8,2 , 163156 octets

.+
$*_
(_+)¶(_+)
$2¶$1¶$1
r`__\G
$%`$&
¶
;
(?<=(_+);.*)(?<=;_+;\1*)_
¶$`_
m`^_+;
__
+`(>*)_(_+)(_+<?;)\2
$1_$.2$* $3¶$1>$2<;
T`>\_` \\`>+_
T`\\\_;<`V/_`.<|;

Essayez-le en ligne! Explication:

.+
$*_

Convertissez les entrées en unaire. Cela nous donne W¶S.

(_+)¶(_+)
$2¶$1¶$1

Échangez les entrées et dupliquez la largeur. Cela nous donne S¶W¶W.

r`__\G
$%`$&

Calculez le volume de la carrière. Cela nous donne S¶W¶V.

¶
;

Joignez les entrées sur une seule ligne. Cela nous donne S;W;V.

(?<=(_+);.*)(?<=;_+;\1*)_
¶$`_

Calculez la quantité de progrès pour chaque jour sur sa propre ligne. Chaque jour a le format S;W;D, où Dest 0sur la première ligne et incrémente de Schaque jour jusqu'à ce qu'il atteigne V.

m`^_+;
__

Supprimez Set augmentez Wde 2 sur chaque ligne. Cela nous donne G;Dpour chaque jour.

+`(>*)_(_+)(_+<?;)\2
$1_$.2$* $3¶$1>$2<;

Tout en Dest non nulle, creuser soit Dou G-2de la ligne ( de sorte que les premiers et derniers caractères sont toujours à gauche), le déplacement de la profondeur à la ligne suivante. Chaque ligne est indentée d'une de plus >que la précédente. Les lignes nouvellement creusées comprennent également a <.

T`>\_` \\`>+_

Transformez le retrait en espaces et les suivants _en a \.

T`\\\_;<`V/_`.<|;

Si a <suit a, \transformez-le en a V, s'il suit a, _transformez-le en a /. Supprimer tous les <s et ;s.

Python 2 , 265 octets

w,s=input();R=range((3+w)/2)
d=0
while d-s<sum(range(w%2,w+1,2)):
 q=[[' _'[i<1]]*(w+2)for i in R];D=d
 for i in R[:-1]:
  a=min(D,w-i*2);D-=a
  if a:q[i][1+i:1+i+a]=[' ']*a;q[i+1][1+i:1+i+a]=(['\\']+['_']*(a-2)+['/'])*(a>1)or['v']
 for l in q:print''.join(l)
 d+=s

Essayez-le en ligne!

• golf en cours

JavaScript (Node.js) , 329 315 307 300 301 298 285 275 260 254 octets

• correction duo de solution à erreur sur w impair (grâce à @Shaggy) + réduction de 2 octets
• merci à @Herman Lauenstein pour avoir réduit de 1 octet

(w,s)=>{h=[...Array(-~w/2+1|0)].map((x,i)=>[...(i?" ":"_").repeat(w)])
for(t=S="";t<s&&h.map((x,i)=>S+=(p=i?" ":"_")+x.join``+p+`
`);)for(y in t=s,h)for(x in D=h[y])if(D[x]=="_"&&t){(d=h[-~y])[x]=x^y?(d[x-1]=x^-~y?"_":"\\","/"):"v"
D[x]=" "
t--}return S}

Essayez-le en ligne!

Explication

(w,s)=>{
h=[...Array(-~w/2+1|0)]                       //the height of the quarry when finished is w/2+1 if even or (w+1)/2+1 if odd
.map((x,i)=>                                  
    [...(i?" ":"_").repeat(w)]                //the first row is the _ w times (i will explain why w and not w+2 in the following lines) afterwards lets just fill with spaces so the output would be clear(when convertion to string)
    )                                         
for(t=S="";                                   //t="" is like t=0(we actually need t to be different from s in the start and s>=1), S will hold the final output
t^s&&                                         //if t not equals s -> it means that now changes were made to the quarry->it means we finished digging
h.map((x,i)=>                                 
S+=(p=i?" ":"_")+x.join``+p+`                 //here comes the reason for w and not w+2. because the border _XXXX_ are not to be touched i only add them to the output and not woking with them in the solution
                                              //that ways its much easier to replace the correct chars. so here i just add _ to either sides if its the first row otherwise space(to pad correctly).
                                              //in the end i add a new line to differ from the previous day
`);)
    for(y in t=s,h)                           //always update t back to s so we know weve passed a day
        for(x in D=h[y])
            if(D[x]=="_"&&t)                  //if the current cell is _ we need to work, but only if the day have yet to pass(t)
            {
                (d=h[-~y])[x]=                //updating the row below us because we just dug a hole
                x^y?                          //if x == y that means we are digging the first hole in the row below
                (d[x-1]=x^-~y?"_":"\\", //we want to update the row below and cell before([y+1][x-1]) only if its not the first cell(AKA not space). if v we need \ other wise _
                    "/")                          //other wise (x!=y) we put "/"
                :"v"                          //so we should put v (if they are equal)
                D[x]=" "                      //always remove the _ from the current one because we dug it
                t--}                          //decrement the counter for the day by one digging
return S}