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

แรงบันดาลใจ

ความท้าทายนี้ได้รับแรงบันดาลใจจากบทกวีที่มีชื่อเสียงของ Robert Frost, The Road Not Taken :

ถนนสองสายแยกในไม้สีเหลือง
และขอโทษที่ฉันไม่สามารถเดินทางทั้งสอง
และเป็นหนึ่งในผู้เดินทางนานผมยืนอยู่
และมองลงไปหนึ่งเท่าที่ผมจะทำได้
เพื่อที่จะงอในพง;

... 2 ย่อหน้าถูกตัด ...

ฉันจะบอกเรื่องนี้ด้วยการถอนหายใจ
ที่ไหนสักแห่งในยุคนี้:
ถนนสองสายแยกจากกันในป่าและฉัน -
ฉันเอาคนเดินทางน้อยกว่า
และนั่นทำให้เกิดความแตกต่าง

สังเกตบรรทัดที่สองถึงบรรทัดสุดท้ายI took the one less traveled by,.

ฉากหลัง

คุณได้รับมอบหมายให้ช่วยให้นักผจญภัยคนตาบอดที่กำลังเดินอยู่บนท้องถนนและได้รับแรงบันดาลใจจากถนนไม่ได้ นักผจญภัยกำลังเข้ามาใกล้ทางแยกในถนนและต้องการใช้เส้นทางน้อยกว่าการเดินทางโดย คุณต้องค้นหาว่านักผจญภัยอยู่ที่ไหนและบอกนักผจญภัยว่าจะไปทางไหน

ความท้าทาย

เป้าหมายของคุณคือค้นหาถนนที่เดินทางน้อยที่สุดบนแผนที่ของคุณในที่ที่ถนนนั้นแยกออก แผนที่ของคุณเป็นสตริงที่มีการขึ้นบรรทัดใหม่ (หรือ\nหากคุณต้องการ) และมีความกว้างและความสูงที่ไม่รู้จัก ในแผนที่ถนนที่ถูกสร้างขึ้นจากตัวเลข 0 ถึง 9แยกเป็น#s คุณต้องค้นหาถนนที่คุณอยู่ในขณะนี้และออกจากถนนสายอื่นที่ถนนส่วนใหญ่เดินทางไปและถนนที่เดินทางน้อยกว่าสำหรับนักผจญภัยที่ตาบอดของคุณ วูดส์ในแผนที่ของคุณแสดงด้วยช่องว่าง นี่คือแผนที่ง่าย ๆ :

2   2
 1 0 
  #  
  2  
  2  

แผนที่นี้กว้าง 5 และสูง 5 สังเกตว่าถนนนั้นมีรูปร่างเป็น Y อย่างไร Y อาจจะเน้นไปทางใดทางหนึ่งดังนั้นคุณจะต้องสามารถเข้าใจแผนที่ "หมุน"

สิ่งที่#หมายถึง

#ซึ่งแผนที่ส้อมจะมี สิ่งนี้จะไม่ส่งผลกระทบต่อคะแนนของเส้นทางใด ๆ

สิ่งที่ตัวเลขจริงหมายถึง

แต่ละเส้นทาง (เส้นตัวเลขอาจมีโค้งงอในนั้น) มีคะแนน คะแนนของเส้นทางถูกกำหนดโดยการเพิ่มตัวเลขดังนั้นสำหรับตัวอย่างแรกเส้นทางแรก (จากซ้ายบนตามเข็มนาฬิกา) มีคะแนน 2 + 1 = 3 ที่สองมี 2 +0 = 2 และที่สาม มี 2 ​​+ 2 = 4 ถนนอาจมีหมายเลขที่เชื่อมต่อตามแนวทแยงมุม

ค้นหาที่ที่คุณอยู่

คุณอยู่บนเส้นทางที่มีคะแนนสูงสุด อีกสองเส้นทางคือถนนที่เดินทางผ่านและถนนนั้นเดินทางน้อยกว่า คุณต้องไปหาถนนที่มีคะแนนต่ำสุด

บอกนักเดินทางของคุณว่าจะไปที่ไหน

คุณต้องบอกให้นักเดินทางของคุณไปที่ "ซ้าย" หรือ "ถูกต้อง" โปรดทราบว่าเส้นทางมาจากมุมมองของนักเดินทาง (เขาหันหน้าเข้าหาทางแยก)

แผนที่ตัวอย่าง

  14
9#  
  04

ผลลัพธ์: "ถูกต้อง" (นักท่องเที่ยวอยู่ที่9ถนน 0 + 4 <1 + 4

  9  
  9  
  9  
  9  
  9  
  #  
 8 8 
 8 8 
88 88
8   7

เอาท์พุท: "ซ้าย" (นักท่องเที่ยวอยู่ที่99999ถนน 8 + 8 + 8 + 8 + 8> 8 + 8 + 8 + 8 + 7

02468      
     #98765
13579      

เอาท์พุท: "ถูกต้อง" (นักท่องเที่ยวอยู่ที่98765ถนน 0 + 2 + 4 + 6 + 8 <1 + 3 + 5 + 7 + 9)

4 2
4 2
 # 
 4 
 4 
 2 
 2 

เอาท์พุท: "ถูกต้อง" (นักท่องเที่ยวอยู่ที่4422ถนน 4 + 4> 2 + 2)

 9   
 9   
 9   
 #   
8 7  
8  7 
8   7

เอาท์พุท "ซ้าย" (นักท่องเที่ยวอยู่ที่999ถนน 8 + 8 + 8> 7 + 7 + 7

เรื่องน่ารู้:

• แผนที่จะเต็มไปด้วยช่องว่างเพื่อให้แต่ละบรรทัดมีความยาวเท่ากัน
• คุณต้องส่งออกไปยัง STDOUT / console / file สตริงleftหรือrightตามด้วยบรรทัดใหม่ต่อท้าย
• คุณต้องรับอินพุตเป็นสตริงที่มีบรรทัดใหม่, \ns หรืออาร์เรย์ / รายการของบรรทัด (แต่ละบรรทัดเป็นสตริง) ตำแหน่งที่ใส่จะต้องเป็นฟังก์ชั่นอาร์กิวเมนต์บรรทัดคำสั่งไฟล์หรือ STDIN หนึ่งบรรทัดในเวลาหรือคล้ายกัน ตัวแปรไม่ใช่อุปกรณ์อินพุตที่ยอมรับได้ (ยกเว้นว่าเป็นพารามิเตอร์ฟังก์ชัน) เช่นเดียวกันการแสดงออกของฟังก์ชันใน JS และภาษาอื่น ๆ จะต้องถูกกำหนดให้กับตัวแปร
• นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ!
• ช่องโหว่มาตรฐานต้องห้าม

สิ่งที่คุณสามารถสันนิษฐานได้

• ข้อมูลของคุณจะถูกต้อง จะไม่มีการทดสอบเช่นนี้สำหรับ:

0 0 0
 0 0
  #
 0 0

• คะแนนของเส้นทางจะไม่ถูกผูกไว้
• อินพุตอาจมีความกว้างหรือความยาวไม่เกินขีด จำกัด สตริงของภาษาของคุณ
• จะต้องมีอย่างน้อย 1 ช่องว่างระหว่าง 2 เส้นทาง
• เส้นทางอาจโค้งงอเลี้ยว ฯลฯ เป็นถนนไม่ใช่ทางหลวง

มีคำถามอะไรไหม? ถามฉันด้านล่างในความคิดเห็นและการเล่นกอล์ฟมีความสุข!

D , 348 321 312 302 ไบต์

import std.stdio,std.algorithm,std.regex,std.range;void h(R,U)(R s,U r){U[2]c;foreach(L;s.map!(a=>a.array.split)){U l=L.length-1;r>1?r=l^r-2:0;l?c[]+=l*L.map!sum.array[]:c;}write(c[r]>c[!r]?"right":"left");}void main(){auto s=stdin.byLineCopy.array;!s.join.match(`\d \d`)?h(s.transposed,2UL):h(s,3UL);}

Ungolfed

import std.stdio,std.algorithm,std.regex,std.range;

void h(R,U)(R s, U reverse) {
    U[2] counts;
    /* Now that all paths are up/down, every line we need to count up has
       precisely two space-delimited parts to sum up. */
    foreach (line; s.map!(a=>a.array.split)) {
        U len = line.length - 1;
        reverse > 1 ? reverse = len ^ reverse - 2 : 0;
        len ? counts[] += len * line.map!sum.array[] : counts;
    }

    /* Switch left/right as needed based on our orientation */
    write(counts[reverse] > counts[!reverse] ? "right" : "left");
}

void main() {
    /* Treat the input as a matrix of integers */
    auto s = stdin.byLineCopy.array;

    /* If moving left/right intead of up/down, transpose */
    !s.join.match(`\d \d`)?h(s.transposed,2UL):h(s,3UL);
}

ลองออนไลน์!

Python 2, 304 ไบต์

ลองออนไลน์

A=input()
S=str(A)[2:-2].replace("', '",'')
i=S.index('#')
r=len(A[0])
w=1
a=i/r
if' '<S[i-r]:w=-w;A=A[::w];a=len(A)+~a
if' '<S[i+1]:A=zip(*A[::-1]);a=i%r
if' '<S[i-1]:A=zip(*A)[::-1];a=len(A)-i%r-1
s=0
for c in' '.join(map(''.join,A[0:a])).split():s+=sum(map(int,c));s=-s
print['left','right'][::w][s>0]

โปรแกรมนี้ช่วยลดทอนทิศทางของถนนและหมุนมันขึ้นเพื่อใช้โซลูชันของฉันจากส่วนที่ 2 ของความท้าทายนี้