Vous êtes un employé de la nouvelle épicerie branchée Half Foods, et c'est la veille de Thanksgiving Christmas Easter. Étant donné que le magasin sera rempli de clients se précipitant pour obtenir leurs denrées alimentaires, le magasin a besoin d'un gestionnaire de trafic pour envoyer tout le monde aux lignes appropriées. Étant paresseux, vous aimeriez automatiser cela afin de pouvoir aller à la charcuterie avant que tout le monde ne prenne tout le jambon de dinde . Cependant, tout ce que vous avez avec vous est votre téléphone, et coder de longs programmes dessus est une vraie douleur - vous devez donc vous défaire de vos compétences de ninja -golf .

Défi

Visualisons l'épicerie sur une grille à deux dimensions. Voici un exemple de grille à disséquer:

                             e
                             s
                             s
                             s
                               Y

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

La grille commence par un e, qui représente une "sortie" pour le reste du magasin. Chaque génération, tous les points de vente de la grille génèrent un client ( s) directement en dessous. Les acheteurs descendent chaque génération jusqu'à ce qu'ils vous atteignent ( Y). Lorsqu'un acheteur atteint la même ligne que vous, vous devez le téléporter au début de la ligne avec le moins de clients. Un acheteur passe immédiatement à la ligne lorsqu'il se déplacerait dans la rangée avec le Y, il n'y a pas de génération entre les deux. Les lignes sont représentées par le #s - la colonne après le #s est une ligne. Les acheteurs descendent jusqu'à la fin de la ligne (représentée par une sortie x), puis se transforment en un nombre aléatoire entre 1et5. Chaque génération, vous devez décrémenter les acheteurs numérotés de 1- lorsqu'un acheteur atteint 0, il a fini de vérifier et quitte le magasin.

Étant donné l'entrée d'une grille comme celle-ci, sortez la prochaine génération de l'épicerie (déplacez tous les acheteurs vers le bas simultanément, redirigez les acheteurs et faites-les partir s'ils ont terminé).

Échantillons

Contribution:

                e

                     Y


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

Production:

                e
                s 
                     Y


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

Contribution:

                e
                s 
                     Y


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

Production

                e
                s 
                     Y


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

Contribution:

                e

                     Y


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

(Possible) Sortie:

                e
                s 
                     Y


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

Contribution:

                e
                s 
                     Y


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

Production:

                e
                s 
                     Y


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

Contribution:

                e

                     Y


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

Production:

                e
                s 
                     Y


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

C'est le code-golf , donc le code le plus court l'emporte.

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

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

Essayez-le en ligne!

Je travaille toujours sur le golf, mais cela résout le problème pour l'instant

C ++, 898 896 885 841 octets

Très long à coder ... mais c'est là

-2 octets grâce à Conor O'Brien
-45 octets grâce à 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;};

Alors ... quelques détails:

• Vous devez passer un std::vector<std::string>(ils seront redimensionnés à la même longueur que la chaîne la plus longue)

• Toutes les lignes de #départ aux mêmes coordonnées y (verticales), ont la même longueur et se terminent aux mêmes coordonnées y (verticales)

• Supposons que la grille ait au moins 1 #ligne ou plus, a une lettree (une sortie) en haut, une lettreY

• Supposons que l'entrée est une sortie valide, de sorte que les acheteurs en attente de redirection seront toujours l'un après l'autre.

Edit: Je viens de voir dans les commentaires de la réponse de Wheat Wizard qu'il devrait prendre en charge plusieurs entrées, je continuerai à travailler sur cela