Apakah Anda suka menonton garis waktu keren konstruksi atau pekerjaan besar lainnya yang dilakukan dalam hitungan menit? Mari kita buat satu di sini.
Kami akan melihat penggalian penggalian, membuat gambar setiap hari untuk melihat seluruh kemajuan. Dan tugas Anda adalah menunjukkan kepada kami proses ini!

Tambang didefinisikan oleh lebar lapisan pertama.
Excavator ditentukan oleh kemampuannya untuk menggali dalam satu hari.

Memasukkan

Lebar tambang. Angka integer, selalu> = 1.
Kecepatan penggalian excavator. Angka integer, selalu> = 1.

Keluaran

Kemajuan menggali tambang setiap hari. Dimulai dengan tanah datar yang belum tersentuh dan selesai dengan penambangan yang lengkap.

Aturan

• Pada hari terakhir mungkin ada lebih sedikit unit untuk digali, daripada yang mampu digali oleh excavator. Pekerjaan yang berlebihan tidak akan digunakan di mana pun, jadi Anda harus mengeluarkan tambang yang digali sepenuhnya.

• Semua hari kemajuan harus hadir dalam output sekaligus. Anda tidak dapat menghapus atau menimpa kemajuan hari sebelumnya di output.

• Mengejar dan memimpin baris baru untuk setiap hari dapat diterima dalam jumlah yang wajar.

• Ini adalah kode-golf , jadi buatlah kode Anda seringkas mungkin.

Klarifikasi

Pekerjaan dimulai dengan tanah datar. Panjang ground yang ditampilkan adalah lebar quarry + 2. Jadi selalu ada satu karakter garis bawah di kedua sisi quarry.

__________

Tambang penggalian terlihat seperti ini untuk lebar genap:

_        _      
 \      /
  \    /
   \  /
    \/

Dan seperti ini untuk lebar ganjil

_       _      
 \     /
  \   /
   \ /
    V

Berikut adalah contoh dari kemajuan penambangan:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Contoh kemajuan penuh. Lebar tambang: 8. Kecepatan excavator: 4 unit per hari.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Cornercases

Excavator perlu menggali pada hari terakhir persis kemampuannya (kecepatan)

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

Stax , 65 byte

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

Jalankan dan debug itu

Jika pertama kali menghitung karakter penggalian, dalam satu string datar. Lalu itu menambah kedalaman. Misalnya "_V___"adalah satu hari penggalian, dan "_\V/_"merupakan string datar yang selesai.

Ini menggunakan metode ini untuk melakukan satu unit penggalian.

1. Mulai dengan satu "\", ditambah jumlah karakter "_" yang sesuai.
2. Jika "V_" ada di string, ganti dengan "/".
3. Kalau tidak, jika "/ _" ada di dalam string, ganti dengan "_ /".
4. Kalau tidak, jika "\ _" ada dalam string, ganti dengan "\ V".
5. String baru adalah hasil dari satu unit penggalian. Ulangi dari langkah 2.

Inilah keseluruhan program yang dibongkar, tidak diserang, dan dikomentari.

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

Jalankan dan debug itu

Retina 0.8.2 , 163 156 byte

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

Cobalah online! Penjelasan:

.+
$*_

Konversikan input ke unary. Ini memberi kita W¶S.

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

Tukar input dan gandakan lebar. Ini memberi kita S¶W¶W.

r`__\G
$%`$&

Hitung volume kuari. Ini memberi kita S¶W¶V.

¶
;

Gabungkan input menjadi satu baris. Ini memberi kita S;W;V.

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

Hitung jumlah kemajuan untuk setiap hari pada jalurnya sendiri. Setiap hari memiliki format S;W;D, di mana Dada 0di baris pertama dan peningkatan Ssetiap hari hingga mencapai V.

m`^_+;
__

Hapus Sdan tambah W2 pada setiap baris. Ini memberi kita G;Dsetiap hari.

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

Sementara Dbukan nol, gali salah satu Datau G-2dari baris (sehingga karakter pertama dan terakhir selalu tersisa), pindahkan kedalaman ke baris berikutnya. Setiap baris diberi indentasi dengan lebih >dari sebelumnya. Garis yang baru digali juga termasuk a <.

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

Ubah indentasi menjadi spasi dan berikut ini _menjadi a \.

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

Jika a <mengikuti a \maka ubah menjadi a V, jika mengikuti a _maka ubah menjadi a /. Hapus semua tanda <dan tanda ;.

Python 2 , 265 byte

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

Cobalah online!

• golf sedang berlangsung

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

• duo solusi tetap untuk kesalahan pada aneh w (terima kasih kepada @Shaggy) + kurangi 2 byte
• terima kasih kepada @Herman Lauenstein untuk mengurangi 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}

Cobalah online!

Penjelasan

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