Jesteś pracownikiem modnego nowego sklepu spożywczego Half Foods i to dzień przed Świętami Bożego Narodzenia w Święto Dziękczynienia . Ponieważ sklep będzie pełen klientów pędących po żywność, sklep potrzebuje menedżera ruchu, aby wysłać wszystkich na odpowiednie linie. Będąc leniwym, chcesz zautomatyzować to, abyś mógł przejść do delikatesów, zanim wszyscy wezmą całą szynkę z indyka . Jednak wszystko, co masz przy sobie, to telefon, a pisanie na nim długich programów jest prawdziwym bólem - więc musisz poćwiczyć swoje umiejętności gry w golfa ninja .

Wyzwanie

Wizualizujmy sklep spożywczy na dwuwymiarowej siatce. Oto przykładowa siatka do wycięcia:

                             e
                             s
                             s
                             s
                               Y

#           #                #s           #
#s          #                #s           #
#s          #                #s           #
#s          #s               #s           #
#3          #1               #4           #
 x           x                x            x

Siatka zaczyna się od znaku e, który reprezentuje „wylot” do reszty sklepu. Z każdym pokoleniem wszystkie gniazda w sieci spawnują shopper ( s) bezpośrednio poniżej. Kupujący przesuwają się w dół z każdym pokoleniem, aż do ciebie ( Y). Kiedy klient osiągnie ten sam rząd co ty, musisz teleportować go na początek linii z najmniejszą liczbą kupujących. Klient natychmiast przenosi się na linię, gdy wprowadzi się do rzędu z Y, nie ma między nimi generacji. Linie są reprezentowane przez #s - kolumna po #s jest linią. Kupujący schodzą na koniec linii (reprezentowanej przez wyjście x), a następnie zamieniają się w losową liczbę między 1i5. Z każdym pokoleniem należy zmniejszyć numerowanych klientów o 1- kiedy klient do 0nich dotrze , kończy sprawdzanie i opuszcza sklep.

Biorąc pod uwagę taką siatkę, wypisz następną generację sklepu spożywczego (przesuń wszystkich kupujących jednocześnie, przekieruj kupujących i pozwól im odejść, jeśli są gotowe).

Próbki

Wejście:

                e

                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
 x           x                x            x

Wynik:

                e
                s 
                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
 x           x                x            x

Wejście:

                e
                s 
                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
 x           x                x            x

Wynik

                e
                s 
                     Y


#s          #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
 x           x                x            x

Wejście:

                e

                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#s          #                #            #
#           #                #            #
 x           x                x            x

(Możliwe) Wyjście:

                e
                s 
                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#3          #                #            #
 x           x                x            x

Wejście:

                e
                s 
                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#3          #                #            #
 x           x                x            x

Wynik:

                e
                s 
                     Y


#           #s               #            #
#           #                #            #
#           #                #            #
#           #                #            #
#2          #                #            #
 x           x                x            x

Wejście:

                e

                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#1          #                #            #
 x           x                x            x

Wynik:

                e
                s 
                     Y


#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
#           #                #            #
 x           x                x            x

To jest golf golfowy , więc wygrywa najkrótszy kod.

Python 2 , 477 463 453 449 423 402 397 396 393 bajtów

t=input()
e=enumerate
q,r=" s"
for i,L in list(e(t))[:0:-1]:
 for j,c in e(L):
	a=t[i-1][j]
	if"0"<c<"6":L[j]="0 1234"[int(c)]
	if(r==a)*q==L[j]:t[i-1][j],L[j]=q+r
	if"e"==a:L[j]=r
	if r==L[j]and"x"==t[i+1][j]:L[j]="5"
 if"Y"in L:x=L.count(r);t[i]=[p.replace(r,q)for p in L]
for i,l in list(e(t))[::-1]:
 for j,c in e(l):
	if"#"==c and(q==l[j+1])*x:x-=1;l[j+1]=r
print"\n".join(map("".join,t))

Wypróbuj online!

Nadal pracuję nad golfem, ale na razie to rozwiązuje problem

C ++, 898 896 885 841 bajtów

Bardzo długo koduję ... ale tam jest

-2 bajty dzięki
Conorowi O'Brienowi -45 bajtów dzięki Zacharýmu

#include<vector>
#include<string>
#include<algorithm>
#include<ctime>
#define B begin()
#define L length()
#define C(e)if(i[j].find(e)!=string::npos&&!
#define S's'
#define T size()
#define U i[x][a]
using namespace std;auto g=[](auto&i){int e=i[0].find('e'),n=0,y=0,h=0,o,j,c,x,t=0;for(auto&a:i)t=a.L>t?a.L:t;for_each(i.B,i.end(),[&i,t](string&s){s.resize(t);});srand(time(0));vector<int>s,l;for(j=0;j<i.T;++j){C(S)y)++n;C(89)0)y=j;C(35)h){h=j;for(int d=0;d<i[j].T;++d)if(i[j][d]==35)l.push_back(d+1);s.resize(l.T);}if(h)for(c=0;c<l.T;c++)if(i[j][l[c]]!=32)++s[c];C('x')0)x=j;}--x;for_each(l.B,l.end(),[&i,&x,h](int&a){if(U!=32)--U;if(U==10)U=32;for(int b=x;b>h;--b){if(i[b][a]==32&&i[b-1][a]==S){i[b][a]=S;i[b-1][a]=32;}}if(U==S)U=49+rand()%5;});if(i[y-1][e]==S)i[h][l[min_element(s.B,s.end())-s.B]]=S;for(j=1;j<n+2;++j)if(j<y)i[j][e]=S;};

Więc ... kilka szczegółów:

• Musisz przekazać std::vector<std::string>(rozmiar zostanie zmieniony na tej samej długości, co najdłuższy ciąg)

• Wszystkie linie #początków o tych samych współrzędnych y (pionowych) mają tę samą długość i kończą się na tych samych współrzędnych y (pionowych)

• Załóżmy, że siatka ma co najmniej 1 #linię lub więcej, ma jedną literę e(jeden wylot) u góry, jedną literęY

• Załóżmy, że dane wejściowe są prawidłowymi danymi wyjściowymi, więc klienci oczekujący na przekierowanie będą zawsze jeden po drugim

Edycja: Właśnie zobaczyłem w komentarzach odpowiedzi Kreatora pszenicy, że powinien obsługiwać wiele wejść, będę nadal nad tym pracował