Czy lubisz oglądać fajne timelapsy konstrukcji lub inne masywne prace wykonane w kilka minut? Zróbmy tutaj.
Będziemy patrzeć na koparkę kopiącą kamieniołom, robiąc zdjęcia każdego dnia, aby zobaczyć cały postęp. Twoim zadaniem jest pokazanie nam tego procesu!

Kamieniołom jest definiowany przez szerokość pierwszej warstwy.
Koparka jest definiowana przez jej zdolność do kopania w ciągu jednego dnia.

Wejście

Szerokość kamieniołomu. Liczba całkowita, zawsze> = 1.
Prędkość kopania koparki. Liczba całkowita, zawsze> = 1.

Wynik

Postęp kopania kamieniołomu każdego dnia. Zaczęło się od płaskiej, nietkniętej ziemi i zakończyło zakończonym kamieniołomem.

Zasady

• Ostatniego dnia może być mniej jednostek do wykopania, niż jest w stanie koparka. Nadmiar pracy nie będzie nigdzie używany, więc powinieneś po prostu wysyłać w pełni wykopany kamieniołom.

• Postęp wszystkich dni musi być jednocześnie widoczny na wyjściu. Nie można wyczyścić ani zastąpić postępu z poprzedniego dnia na wyjściu.

• Końcowe i wiodące nowe wiersze dla każdego dnia wyjścia są dopuszczalne w dowolnej rozsądnej liczbie.

• To jest golf golfowy , więc uczyń swój kod tak kompaktowym, jak to możliwe.

Wyjaśnienia

Prace rozpoczynają się od płaskiego podłoża. Długość wyświetlanego gruntu to szerokość kamieniołomu + 2. Dlatego zawsze po obu stronach kamieniołomu będzie jeden znak podkreślenia.

__________

Kopalnia wykopana wygląda tak dla równej szerokości:

_        _      
 \      /
  \    /
   \  /
    \/

I tak dla nieparzystej szerokości

_       _      
 \     /
  \   /
   \ /
    V

Oto przykłady postępu w kamieniołomach:

_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units


_       _
 \   __/    dug 10 units
  \_/

Pełny przykład postępu. Szerokość kamieniołomu: 8. Prędkość koparki: 4 jednostki dziennie.

__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Narożniki

Koparka będzie musiała kopać ostatniego dnia dokładnie jej możliwości (prędkości)

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

Stax , 65 bajtów

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

Uruchom i debuguj

Jeśli najpierw oblicza znaki kopiące, w jednym płaskim ciągu. Następnie dodaje głębi. Na przykład "_V___"jest jeden dzień kopania i "_\V/_"jest to gotowy płaski ciąg.

Wykorzystuje tę metodę do wykonania jednej jednostki kopania.

1. Zacznij od pojedynczego „\” i odpowiedniej liczby znaków „_”.
2. Jeśli „V_” znajduje się w ciągu, zamień go na „/”.
3. W przeciwnym razie, jeśli „/ _” znajduje się w ciągu, zamień go na „_ /”.
4. W przeciwnym razie, jeśli „\ _” znajduje się w ciągu, zamień go na „\ V”.
5. Nowy ciąg jest wynikiem jednej jednostki kopania. Powtórz od kroku 2.

Oto cały program rozpakowany, nieposortowany i skomentowany.

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

Uruchom i debuguj

Retina 0.8.2 , 163 156 bajtów

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

Wypróbuj online! Wyjaśnienie:

.+
$*_

Konwertuj wejścia na unary. To nam daje W¶S.

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

Zamień dane wejściowe i zduplikuj szerokość. To nam daje S¶W¶W.

r`__\G
$%`$&

Oblicz objętość kamieniołomu. To nam daje S¶W¶V.

¶
;

Połącz dane wejściowe w jedną linię. To nam daje S;W;V.

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

Oblicz stopień postępu dla każdego dnia na własnej linii. Każdy dzień ma format S;W;D, w którym Dznajduje 0się w pierwszym wierszu i zwiększa się Skażdego dnia, aż do osiągnięcia V.

m`^_+;
__

Usuń Si zwiększ Wo 2 w każdej linii. To daje nam G;Dna każdy dzień.

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

Gdy Djest niezerowe, wykopaj jeden z wiersza Dlub G-2z wiersza (aby zawsze pozostawić pierwszy i ostatni znak), przenosząc głębokość do następnego wiersza. Każda linia jest wcięta o jeden więcej >niż poprzedni. Nowo wykopane linie obejmują również <.

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

Zmień wcięcie w spacje, a następujące _w - \.

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

Jeśli a <podąża za, a \następnie zamień ją w a V, jeśli podąża za, a _następnie zamień ją w a /. Usuń wszystkie <s i ;s.

Python 2 , 265 bajtów

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

Wypróbuj online!

• golf w toku

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

• naprawiono błąd rozwiązania duetu na nieparzystym w (dzięki @Shaggy) + zmniejszenie o 2 bajty
• dzięki @Herman Lauenstein za zmniejszenie o 1 bajt

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

Wypróbuj online!

Wyjaśnienie

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