एक ट्रैफ़िक चौराहे को हल करें

Question

काम

एक प्रोग्राम या फ़ंक्शन लिखें जो ट्रैफ़िक चौराहे की संरचना लेता है और अनुक्रम को आउटपुट करता है, जिसमें वाहन गुजरेंगे।

आउटपुट में निम्न प्रारूप वाली अधिकतम चार पंक्तियाँ होनी चाहिए #. x->y\n, जहाँ #एक क्रम संख्या संख्या होती है, जिसके बाद बिंदु होते हैं ., xऔर yअक्षर होते हैं ["N", "E", "S", "W"]। उन्हें पात्रों द्वारा अलग किया जाना चाहिए ->। यदि आप स्ट्रिंग्स की एक सरणी नहीं लौटाते हैं, तो प्रत्येक पंक्ति \nको आपके सिस्टम के समतुल्य (नई पंक्ति वर्ण) या समतुल्य होना चाहिए ।

इनपुट को निम्नलिखित रूप लेना चाहिए:

• भाग 1: चार वर्ण, प्रत्येक में स्रोत सड़कों के लिए गंतव्य सड़क है जो क्रम N, E, S, W (दक्षिणावर्त) है। अनुमति चरित्र N, S, W, Eया । अंतरिक्ष का मतलब है कि विशेष सड़क पर कोई वाहन नहीं है। उदाहरण के लिए स्ट्रिंग का S WEमतलब है, कि एन वाहन दक्षिण जाने की इच्छा रखता है, अंतरिक्ष का मतलब है कि कोई ई वाहन नहीं है, Wइसका मतलब है कि एस पश्चिम जाना चाहता है, Eइसका मतलब पश्चिम पूर्व की ओर जाना चाहता है।
• भाग 2 - एक अंतरिक्ष या एक अक्षर का अर्थ है जो एक आपातकालीन वाहन का है।
• भाग 3 - दो वर्ण जो यह निर्धारित करते हैं कि किन दो सड़कों की प्राथमिकता है (उदाहरण के लिए NEकि उत्तर और पूर्व दोनों में दक्षिण और पश्चिम दोनों की तुलना में उच्च प्राथमिकताएँ हैं)। यदि यह आपके लिए आसान है, तो आप निम्न प्राथमिकता वाली सड़कों को ले सकते हैं (उस स्थिति में SW)।

एक बेकार स्थिति में आपको एक-पंक्ति स्ट्रिंग वापस करने की अनुमति दी जाती है, जो उपयोगकर्ता को स्पष्ट है, जैसे unsolvable, no solutionऔर इसी तरह। जावास्क्रिप्ट उपयोगकर्ता अंतर्निहित undefinedनिरंतर ले सकते हैं ।

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

यातायात के नियम

कृपया ध्यान दें कि कुछ नियम आपके देश के यातायात नियमों का पालन नहीं कर सकते हैं। उनमें से कुछ को चुनौती को आसान बनाने के लिए सरल बनाया गया है। इस प्रश्न को वास्तविक जीवन यातायात प्रणाली के लिए एक गाइड के रूप में उपयोग न करें।

1. चुनौती के लिए आपको केवल राइट-साइड ट्रैफ़िक का उपयोग करने की अनुमति है।
2. यातायात चौराहे में ठीक चार सड़कें होती हैं जो एक बिंदु पर मिलती हैं। वे चिह्नित कर रहे हैं N( "उत्तर के लिए" के रूप में), S, W, E। इन पत्रों के बजाय इस्तेमाल किया जाना चाहिए xऔर yइसके बाद के संस्करण उत्पादन उदाहरण में।

3. प्रत्येक सड़क पर अधिकतम एक वाहन है। यह गारंटी नहीं है कि प्रत्येक सड़क पर एक वाहन है। प्रत्येक वाहन किसी भी चार दिशाओं में ड्राइव कर सकता है, अर्थात। बाएं मुड़ें, दाएं मुड़ें, सीधे जाएं या U- टर्न बनाएं ।

4. यदि दो वाहनों के मार्ग एक दूसरे से टकराते नहीं हैं (वे टकराते नहीं हैं), तो वे उसी क्षण जा सकते हैं। रास्ते टकराते नहीं हैं, अगर दो वाहन (सूची पूरी नहीं हो सकती है, लेकिन यह जानबूझकर है, तो बस आपको एक सुराग देने के लिए):
   • विपरीत दिशाओं से आते हैं और दोनों सीधे जाते हैं, या उनमें से कम से कम एक सही मुड़ता है,
   • विपरीत दिशाओं से आते हैं और दोनों बाएं मुड़ते हैं,
   • विपरीत दिशाओं से आते हैं और उनमें से एक किसी भी दिशा में मुड़ता है या यू-टर्न बनाता है, जबकि दूसरा यू-टर्न बनाता है,
   • ऑर्थोगोनल दिशाओं से आते हैं, एक बाएं से दाएं मुड़ता है और दूसरा यू-टर्न नहीं बनाता है

     नीचे रास्ते नहीं टकराने के कुछ उदाहरण। कृपया ध्यान दें कि तीसरे ड्राइंग पर N का कोई भी पथ E के पथ से टकराएगा, भले ही N एक U- टर्न बनाए।

5. यदि दो रास्ते टकराते हैं, तो अन्य नियमों का उपयोग करना आवश्यक है। दो वाहनों (नीचे देखें) एक ही प्राथमिकता वाली सड़क पर हैं, जिस तरह से सही वाहन है कि करने के लिए दिया जाता है:
   • सड़क से दाईं ओर से आता है, अगर वे ऑर्थोगोनल दिशाओं से आते हैं
   • यदि दूसरा बायें मुड़ता है तो दाएं मुड़ता है
   • अगर दूसरा यू-टर्न लेता है तो सीधे जाता है या दाएं मुड़ता है।

     E वाहन के नीचे दोनों उदाहरणों में वाहन S पर रास्ता सही है।

नीचे दिए गए उदाहरण में पहले W, फिर N, फिर E और आखिरी में S जाता है।

इस विशेष मामले के लिए आपके प्रोग्राम का आउटपुट होना चाहिए:

1. W->S
2. N->S
3. E->S
4. S->S

6. सभी ड्राइवर टर्न सिग्नल का उपयोग करते हैं और जानते हैं कि अन्य सभी कहां जाना चाहते हैं (सादगी के लिए हम मानते हैं कि बाएं मोड़ और यू-टर्न के बीच अंतर करना संभव है)।

7. कभी-कभी सड़कों को प्राथमिकता के संकेत दिए जाते हैं, जो अधिक महत्वपूर्ण हैं कि ऊपर दिए गए नियम। उच्च प्राथमिकता वाली सड़क में प्राथमिकता चिह्न ( प्राथमिकता चिह्न छवि ) होती है। यदि प्राथमिकता वाली सड़क सीधी नहीं जाती है, तो अतिरिक्त संकेतों का भी उपयोग किया जाता है, जैसे यह । कम प्राथमिकता वाली सड़कों पर पैदावार चिन्ह या स्टॉप साइन (वे समतुल्य हैं) हैं। कोई भी या बिल्कुल दो अलग-अलग सड़कों की उच्च प्राथमिकता नहीं होगी। आपके प्रोग्राम का उपयोगकर्ता प्रवेश कर सकता है, जिसमें सड़कें उच्च (या निम्न) प्राथमिकताएं हैं।

8. उच्च प्राथमिकता वाली सड़क से आने वाले वाहन को कम प्राथमिकता वाली सड़क से आने वाले वाहन पर अधिकार होता है, भले ही वह बाईं ओर हो।
9. यदि एक ही प्राथमिकता के साथ सड़कों से आने वाले दो वाहनों के रास्ते टकराते हैं, तो राइट-साइड नियम ऊपर सक्रिय हैं।

   सड़कों के नीचे के उदाहरण पर एस और डब्ल्यू में प्राथमिकता के संकेत हैं, जिसका अर्थ है कि एन और ई पर वाहनों को उन्हें रास्ता देना चाहिए। एस वाहन की डब्ल्यू वाहन पर प्राथमिकता है, क्योंकि यह उसके दाहिनी ओर है, इसलिए पहले जाता है। फिर डब्ल्यू जाता है, क्योंकि यह ई की तुलना में उच्च प्राथमिकता की सड़क पर है। वाहन एन के पास ई से सही रास्ता है, क्योंकि यह इसके दाईं ओर है। जैसा कि अंतिम ई।

इस विशेष मामले के लिए आपके प्रोग्राम का आउटपुट होना चाहिए:

1. S->W
2. W->N
3. N->S
4. E->W

10. यह संभव है कि एक (और कोई और नहीं) वाहन एक आपातकालीन वाहन हो , जिसकी प्राथमिकता यह हो कि वह किस दिशा से आता है या किस दिशा में जाता है और उसके पास क्या चिन्ह है (यह हमेशा पहले जाता है)। कार्यक्रम को उपयोगकर्ता को प्रवेश करने की अनुमति देनी चाहिए, कौन सा वाहन एक आपातकालीन वाहन है। यह देखते हुए कि अंतिम उदाहरण में एन एक आपातकालीन वाहन है, एन पहले जाता है, फिर एस, डब्ल्यू और अंतिम ई।

आपके कार्यक्रम का आउटपुट N पर आपातकालीन वाहन के साथ इस विशेष मामले के लिए होना चाहिए:

1. N->S
2. S->W
3. W->N
4. E->W

11. यदि दो वाहनों को एक ही समय पर जाने दिया जाता है (उनके रास्ते टकराते नहीं हैं और उन्हें अन्य वाहनों को रास्ता नहीं देना पड़ता है), तो आपके कार्यक्रम को यह पता लगाना चाहिए और उन्हें उसी क्रम संख्या के रूप में वापस करना चाहिए।

    उदाहरण के नीचे N और E के पथ के साथ-साथ E और S या W और E टकराते नहीं हैं। क्योंकि S को N और W को रास्ता देना है, S को रास्ता देना है, S, E और N के साथ एक साथ नहीं जा सकता है। तो पहले N और E एक साथ चलते हैं, S से और W अंतिम के रूप में।

आपके प्रोग्राम का उचित आउटपुट होना चाहिए:

1. N->W
1. E->E
2. S->W
3. W->N

आप लाइनों के क्रम का चयन करने के लिए स्वतंत्र हैं 1( N->W / E->Eसमकक्ष है E->E / N->W)

12. कभी-कभी ट्रैफ़िक के कारण असमान स्थिति पैदा हो सकती है, जो किसी भी वाहन को जाने की अनुमति नहीं देता है। वास्तविक जीवन में यह तब हल हो जाता है जब कोई भी चालक स्वेच्छा से अपने अधिकार से इस्तीफा दे देता है। यहां, आपके प्रोग्राम को आउटपुट unsolvableआदि चाहिए , जैसा कि प्रश्न के पहले भाग में बताया गया है।

    नीचे अस्थिर स्थिति का एक उदाहरण है। E को W को रास्ता देना चाहिए, W को S को रास्ता देना चाहिए, और S को E को रास्ता देना चाहिए।

Comments

मुझे लगता है कि एक सुसंगत इनपुट प्रारूप को परिभाषित किया जाना चाहिए। "इनपुट में आपकी कोई संरचना हो सकती है" एक बड़ा लाल झंडा है। क्या इनपुट समाधान हो सकता है?

— केल्विन के शौक

@ केल्विन के शौकीन मैंने सवाल अपडेट किया है

— Voitcus

कोई भी मौका हमें 1-2 मामलों के लिए एक उदाहरण इनपुट / आउटपुट मिल सकता है?

— चार्ली व्यान

तो सवाल (और मैं समाधान मान रहा हूं) मान लें कि प्रश्न में सड़क (ओं) को दाहिने हाथ से चलाया जाता है?

— टेरोसॉरोस

Google कार ठीक इसी तरह से काम करती है

— coredump

Answer 1

क्यू, 645 बाइट्स

r:{(1_x),*x}                                                    /rot
R:{x 3,!3}                                                      /-rot
A:4 4#/:@[16#0;;:;]'[(&0100011001111100b;&0001111101100010b;&0010001111000100b;0);(&0 6 2;&0 1 7;&0 3 3;0)]
K:,/{,'/A x}'3 R\3 0 2 1                                        /Konflick matrix
G:3 R\|E:"NESW"                                                 /E:NESW  G:WSEN NWSE ENWS SENW    
m:{x-y*_x%y}                                                    /mod
t:{1=+/m'[_x%4;2]}                                              /orthogonal
w:{-1($x),". ",y[0],"->",y 1;}                               /write
b:{_x%4}                                                        /n-> base dir.
g:m[;4]                                                         /n-> turn
e:(!4)in                                                        /exists
d:{s:r a:e b x;R s&~a}                                       /right free
I:{(G[a]?x 1)+4*a:E?*x}                                         /"dd"->n
O:{E[a],G[a:b x]g x}                                            /n-> "dd"
P:{N::(y=4)&z~4 4;a@&0<a:(@[4#0;b x;:;4-g x])+(5*d x)+(24*e z)+99*e y}          /priority
H:{a::K ./:/:x,/:\:x; if[N&2 in *a;:,0N]; x@&{~|/x[;z]'y}[a]'[!:'u+1;u:!#x]}    /each set of concurrent movements
f:{i:I'(E,'a)@&~^a:4#x; i:i@p:>P[i;E?x 4;E?x 5 6]; {0<#x 1}{a:H x 1;$[a~,0N;-1"unsolvable";w[*x]'O'a];$[a~,0N;(0;());(1+*x;x[1]@&~x[1] in a)]}/(1;i);}

टिप्पणियाँ

निश्चित रूप से, यह छोटा नहीं है (और न ही सरल) कोड। यह (गंभीर रूप से) संकुचित हो सकता है, लेकिन यह पाठक के लिए बहिष्कार के रूप में छोड़ दिया जाता है (मैंने इस समस्या के लिए बहुत समय समर्पित किया है)।

मैंने बहुस्तरीय टिप्पणी समाधान शामिल किया है, लेकिन आकार को गिनने के लिए 1 बाइट के रूप में नई संख्याओं को मानें और टिप्पणियों (/ से अंत तक) को त्याग दें

मुख्य कठिनाई सभी नियमों को पूरी तरह से समझने में है। एक जटिल समस्या के समाधान को विकसित करने के लिए कोड की लंबाई का प्रारंभिक अनुकूलन असंगत है। न ही नीचे-ऊपर या ऊपर-नीचे दृष्टिकोण अपठनीय कोड के साथ अच्छी तरह से मुकाबला करता है।

अंत में, मैंने 16 पंक्तियों और 16 स्तंभों (प्रत्येक संभव मोड़ के साथ संयुक्त दिशा के लिए) के साथ एक विचलन तालिका (संघर्ष मैट्रिक्स) विकसित की। आइटम के मान 0 (संगतता), 1 (पंक्ति के लिए वरीयता), या 2 (स्तंभ के लिए वरीयता) हैं। यह सभी परीक्षण को संतुष्ट करता है, मुझे यकीन नहीं है कि सभी संभावित परिस्थितियां अच्छी तरह से कवर की गई हैं

स्रोत फ़ाइल में k एक्सटेंशन होना चाहिए। इंटरएक्टिव इंटरप्रेटर शुरू करें (गैर-कॉमरेटियल उपयोग के लिए निशुल्क, kx.com) और तुरंत मूल्यांकन करें (जैसा कि ter एनडीआर) में दिखाया गया है)

परीक्षा

q)f " WN    "
1. E->W
2. S->N

q)f " SW    "
1. E->S
2. S->W

q)f "SSSS   "
1. W->S
2. N->S
3. E->S
4. S->S

q)f "SWWN WS"
1. S->W
2. W->N
3. N->S
4. E->W

q)f "SWWNNWS"
1. N->S
2. S->W
3. W->N
4. E->W

q)f "WEWN   "
1. N->W
1. E->E
2. S->W
3. W->N

q)f " SWE   "
unsolvable

व्याख्या

आधार संरचना 'पूर्ववर्ती मैट्रिक्स' है

   N       E       S       W   
   W S E N N W S E E N W S S E N W
NW 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
 S 0 0 0 0 0 1 1 0 0 0 1 1 2 2 2 2
 E 0 0 0 0 0 1 1 1 2 2 0 0 0 2 2 0
 N 0 0 0 0 2 2 0 0 0 2 0 0 0 0 2 0
EN 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 0
 W 2 2 2 2 0 0 0 0 0 1 1 0 0 0 1 1
 S 0 2 2 0 0 0 0 0 0 1 1 1 2 2 0 0
 E 0 0 2 0 0 0 0 0 2 2 0 0 0 2 0 0
SE 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0
 N 0 0 1 1 2 2 2 2 0 0 0 0 0 1 1 0
 W 2 2 0 0 0 2 2 0 0 0 0 0 0 1 1 1
 S 0 2 0 0 0 0 2 0 0 0 0 0 2 2 0 0
WS 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0
 E 0 1 1 0 0 0 1 1 2 2 2 2 0 0 0 0
 N 0 1 1 1 2 2 0 0 0 2 2 0 0 0 0 0
 W 2 2 0 0 0 2 0 0 0 0 2 0 0 0 0 0

अर्थ (उदाहरण से)

• m[NW][SE] 0 मान है (दोनों आंदोलनों संगत हैं -संक्रमण-)
• m[EW][SN] 1 मान (EW में SN पर प्राथमिकता है) NOTE.- अन्य प्राथमिकता कारक इस वाक्य को बदल सकते हैं (आपातकालीन वाहन, प्राथमिकता सड़क, ..)
• m[NE][SE] 2 मान है (SE NE पर प्राथमिकता है) NOTE.- अन्य प्राथमिकता कारक इस वाक्य को बदल सकते हैं (आपातकालीन वाहन, प्राथमिकता सड़क, ..)

मैट्रिक्स का निर्माण चार सबमेट्रिक्स (4x4) प्रकारों का उपयोग करके किया जा सकता है

  NESW  A    B    C    D
N DACB  0100 0001 0010 0000
E BDAC  0110 2222 0011 0000
S CBDA  0111 0220 2200 0000
W ACBD  2200 0020 0200 0000

मैट्रिक्स एक फ़ंक्शन के साथ पूरक है जो प्रत्येक आंदोलन को प्राथमिकता देता है। यह समारोह आपातकालीन वाहनों, प्राथमिकता वाली सड़कों, ऑर्थोगोनल दिशाओं, मोड़ के प्रकार और वाहनों के 'सही से आने' का हिसाब लेता है।

हम आंदोलनों को प्राथमिकता के आधार पर हल करते हैं और मैट्रिक्स मूल्यों को लागू करते हैं। परिणामस्वरूप सबमेट्रिक्स में प्रत्येक आंदोलन के संघर्ष और प्राथमिकता शामिल है।

• हम बेकार मामलों (आपसी संघर्ष) का विश्लेषण करते हैं
• यदि नहीं, तो हम सबसे अधिक प्राथमिकता वाले आइटम का चयन करते हैं और इसके साथ संगत सभी आंदोलनों और पिछले असंगत आंदोलनों के साथ असंगत नहीं हैं, और एक साथ जाने के लिए अनुमत आंदोलनों का एक सेट बनाते हैं
• आंदोलनों के उस सेट को लिखें और बाकी उम्मीदवारों पर पुनरावृति करें