किराने की दुकान Micromanagement

Question

आप कूल्हे नया किराने की दुकान आधा फूड्स से कम एक कर्मचारी हैं, और यह पहले दिन है धन्यवाद क्रिसमस ईस्टर। चूंकि स्टोर को उनके खाद्य पदार्थों को प्राप्त करने के लिए भाग रहे ग्राहकों के साथ पैक किया जाएगा, इसलिए सभी को उचित लाइनों में भेजने के लिए स्टोर को ट्रैफिक मैनेजर की आवश्यकता होती है। आलसी होने के नाते, आप इसे स्वचालित करना चाहेंगे ताकि आप सभी को टर्की हैम लेने से पहले डेली हिट कर सकें । हालाँकि, आपके पास आपके पास अपना फोन है, और उस पर लंबे कार्यक्रमों को कोड करना एक वास्तविक दर्द है - इसलिए आपको अपने निंजा कोड-गोल्फ कौशल का भंडाफोड़ करने की आवश्यकता है ।

चुनौती

चलो एक दो-आयामी ग्रिड पर किराने की दुकान की कल्पना करते हैं। यहाँ एक नमूना ग्रिड विच्छेदित करने के लिए है:

                             e
                             s
                             s
                             s
                               Y

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

ग्रिड एक के साथ शुरू होता है e, जो बाकी स्टोर के लिए "आउटलेट" का प्रतिनिधित्व करता है। हर पीढ़ी, ग्रिड के सभी आउटलेट sसीधे नीचे एक दुकानदार ( ) को नियुक्त करते हैं। दुकानदार प्रत्येक पीढ़ी को तब तक नीचे ले जाते हैं जब तक कि वे आप तक नहीं पहुँचते ( Y)। जब एक दुकानदार आपके पास एक ही पंक्ति में पहुंचता है, तो आपको दुकानदार को लाइन की शुरुआत में दुकानदारों को कम से कम राशि के साथ टेलीपोर्ट करना होगा। एक दुकानदार तुरंत लाइन में जाता है जब वे पंक्ति के साथ आगे बढ़ते हैं Y, बीच में कोई पीढ़ी नहीं होती है। लाइनों को #एस द्वारा दर्शाया जाता है - एस के बाद का कॉलम #एक लाइन है। दुकानदार लाइन के अंत तक जाते हैं (एक निकास द्वारा दर्शाया गया है x), और फिर 1और के बीच एक यादृच्छिक संख्या में बदल जाते हैं5। प्रत्येक पीढ़ी, आपको दुकानदारों की संख्या में कमी करनी चाहिए 1- जब कोई दुकानदार पहुंचेगा 0, तो वे जांच कर रहे होंगे और वे दुकान छोड़ देंगे।

इस तरह एक ग्रिड के इनपुट को देखते हुए, किराने की दुकान की अगली पीढ़ी को आउटपुट करें (सभी दुकानदारों को एक साथ नीचे ले जाएं, दुकानदारों को पुनर्निर्देशित करें, और यदि वे काम कर रहे हैं तो उन्हें छोड़ दें)।

नमूने

इनपुट:

                e

                     Y


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

आउटपुट:

                e
                s 
                     Y


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

इनपुट:

                e
                s 
                     Y


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

उत्पादन

                e
                s 
                     Y


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

इनपुट:

                e

                     Y


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

(संभव) आउटपुट:

                e
                s 
                     Y


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

इनपुट:

                e
                s 
                     Y


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

आउटपुट:

                e
                s 
                     Y


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

इनपुट:

                e

                     Y


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

आउटपुट:

                e
                s 
                     Y


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

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

Comments

मुझे वास्तव में इनपुट प्रारूप नहीं मिला है।

— निधि मोनिका का मुकदमा

@QPaysTaxes इनपुट या तो मल्टी-लाइन स्ट्रिंग या इनपुट की कई लाइनों को लेने के लिए हमारी चूक के अनुसार सिंगल लाइन स्ट्रिंग्स की एक सरणी हो सकती है।

— एक स्पेगेटो

नहीं, मेरा मतलब है कि मुझे अभी चुनौती नहीं मिली है।

— निधि मोनिका का मुकदमा

उदाहरणों पर भरोसा करने के बजाय, यह स्पष्ट रूप से कहा जा सकता है कि दुकानदार कभी भी वाई के रूप में एक ही पंक्ति में नहीं हो सकता है, क्योंकि वाई पंक्ति के नीचे जाने और एक ही चरण में प्रासंगिक कतार के शीर्ष पर टेलीपोर्ट होने के नाते।

— ट्राइकोप्लाक्स

एक उदाहरण के रूप में एक परीक्षण मामले के साथ एक कतार कैसे चलती है, इसका वर्णन करने में भी मदद मिलेगी। यदि कतार में 3 दुकानदार लंबवत सटे हुए हैं, और सबसे नीचे जा सकते हैं, तो क्या सभी 3 एक ही चरण में एक साथ नीचे जाते हैं या क्या उपलब्ध स्थान एक बार में एक पंक्ति ऊपर ले जाता है क्योंकि प्रत्येक दुकानदार इसमें चला जाता है?

— ट्राइकोप्लाक्स

Answer 1

पायथन 2 , 477 463 453 449 423 402 397 396 393 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अभी भी यह गोल्फिंग पर काम कर रहा है लेकिन यह अभी के लिए समस्या को हल करता है

Comments

आप अतिरिक्त इंडेंटेशन और लाइन ब्रेक को हटा सकते हैं (एकल लाइन ब्लॉक ब्लॉक की शुरुआत के समान लाइन पर जा सकते हैं)

— सोलोमन उको

@SolomonUcko आप किस बारे में बात कर रहे हैं?

— पोस्ट रॉक गार्फ हंटर

1. क्या अजगर के लिए 8 रिक्त स्थान हैं? 2. मुझे लगता है कि आप छोरों के लिए अंतिम 2 के बाद लाइन ब्रेक को हटा सकते हैं।

— सोलोमन उको

1. पायथन में टैब्स उनकी अपनी चीज है। 2. आप उस लाइन ब्रेक को हटा नहीं सकते।

— पोस्ट रॉक गार्फ हंटर

1. क्या अजगर एक ब्लॉक में पहले इंडेंटेशन स्तर को उस ब्लॉक के इंडेंटेशन स्तर के रूप में गिनता है? 2. क्या आप जानते हैं कि क्यों नहीं? मैंने इसका परीक्षण किया और यह काम नहीं करता है।

— सोलोमन उको

Answer 2

सी ++, 898 896 885 841 बाइट्स

कोड के लिए बहुत लंबा ... लेकिन यह वहाँ है

-2 बाइट्स कोनोर ओ'ब्रायन
-45 बाइट की बदौलत जचार्जी को धन्यवाद

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

तो ... कुछ विवरण:

• आपको एक पास करना होगा std::vector<std::string>(वे एक ही लंबाई में सबसे लंबी स्ट्रिंग हैं)

• #एक ही y (वर्टिकल) निर्देशांक पर शुरू होने वाली सभी लाइनें एक ही लंबाई की होती हैं, और एक ही y (वर्टिकल) निर्देशांक पर समाप्त होती हैं

• मान लें कि ग्रिड में कम से कम 1 #पंक्ति या अधिक है, तो eशीर्ष पर एक अक्षर (एक आउटलेट), एक अक्षर हैY

• मान लें कि इनपुट एक वैध आउटपुट है इसलिए दुकानदारों को पुनर्निर्देशित होने का इंतजार हमेशा एक के बाद एक होगा

संपादित करें: अभी गेहूं जादूगर के जवाब की टिप्पणियों में देखा गया है कि इसे कई प्रवेश द्वारों का समर्थन करना चाहिए, मैं उस पर काम करना जारी रखूंगा

Comments

शायद आप कर सकते हैं कि सी मैक्रो हो सकता है #define C(e)i[j].find(e)!=string::npos?

— कॉनर ओ'ब्रायन

मेरा जवाब एक पक्ष प्रभाव के रूप में कई प्रवेश द्वारों का समर्थन करता है, यह गोल्फ की तरह है। क्वार्टाटा ने कहा कि इसकी आवश्यकता होगी, लेकिन मैं इसे प्रश्न में नहीं देखती, इसलिए जहां तक ​​मेरा सवाल है आप केवल एक ही प्रवेश का समर्थन करने के लिए स्वतंत्र हैं।

— पोस्ट रॉक गार्फ हंटर

@WheatWizard ठीक है, अगर मैं प्रश्न पढ़ता हूं, तो यह कहता है: "ग्रिड एक ई के साथ शुरू होता है, जो एक आउटलेट का प्रतिनिधित्व करता है" और "सभी आउटलेट्स", ताकि यह सुझाव दे कि इसमें कई प्रवेश हो सकते हैं

— HatsuPointerKit

आप की परिभाषा को बदल सकते हैं C(e)होने के लिए #define C(e)if(i[j].find(e)!=string::nposऔर कॉल के हिसाब से बदल जाते हैं।

— Zacharý

और चूंकि length()केवल पर लागू किया गया है a, आप के Lरूप में परिभाषित किया जा सकता है a.length(), तदनुसार कॉल को संशोधित करना। इसके अलावा, आप using namespace std;नीचे की ओर जा सकते हैं ,

— न्यूलाइन