Bạn có thích xem các khung thời gian tuyệt vời của các công trình hoặc công việc đồ sộ khác được thực hiện trong vài phút không? Hãy làm cho một ở đây.
Chúng tôi sẽ xem xét một máy đào đào mỏ, làm cho hình ảnh mỗi ngày để xem toàn bộ tiến độ. Và nhiệm vụ của bạn là chỉ cho chúng tôi quá trình này!

Mỏ đá được xác định bởi chiều rộng của lớp đầu tiên của nó.
Máy đào được xác định bởi khả năng đào trong một ngày.

Đầu vào

Chiều rộng của mỏ đá. Số nguyên, luôn luôn> = 1.
Tốc độ đào máy đào. Số nguyên, luôn luôn> = 1.

Đầu ra

Tiến độ đào mỏ mỗi ngày. Bắt đầu với mặt đất bằng phẳng và hoàn thành với mỏ đá hoàn thành.

Quy tắc

• Vào ngày cuối cùng có thể có ít đơn vị để đào, hơn máy đào có khả năng. Công việc quá mức sẽ không được sử dụng ở bất cứ đâu, vì vậy bạn chỉ nên xuất khai thác hoàn toàn.

• Tất cả tiến độ ngày phải có mặt trong đầu ra cùng một lúc. Bạn không thể xóa hoặc ghi đè tiến trình ngày trước trong đầu ra.

• Trailing và hàng đầu mới cho đầu ra mỗi ngày được chấp nhận trong bất kỳ số lượng hợp lý.

• Đây là môn đánh gôn , vì vậy hãy làm cho mã của bạn nhỏ gọn nhất có thể.

Làm rõ

Công việc bắt đầu với một mặt đất bằng phẳng. Chiều dài của mặt đất được hiển thị là chiều rộng của mỏ đá + 2. Vì vậy, sẽ luôn có một ký tự gạch dưới ở cả hai phía của mỏ đá.

__________

Mỏ đá đào trông như thế này cho chiều rộng thậm chí:

_        _      
 \      /
  \    /
   \  /
    \/

Và như thế này cho chiều rộng lẻ

_       _      
 \     /
  \   /
   \ /
    V

Dưới đây là ví dụ về tiến độ khai thác:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Ví dụ tiến độ đầy đủ. Chiều rộng mỏ đá: 8. Tốc độ máy đào: 4 chiếc mỗi ngày.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Cornercase

Máy đào sẽ cần đào vào ngày cuối cùng chính xác khả năng (tốc độ) của nó

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

Chạy và gỡ lỗi nó

Nếu lần đầu tiên tính toán các ký tự đào, trong một chuỗi phẳng. Sau đó, nó thêm chiều sâu. Ví dụ, "_V___"một ngày đào, và "_\V/_"là chuỗi phẳng hoàn thành.

Nó sử dụng phương pháp này để thực hiện một đơn vị đào.

1. Bắt đầu bằng một "\", cộng với số ký tự "_" thích hợp.
2. Nếu "V_" nằm trong chuỗi, thay thế nó bằng "/".
3. Mặt khác, nếu "/ _" nằm trong chuỗi, thay thế nó bằng "_ /".
4. Mặt khác, nếu "\ _" nằm trong chuỗi, hãy thay thế nó bằng "\ V".
5. Chuỗi mới là kết quả từ một đơn vị đào. Lặp lại từ bước 2.

Đây là toàn bộ chương trình được giải nén, không ghi chú và nhận xét.

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

Chạy và gỡ lỗi nó

Võng mạc 0.8.2 , 163 156 byte

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

Hãy thử trực tuyến! Giải trình:

.+
$*_

Chuyển đổi các đầu vào để unary. Điều này cho chúng ta W¶S.

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

Hoán đổi đầu vào và nhân đôi chiều rộng. Điều này cho chúng ta S¶W¶W.

r`__\G
$%`$&

Tính thể tích mỏ đá. Điều này cho chúng ta S¶W¶V.

¶
;

Tham gia đầu vào thành một dòng. Điều này cho chúng ta S;W;V.

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

Tính số lượng tiến độ cho mỗi ngày trên dòng riêng của mình. Mỗi ngày có định dạng S;W;D, nơi Dlà 0trên dòng đầu tiên và gia tăng bằng cách Smỗi ngày cho đến khi nó đạt đến V.

m`^_+;
__

Xóa Svà tăng W2 trên mỗi dòng. Điều này cho chúng ta G;Dmỗi ngày.

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

Trong khi Dlà khác không, hãy đào Dhoặc G-2từ dòng (vì vậy các ký tự đầu tiên và cuối cùng luôn luôn ở bên trái), di chuyển độ sâu sang dòng tiếp theo. Mỗi dòng được thụt vào với một hơn >so với trước đó. Dòng đào mới cũng bao gồm a <.

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

Biến thụt vào không gian và sau đây _thành a \.

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

Nếu a <đang theo a \thì biến nó thành a V, nếu nó theo a _thì biến nó thành a /. Xóa tất cả các <s và ;s.

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

Hãy thử trực tuyến!

• chơi gôn

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

• đã sửa lỗi bộ đôi giải pháp thành lỗi trên w lẻ (nhờ @Shaggy) + giảm 2 byte
• cảm ơn @Herman Lauenstein vì đã giảm 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}

Hãy thử trực tuyến!

Giải trình

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