Вы любите смотреть классные интервальные съемки конструкций или другую огромную работу, выполненную за несколько минут? Давайте сделаем один здесь.
Мы будем смотреть на экскаваторный карьер, делая фотографии каждый день, чтобы увидеть весь прогресс. И ваша задача показать нам этот процесс!

Карьер определяется шириной его первого слоя.
Экскаватор определяется его способностью копать за один день.

вход

Ширина карьера. Целое число, всегда> = 1.
Скорость копания экскаватора. Целое число, всегда> = 1.

Выход

Прогресс рытья карьера на каждый день. Начинали с ровной нетронутой земли и заканчивали законченным карьером.

правила

• В последний день может выкопаться меньше единиц, чем способен экскаватор. Чрезмерная работа нигде не будет использована, поэтому вы должны просто вывести полностью вырытый карьер.

• Прогресс всех дней должен присутствовать в выходных данных одновременно. Вы не можете очистить или перезаписать прогресс предыдущего дня в выходных данных.

• Трейлинг и ведущие новые строки для каждого выходного дня допустимы в любом разумном количестве.

• Это код-гольф , поэтому сделайте ваш код максимально компактным.

Разъяснения

Работа начинается с ровной площадки. Длина отображаемой земли равна ширине карьера + 2. Таким образом, всегда будет один символ подчеркивания с обеих сторон карьера.

__________

Выкопанный карьер выглядит примерно так:

_        _      
 \      /
  \    /
   \  /
    \/

И как это для нечетной ширины

_       _      
 \     /
  \   /
   \ /
    V

Вот примеры развития карьера:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Полный пример прогресса. Ширина карьера: 8. Скорость экскаватора: 4 единицы в сутки.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Cornercases

Экскаватор должен будет в последний день копать именно его возможности (скорость)

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и увеличить Wна 2 в каждой строке. Это дает нам G;Dна каждый день.

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

Пока не Dравен нулю, либо рыть Dили G-2от линии (так что первые и последние символы всегда остаются), перемещая глубину к следующей строке. Каждая строка имеет отступ на одну единицу больше >предыдущей. Недавно вырытые линии также включают <.

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

Превратить отступ в пробелы, а следующие _в \.

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

Если a <следует за a, \превратите его в a V, если он следует за a, _затем превратите его в a /. Удалить все <s и ;s.

Python 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

Попробуйте онлайн!

• гольф в прогресс

JavaScript (Node.js) , 329 315 307 300 301 298 285 275 260 254 байта

• исправлен дуэт решения с ошибкой на нечетном w (благодаря @Shaggy) + уменьшение на 2 байта
• спасибо @Herman Lauenstein за сокращение на 1 байт

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