Sei un dipendente del nuovo negozio di alimentari alla moda Half Foods, ed è il giorno prima del Ringraziamento Natale Pasqua. Poiché il negozio sarà pieno di clienti che si affrettano a procurarsi i loro prodotti alimentari, il negozio ha bisogno di un gestore del traffico per inviare tutti alle linee appropriate. Essendo pigro, ti piacerebbe automatizzare questo in modo da poter andare a fare un giro nella gastronomia prima che tutti prendano tutto il prosciutto di tacchino qualunque. Tuttavia, tutto ciò che hai con te è il tuo telefono, e codificare programmi lunghi su di esso è un vero dolore - quindi devi sbrigare le tue abilità di ninja nel golf del codice .

Sfida

Visualizziamo il negozio di alimentari su una griglia bidimensionale. Ecco una griglia di esempio per dissezionare:

                             e
                             s
                             s
                             s
                               Y

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

La griglia inizia con un e, che rappresenta uno "sbocco" per il resto del negozio. Ogni generazione, tutti gli sbocchi della griglia generano un acquirente ( s) direttamente sotto. Gli acquirenti si muovono verso il basso ogni generazione fino a quando non ti raggiungono ( Y). Quando un acquirente raggiunge la stessa riga di te, devi teletrasportarlo all'inizio della linea con il minor numero di acquirenti presenti. Un acquirente si sposta immediatamente sulla linea quando si sposterebbe nella fila con la Y, non c'è generazione in mezzo. Le linee sono rappresentate dalla #s - la colonna dopo la #s è una linea. Gli acquirenti scendono fino alla fine della linea (rappresentata da un'uscita x), quindi si trasformano in un numero casuale tra 1e5. Ogni generazione, è necessario decrementare gli acquirenti numerati di 1: quando un acquirente avrebbe raggiunto 0, hanno terminato il checkout e hanno lasciato il negozio.

Dato un input di una griglia come questa, genera la prossima generazione del negozio di alimentari (sposta contemporaneamente tutti gli acquirenti verso il basso, reindirizza gli acquirenti e lasciali andare se hanno finito).

Campioni

Ingresso:

                e

                     Y


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

Produzione:

                e
                s 
                     Y


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

Ingresso:

                e
                s 
                     Y


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

Produzione

                e
                s 
                     Y


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

Ingresso:

                e

                     Y


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

(Possibile) Uscita:

                e
                s 
                     Y


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

Ingresso:

                e
                s 
                     Y


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

Produzione:

                e
                s 
                     Y


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

Ingresso:

                e

                     Y


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

Produzione:

                e
                s 
                     Y


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

Questo è code-golf , quindi vince il codice più corto.

Python 2 , 477 463 453 449 423 402 397 396 393 byte

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))

Provalo online!

Sto ancora lavorando sul golf, ma per ora risolve il problema

C ++, 898 896 885 841 byte

Molto lungo da programmare ... ma è lì

-2 byte grazie a Conor O'Brien
-45 byte grazie a Zacharý

#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;};

Quindi ... alcuni dettagli:

• Devi passare un std::vector<std::string>(saranno ridimensionati alla stessa lunghezza della stringa più lunga)

• Tutte le linee di #inizio con le stesse coordinate y (verticali), hanno la stessa lunghezza e terminano con le stesse coordinate y (verticali)

• Supponiamo che la griglia abbia almeno 1 #riga o più, abbia una lettera e(una presa) nella parte superiore, una letteraY

• Supponiamo che l'input sia un output valido, quindi gli acquirenti in attesa di essere reindirizzati saranno sempre uno dopo l'altro

Modifica: Ho appena visto nei commenti della risposta di Wheat Wizard che dovrebbe supportare più ingressi, continuerò a lavorarci su