Você gosta de assistir timelapses legais de construções ou outro trabalho maciço feito em minutos? Vamos fazer um aqui.
Estaremos olhando para uma pedreira de escavadeira, tirando fotos todos os dias para ver todo o progresso. E sua tarefa é nos mostrar esse processo!

A pedreira é definida pela largura da sua primeira camada.
A escavadeira é definida por sua capacidade de escavar em um dia.

Entrada

Largura da pedreira. Número inteiro, sempre> = 1.
Velocidade de escavação da escavadeira. Número inteiro, sempre> = 1.

Resultado

Progresso da escavação em cada dia. Começou com terreno plano intocado e terminou com pedreira concluída.

Regras

• No último dia, pode haver menos unidades para escavar do que a escavadeira é capaz. O trabalho excessivo não será usado em nenhum lugar; portanto, você deve produzir uma pedreira totalmente escavada.

• Todos os dias o progresso deve estar presente na saída de uma só vez. Você não pode limpar ou substituir o progresso do dia anterior na saída.

• Novas linhas à direita e à direita para cada saída do dia são aceitáveis ​​em qualquer número razoável.

• Isso é código-golfe , então faça seu código o mais compacto possível.

Esclarecimentos

O trabalho começa com um terreno plano. O comprimento do solo exibido é a largura da pedreira + 2. Portanto, sempre haverá um caractere sublinhado nos dois lados da pedreira.

__________

A pedreira escavada fica assim com largura uniforme:

_        _      
 \      /
  \    /
   \  /
    \/

E assim para largura ímpar

_       _      
 \     /
  \   /
   \ /
    V

Aqui estão exemplos de progresso da pedreira:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Exemplo de progresso completo. Largura da pedreira: 8. Velocidade da máquina escavadora: 4 unidades por dia.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Cornercases

A escavadeira precisará cavar no último dia exatamente sua capacidade (velocidade)

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

Execute e depure

Se primeiro calcular os caracteres de digitação, em uma sequência simples. Depois, adiciona profundidade. Por exemplo, "_V___"é um dia de escavação e "_\V/_"é a sequência plana concluída.

Ele usa esse método para fazer uma unidade de escavação.

1. Comece com um único "\", mais o número apropriado de caracteres "_".
2. Se "V_" estiver na cadeia, substitua-o por "/".
3. Caso contrário, se "/ _" estiver na cadeia, substitua-o por "_ /".
4. Caso contrário, se "\ _" estiver na cadeia, substitua-o por "\ V".
5. A nova string é o resultado de uma unidade de escavação. Repita da etapa 2.

Aqui está o programa inteiro descompactado, não destruído e comentado.

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

Execute e depure

Retina 0.8.2 , 163 156 bytes

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

Experimente online! Explicação:

.+
$*_

Converta as entradas para unárias. Isso nos dá W¶S.

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

Troque as entradas e duplique a largura. Isso nos dá S¶W¶W.

r`__\G
$%`$&

Calcule o volume da pedreira. Isso nos dá S¶W¶V.

¶
;

Junte as entradas em uma linha. Isso nos dá S;W;V.

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

Calcule a quantidade de progresso para cada dia em sua própria linha. Cada dia tem o formato S;W;D, onde Destá 0a primeira linha e incrementa a Scada dia até chegar V.

m`^_+;
__

Exclua Se aumente Wem 2 em cada linha. Isso nos dá G;Dpara cada dia.

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

Enquanto Dfor diferente de zero, cave Dou a G-2partir da linha (para que o primeiro e o último caracteres sejam sempre deixados), movendo a profundidade para a próxima linha. Cada linha é recuada com uma mais >que a anterior. As linhas recentemente cavadas também incluem a <.

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

Transforme o recuo em espaços e o seguinte _em a \.

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

Se a <estiver seguindo a, \então transforme-o em a V, se estiver seguindo a, _então transforme-o em a /. Exclua todos os <s e ;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

Experimente online!

• golfe em andamento

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

• solução dupla corrigida para erro no w ímpar (graças a @Shaggy) + redução de 2 bytes
• graças a @Herman Lauenstein por reduzir em 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}

Experimente online!

Explicação

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