Nota: si basa su due strade divergenti in un bosco giallo (parte 2) , una mia precedente sfida. A causa della popolarità di quella domanda e due strade divergenti in un bosco giallo (parte 1) , ho voluto fare un terzo. Ma i primi 2 erano troppo facili (una risposta a 2 byte sul primo, una risposta a 15 byte sul secondo). Quindi ho reso qualcosa di più complesso ...

L'ispirazione

Questa sfida è ispirata al famoso poema di Robert Frost, The Road Not Taken :

Due strade divergevano in un bosco giallo,
e scusami non potevo viaggiare entrambe
ed essere un viaggiatore, a lungo mi fermai
e ne guardai giù il più lontano possibile
verso dove si piegava nel sottobosco;

... 2 paragrafi tagliati ...

Lo dirò con un sospiro
Da qualche parte secoli e secoli da qui:
due strade divergevano in un bosco, e io -
ho preso quella meno percorsa,
e questo ha fatto la differenza.

Notare la penultima riga I took the one less traveled by,,.

Il retroscena

Ti è stato assegnato il compito di aiutare un avventuriero cieco che cammina su una strada ed è stato ispirato da The Road Not Taken . L'avventuriero si sta avvicinando a un bivio e vorrebbe percorrere il sentiero meno percorso. Devi trovare dove si trova l'avventuriero e dire all'avventuriero dove rivolgersi.

La sfida

Il tuo obiettivo è trovare la strada meno percorsa sulla tua mappa in cui si biforca la strada. La tua mappa è una stringa contenente newline (o \n, se preferisci) e ha una larghezza e un'altezza sconosciute. Nella mappa, le strade sono costituite da cifre da 0 a 9 , l'intersezione è composta da #s. Devi trovare la strada in cui ti trovi attualmente, e fuori dalle altre strade la strada più percorsa e la strada meno percorsa dal tuo avventuriero cieco. Il bosco nella tua mappa è rappresentato da uno spazio. Ecco una semplice mappa:

2   2
 1 0 
  #  
  2  
  2  

Questa mappa è larga 5 e alta 5. Notare come la strada si biforca a forma di Y. La Y può essere orientata in qualsiasi modo, quindi devi essere in grado di comprendere una mappa "ruotata".

Cosa #significa

Dove la mappa si biforca ci sarà un #. Ciò non influisce sul punteggio di alcun percorso.

Cosa significano effettivamente i numeri

Ogni percorso (una linea di numeri, può contenere una curva) ha un punteggio. Il punteggio di un percorso viene determinato sommando le sue cifre, quindi per il primo esempio, il primo percorso (dall'alto a sinistra, in senso orario) ha un punteggio di 2 + 1 = 3, il secondo ha 2 + 0 = 2 e il terzo ha 2 + 2 = 4. Le strade possono contenere numeri collegati in diagonale.

Trovare dove sei

Sei sul percorso con il punteggio più alto. Gli altri 2 percorsi sono la strada più percorsa e la strada meno percorsa. Devi trovare la strada con il punteggio più basso .

Dire al tuo viaggiatore dove andare

Devi dire al tuo viaggiatore di andare "a sinistra" o "a destra". Tieni presente che le direzioni provengono dal punto di vista del tuo viaggiatore (è di fronte al bivio).

Mappe di esempio

  14
9#  
  04

Uscita: "destra" (il viaggiatore è sulla 9strada, 0 + 4 <1 + 4

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

Uscita: "a sinistra" (il viaggiatore è sulla 99999strada, 8 + 8 + 8 + 8 + 8> 8 + 8 + 8 + 8 + 7

02468      
     #98765
13579      

Uscita: "destra" (il viaggiatore è sulla 98765strada, 0 + 2 + 4 + 6 + 8 <1 + 3 + 5 + 7 + 9)

4 2
4 2
 # 
 4 
 4 
 2 
 2 

Uscita: "giusto" (il viaggiatore è sulla 4422strada, 4 + 4> 2 + 2)

 9   
 9   
 9   
 #   
8 7  
8  7 
8   7

Uscita "a sinistra" (il viaggiatore è sulla 999strada, 8 + 8 + 8> 7 + 7 + 7

Cose da sapere:

• Le mappe saranno riempite con spazi per rendere ogni linea della stessa lunghezza.
• È necessario eseguire l'output su STDOUT / console / file la stringa lefto right, facoltativamente, seguita da una nuova riga finale.
• È necessario prendere l'input come una stringa contenente newline, \ns o un array / elenco di righe (ogni riga è una stringa). Dove viene immesso tale input deve essere una funzione, argomento della riga di comando, file o STDIN una riga alla volta o simile. Una variabile non è un dispositivo di input accettabile (a meno che non sia un parametro di funzione). Allo stesso modo, le espressioni di funzione in JS e in altre lingue devono essere assegnate a una variabile.
• Questo è code-golf , quindi vince la risposta più breve in byte!
• Scappatoie standard vietate

Cose che puoi assumere

• Il tuo contributo sarà valido. Niente di simile sarà testato per:

0 0 0
 0 0
  #
 0 0

• I punteggi dei percorsi non saranno mai legati.
• L'input può essere di qualsiasi lunghezza in larghezza o altezza, inferiore al limite di stringa della tua lingua.
• Ci sarà sempre almeno 1 spazio tra i 2 percorsi.
• I percorsi possono avere curve, curve, ecc. Queste sono strade, non autostrade.

Hai delle domande? Chiedimi qui sotto nei commenti e buon golf!

D , 348 321 312 302 byte

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

Provalo online!

Python 2, 304 byte

Provalo online

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]

Questo programma deduce la direzione delle strade e la ruota verso l'alto per utilizzare la mia soluzione dalla parte 2 di questa sfida.