Lieben Sie es, coole Zeitraffer von Konstruktionen oder andere massive Arbeiten in Minuten zu sehen? Machen wir hier einen.
Wir werden uns einen Bagger ansehen, der einen Steinbruch gräbt und jeden Tag Bilder macht, um den gesamten Fortschritt zu sehen. Und Ihre Aufgabe ist es, uns diesen Prozess zu zeigen!

Der Steinbruch wird durch die Breite seiner ersten Schicht definiert.
Der Bagger zeichnet sich durch seine Fähigkeit aus, an einem Tag zu graben.

Eingang

Breite des Steinbruchs. Ganzzahl, immer> = 1.
Baggergrabgeschwindigkeit. Ganzzahl, immer> = 1.

Ausgabe

Fortschritt des Grabens an jedem Tag. Begonnen mit flachem unberührtem Boden und beendet mit fertiggestelltem Steinbruch.

Regeln

• Am letzten Tag müssen möglicherweise weniger Einheiten gegraben werden, als der Bagger kann. Übermäßige Arbeit wird nirgendwo verwendet, daher sollten Sie nur den vollständig ausgegrabenen Steinbruch ausgeben.

• Alle Tagesfortschritte müssen gleichzeitig in der Ausgabe vorhanden sein. Sie können den Fortschritt des vorherigen Tages in der Ausgabe nicht löschen oder überschreiben.

• Nachfolgende und führende Zeilenumbrüche für jede Tagesausgabe sind in einer angemessenen Anzahl zulässig.

• Dies ist Code-Golf , also machen Sie Ihren Code so kompakt wie möglich.

Klarstellungen

Die Arbeit beginnt mit einem ebenen Boden. Die Länge des angezeigten Bodens ist die Breite des Steinbruchs + 2. Auf beiden Seiten des Steinbruchs befindet sich also immer ein Unterstrich.

__________

Der gegrabene Steinbruch sieht für eine gleichmäßige Breite so aus:

_        _      
 \      /
  \    /
   \  /
    \/

Und so für ungerade Breite

_       _      
 \     /
  \   /
   \ /
    V

Hier einige Beispiele für den Fortschritt des Steinbruchs:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Beispiel für vollständigen Fortschritt. Steinbruchbreite: 8. Baggergeschwindigkeit: 4 Einheiten pro Tag.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Eckkästen

Der Bagger muss am letzten Tag genau seine Fähigkeit (Geschwindigkeit) graben.

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

Stax , 65 Bytes

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

Führen Sie es aus und debuggen Sie es

Wenn zuerst die Grabungszeichen berechnet werden, in einer flachen Zeichenfolge. Dann fügt es Tiefe hinzu. Zum Beispiel "_V___"ist ein Tag des Grabens und "_\V/_"ist die fertige flache Schnur.

Diese Methode wird für eine Grabeinheit verwendet.

1. Beginnen Sie mit einem einzelnen "\" plus der entsprechenden Anzahl von "_" Zeichen.
2. Wenn sich "V_" in der Zeichenfolge befindet, ersetzen Sie sie durch "/".
3. Andernfalls, wenn "/ _" in der Zeichenfolge ist, ersetzen Sie es durch "_ /".
4. Andernfalls, wenn "\ _" in der Zeichenfolge ist, ersetzen Sie es durch "\ V".
5. Die neue Zeichenfolge ist das Ergebnis einer Grabeinheit. Wiederholen Sie ab Schritt 2.

Hier ist das gesamte Programm ausgepackt, ungolfed und kommentiert.

'_*'\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

Führen Sie es aus und debuggen Sie es

Retina 0,8,2 , 163 156 Bytes

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

Probieren Sie es online aus! Erläuterung:

.+
$*_

Konvertieren Sie die Eingaben in unär. Das gibt uns W¶S.

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

Vertauschen Sie die Eingaben und duplizieren Sie die Breite. Das gibt uns S¶W¶W.

r`__\G
$%`$&

Berechnen Sie das Volumen des Steinbruchs. Das gibt uns S¶W¶V.

¶
;

Verbinden Sie die Eingaben in einer Zeile. Das gibt uns S;W;V.

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

Berechnen Sie den Fortschritt für jeden Tag in einer eigenen Zeile. Jeder Tag hat das Format S;W;D, in dem Dist 0in der ersten Zeile und Inkrementen von Sjedem Tag , bis es erreicht V.

m`^_+;
__

Löschen Sund Win jeder Zeile um 2 erhöhen . Das gibt uns G;Dfür jeden Tag.

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

Während Des ungleich Null ist, graben Sie entweder Doder G-2aus der Zeile (so dass das erste und das letzte Zeichen immer übrig bleiben) und verschieben Sie die Tiefe in die nächste Zeile. Jede Zeile wird mit einer mehr >als der vorherigen eingerückt . Neu gegrabene Linien enthalten auch a <.

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

Verwandeln Sie den Einzug in Leerzeichen und das Folgende _in a \.

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

Wenn a einem <folgt, \verwandeln Sie es in ein V, wenn es einem folgt, _verwandeln Sie es in ein /. Löschen Sie alle <s und ;s.

Python 2 , 265 Bytes

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

Probieren Sie es online aus!

• Golf im Gange

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

• Fixes Lösungsduo auf Fehler bei ungeraden w (dank @Shaggy) + um 2 Bytes reduzieren
• danke an @Herman Lauenstein für die Reduzierung um 1 Byte

(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}

Probieren Sie es online aus!

Erläuterung

(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}