งาน

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้โครงสร้างการแยกการจราจรและเรียงลำดับผลลัพธ์ซึ่งยานพาหนะจะผ่าน

เอาท์พุทควรมีที่มากที่สุดสี่เส้นที่มีรูปแบบต่อไป#. x->y\nซึ่ง#เป็นจำนวนที่หมายเลขลำดับตามด้วยจุด., xและตัวละครy พวกเขาควรจะแยกออกจากกันโดยตัวละคร["N", "E", "S", "W"] ->หากคุณไม่ส่งคืนอาเรย์ของสตริงแต่ละบรรทัดต้องลงท้ายด้วย\n(อักขระบรรทัดใหม่) หรือเทียบเท่ากับระบบของคุณ

อินพุตควรใช้แบบฟอร์มต่อไปนี้:

• ส่วนที่ 1: อักขระสี่ตัวแต่ละตัวมีถนนปลายทางสำหรับถนนต้นทางตามลำดับ N, E, S, W (ตามเข็มนาฬิกา) ตัวละครที่ได้รับอนุญาตมีN, S, W, หรือE อวกาศหมายความว่าไม่มียานพาหนะบนถนนโดยเฉพาะ ตัวอย่างเช่นสายอักขระS WEหมายความว่ายานพาหนะ N ปรารถนาที่จะไปทางทิศใต้พื้นที่หมายความว่าไม่มียานพาหนะ E Wหมายถึงว่า S ประสงค์ที่จะไปทางตะวันตกEหมายความว่าตะวันตกต้องการที่จะไปทางตะวันออก
• ส่วนที่ 2 - ช่องว่างหรือตัวอักษรเดี่ยวหมายถึงอันที่หนึ่งของยานพาหนะฉุกเฉิน
• ส่วนที่ 3 - อักขระสองตัวที่กำหนดว่าถนนสองสายใดมีลำดับความสำคัญสูง (เช่นNEหมายความว่าทิศเหนือและทิศตะวันออกมีลำดับความสำคัญสูงกว่าทั้งใต้และตะวันตก) ถ้ามันง่ายกว่าสำหรับคุณคุณอาจใช้ถนนที่มีลำดับความสำคัญต่ำกว่า (ในกรณีนี้SW)

ในสถานการณ์ที่แก้ไม่ได้รับอนุญาตให้กลับสตริงหนึ่งบรรทัดซึ่งเป็นที่ชัดเจนให้กับผู้ใช้เช่นunsolvable, no solutionและที่คล้ายกัน ผู้ใช้ JavaScript อาจมีundefinedค่าคงที่ในตัว

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

กฎจราจร

โปรดทราบว่ากฎบางข้ออาจไม่ปฏิบัติตามกฎจราจรในประเทศของคุณ บางคนได้รับการทำให้เรียบง่ายเพื่อให้การท้าทายง่ายขึ้น อย่าใช้คำถามนี้เป็นแนวทางสำหรับระบบการจราจรในชีวิตจริง

1. สำหรับความท้าทายที่คุณได้รับอนุญาตให้ใช้การจราจรทางด้านขวาเท่านั้น
2. สี่แยกการจราจรประกอบด้วยถนนสี่สายที่พบในจุดเดียว พวกเขามีการทำเครื่องหมายN(เช่นเดียวกับ S"นอร์ท") W, E, ควรใช้ตัวอักษรเหล่านี้แทนxและyในตัวอย่างผลลัพธ์ด้านบน

3. ในแต่ละถนนมียานพาหนะไม่เกินหนึ่งคัน ไม่รับประกันว่าจะมียานพาหนะในแต่ละถนน ยานพาหนะแต่ละคันสามารถขับได้สี่ทิศทางคือ เลี้ยวซ้ายเลี้ยวขวาตรงไปหรือกลับรถ

4. หากเส้นทางของยานพาหนะสองคันไม่ตัดกัน (พวกเขาไม่ชนกัน) พวกเขาสามารถไปในเวลาเดียวกันได้ เส้นทางไม่ชนกันหากรถสองคัน (รายการอาจไม่สมบูรณ์ แต่นี่เป็นเจตนาเพียงเพื่อให้เบาะแสคุณ):
   • มาจากทิศทางตรงข้ามและทั้งคู่เดินตรงหรืออย่างน้อยหนึ่งคนเลี้ยวขวา
   • มาจากทิศทางตรงข้ามและเลี้ยวซ้าย
   • มาจากทิศทางตรงกันข้ามและหนึ่งในนั้นหันไปในทิศทางใดก็ได้หรือทำให้กลับรถในขณะที่อีกคนหันกลับ
   • มาจากทิศทางมุมฉากคนหนึ่งไปทางซ้ายกำลังเลี้ยวขวาและคนอื่น ๆ ไม่ได้กลับรถ

     ตัวอย่างของเส้นทางที่ไม่ชนกันด้านล่าง โปรดทราบว่าในการวาดครั้งที่สามเส้นทางใด ๆ ของ N จะชนกับเส้นทางของ E แม้ว่า N จะเลี้ยวกลับ

5. หากสองพา ธ ชนกันจำเป็นต้องใช้กฎอื่น หากยานพาหนะสองคันอยู่บนถนนที่มีลำดับความสำคัญเท่ากัน (ดูด้านล่าง) จะมีการมอบทางด้านขวาให้กับรถที่:
   • มาจากถนนทางด้านขวาหากพวกเขามาจากทิศทางมุมฉาก
   • เลี้ยวขวาหากเลี้ยวซ้ายอีกทาง
   • ไปทางตรงหรือเลี้ยวขวาหากอีกทางหนึ่งกลับรถ

     ในตัวอย่างทั้งสองด้านล่างยานพาหนะ E มีสิทธิ์เหนือยานพาหนะ S

ในตัวอย่างด้านล่างแรกไป W จากนั้น N จากนั้น E และสุดท้ายไป S

สำหรับกรณีนี้ผลลัพธ์ของโปรแกรมของคุณควรเป็น:

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

6. ผู้ขับขี่ทุกคนใช้สัญญาณเลี้ยวและรู้ว่าคนอื่น ๆ ต้องการไปที่ใด (เพื่อความง่ายเราคิดว่าเป็นไปได้ที่จะแยกความแตกต่างระหว่างเลี้ยวซ้ายและกลับรถ)

7. บางครั้งถนนจะได้รับป้ายบอกลำดับความสำคัญซึ่งสำคัญกว่ากฎข้างต้น ถนนที่มีลำดับความสำคัญสูงกว่าจะมีสัญลักษณ์ลำดับความสำคัญ ( ภาพของลำดับความสำคัญ ) ถ้าถนนมีความสำคัญไม่ได้ตรงไปยังสัญญาณเพิ่มเติมจะนำมาใช้เช่นนี้ ถนนที่มีลำดับความสำคัญต่ำกว่าจะมีสัญญาณให้ผลผลิตหรือเครื่องหมายหยุด (เทียบเท่ากัน) ถนนที่แตกต่างกันสองสายไม่ว่าจะมีลำดับความสำคัญสูงกว่า ผู้ใช้โปรแกรมของคุณควรสามารถเข้าสู่ถนนที่มีลำดับความสำคัญสูงกว่า (หรือต่ำกว่า)

8. ยานพาหนะที่มาจากถนนที่มีลำดับความสำคัญสูงกว่ามีสิทธิ์เหนือยานพาหนะที่มาจากถนนที่มีลำดับความสำคัญต่ำกว่าแม้ว่าจะอยู่ทางด้านซ้าย
9. หากเส้นทางของยานพาหนะสองคันที่มาจากถนนที่มีลำดับความสำคัญเท่ากันมีการชนกันด้านบนกฎด้านขวาจะทำงาน

   ในตัวอย่างด้านล่างถนน S และ W มีสัญญาณลำดับความสำคัญซึ่งหมายความว่ายานพาหนะใน N และ E ควรให้ทางแก่พวกเขา รถ S มีลำดับความสำคัญเหนือกว่ารถ W เพราะมันอยู่ทางด้านขวาดังนั้นก่อนอื่น จากนั้นไปทาง W เพราะอยู่บนถนนที่มีลำดับความสำคัญสูงกว่า E ยานพาหนะ N มีทางเดินที่ถูกต้องจาก E เนื่องจากอยู่ทางด้านขวา เป็นคนสุดท้ายที่ไป E

สำหรับกรณีนี้ผลลัพธ์ของโปรแกรมของคุณควรเป็น:

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

10. เป็นไปได้ว่ารถยนต์หนึ่งคัน (และไม่มีอีก) เป็นยานพาหนะฉุกเฉินซึ่งมีลำดับความสำคัญโดยไม่คำนึงถึงทิศทางที่มาจากหรือไปที่และสิ่งที่ลงชื่อว่ามี (มันจะไปก่อนเสมอ) โปรแกรมควรอนุญาตให้ผู้ใช้ป้อนรถคันใดเป็นพาหนะฉุกเฉิน เมื่อพิจารณาว่าในตัวอย่างสุดท้าย N เป็นยานพาหนะฉุกเฉิน N ไปก่อนจากนั้น S, W และเป็น E สุดท้าย

สำหรับกรณีนี้ที่มียานพาหนะฉุกเฉินที่ 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 ได้ ฯลฯ The N และ E ทำได้ ดังนั้นในตอนแรก 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

Q, 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) และประเมินผลที่พร้อมท์ (ดังแสดงในวรรค 'ทดสอบ')

ทดสอบ

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) หมายเหตุ - ปัจจัยอื่น ๆ ที่มีความสำคัญอาจเปลี่ยนแปลงประโยคนี้ (ยานพาหนะฉุกเฉิน, ถนนที่มีลำดับความสำคัญสูง, .. )
• m[NE][SE] มี 2 ​​ค่า (SE มีลำดับความสำคัญสูงกว่า NE) หมายเหตุ: - ปัจจัยสำคัญอื่น ๆ อาจเปลี่ยนประโยคนี้ (ยานพาหนะฉุกเฉิน, ถนนที่มีลำดับความสำคัญสูง, .. )

เมทริกซ์สามารถสร้างได้โดยใช้ submatrix (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

เมทริกซ์เสริมด้วยฟังก์ชันที่กำหนดระดับความสำคัญให้กับการเคลื่อนไหวแต่ละครั้ง ฟังก์ชั่นนั้นคำนึงถึงยานพาหนะฉุกเฉิน, ถนนที่มีลำดับความสำคัญสูง, ทิศทางมุมฉาก, ชนิดเลี้ยวและพาหนะที่มาจากด้านขวา

เราจัดเรียงการเคลื่อนไหวตามลำดับความสำคัญและใช้ค่าเมทริกซ์ submatrix ที่เกิดขึ้นจะรวมถึงความขัดแย้งและลำดับความสำคัญของการเคลื่อนไหวแต่ละครั้ง

• เราวิเคราะห์กรณีที่แก้ไม่ได้ (ความขัดแย้งซึ่งกันและกัน)
• ถ้าไม่เราเลือกรายการที่มีลำดับความสำคัญสูงสุดและการเคลื่อนไหวทั้งหมดที่เข้ากันได้กับมันและไม่เข้ากันกับการเคลื่อนไหวที่เข้ากันไม่ได้ก่อนหน้านี้และสร้างชุดการเคลื่อนไหวที่อนุญาตให้ไปพร้อมกัน
• เขียนชุดของการเคลื่อนไหวนั้นและทำซ้ำในส่วนที่เหลือของผู้สมัคร