멋진 건축 시간의 경과 또는 몇 분 안에 완료된 다른 대규모 작업을보고 싶습니까? 여기서 하나 만들어 보자.
우리는 굴착기 파고 채석장을 보면서 매일 모든 그림을 보면서 진행 상황을 볼 것입니다. 그리고 당신의 임무는 우리에게이 과정을 보여주는 것입니다!

채석장은 첫 번째 레이어의 너비로 정의됩니다.
굴삭기는 하루 만에 파는 기능으로 정의됩니다.

입력

채석장의 너비. 정수는 항상> = 1입니다.
굴삭기 발굴 속도. 정수는 항상> = 1입니다.

산출

매일 파는 채석장의 진행 상황. 평평한 손길이 닿지 않은 땅에서 시작하여 채석장을 완성했습니다.

규칙

• 마지막 날에는 굴착기가 할 수있는 것보다 파는 단위가 적을 수 있습니다. 과도한 작업은 어느 곳에서도 사용되지 않으므로 완전히 파낸 채석장을 출력해야합니다.

• 모든 일 진행 상황이 한 번에 출력에 있어야합니다. 출력에서 전날 진행률을 지우거나 덮어 쓸 수 없습니다.

• 매일 출력에 대한 후행 및 선행 줄 바꿈은 합리적인 수로 허용됩니다.

• 이것은 code-golf 이므로 가능한 한 코드를 작게 만드십시오.

설명

작업은 평평한 땅에서 시작합니다. 표시된지면의 길이는 채석장 너비 + 2입니다. 따라서 채석장 양쪽에는 항상 하나의 밑줄 문자가 있습니다.

__________

파고 채석장은 너비가 다음과 같이 보입니다.

_        _      
 \      /
  \    /
   \  /
    \/

홀수 너비의 경우 이와 같이

_       _      
 \     /
  \   /
   \ /
    V

다음은 채석 과정의 예입니다.

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

전체 진행 예. 채석장 폭 : 8. 굴삭기 속도 : 하루 4 대.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

코너 케이스

굴삭기는 마지막 날에 정확히 그 능력 (속도)을 파야합니다.

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

Stax , 65 바이트

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

실행 및 디버깅

먼저 파고 문자를 하나의 플랫 문자열로 계산합니다. 그런 다음 깊이를 추가합니다. 예를 들어 "_V___", 파는 하루이며 "_\V/_"완성 된 플랫 스트링입니다.

한 단위의 파기를 수행하기 위해이 방법을 사용합니다.

1. 단일 "\"와 적절한 수의 "_"문자로 시작하십시오.
2. 문자열에 "V_"가 있으면 "/"로 바꾸십시오.
3. 그렇지 않으면 문자열에 "/ _"가 있으면 "_ /"로 바꾸십시오.
4. 그렇지 않으면 문자열에 "\ _"가 있으면 "\ V"로 바꾸십시오.
5. 새로운 스트링은 한 단위의 굴착 결과입니다. 2 단계부터 반복하십시오.

다음은 전체 프로그램의 압축을 풀고 압축을 풀고 주석을 달았습니다.

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

실행 및 디버깅

망막 0.8.2 , 163 156 바이트

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

온라인으로 사용해보십시오! 설명:

.+
$*_

입력을 단항으로 변환하십시오. 이것은 우리에게 제공합니다 W¶S.

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

입력을 바꾸고 너비를 복제하십시오. 이것은 우리에게 제공합니다 S¶W¶W.

r`__\G
$%`$&

채석장의 부피를 계산하십시오. 이것은 우리에게 제공합니다 S¶W¶V.

¶
;

입력을 한 줄로 결합하십시오. 이것은 우리에게 제공합니다 S;W;V.

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

자체 라인에서 매일 진행률을 계산하십시오. 매일 포맷을 갖는 S;W;D경우에, D인 0에 의해 제 라인 단위에 S그 때까지 매일 V.

m`^_+;
__

각 줄에서 삭제 S하고 W2 씩 증가시킵니다 . 이것은 G;D매일 우리 를 제공합니다 .

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

반면 D중 0이 아닌 발굴이다 D또는 G-2다음 행으로 깊이 이동 (첫 번째와 마지막 문자는 항상 왼쪽되도록) 라인에서. 각 줄은 >이전 줄 보다 들여 쓰기됩니다 . 새로 파는 라인도 포함합니다 <.

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

들여 쓰기를 공백 _으로 바꾸고 다음을 로 바꿉니다 \.

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

a <가 뒤에 오는 경우 a \로 바꾸고, a V뒤에 있으면 a _로 바꾸십시오 /. 모든 <s와 ;s를 삭제하십시오 .

파이썬 2 , 265 바이트

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

온라인으로 사용해보십시오!

• 진행중인 골프

자바 스크립트 (Node.js를) , 329 (315) 307 300 301 298 285 275 260 254 바이트

• 홀수 w (@Shaggy 덕분에) + 2 바이트 감소시 오류 해결 솔루션 듀오
• 1 바이트 씩 줄인 @Herman Lauenstein 덕분에

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

온라인으로 사용해보십시오!

설명

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