sfondo

Qualche mese fa, l'avventura della tua vita stava per iniziare. Ora, in questo preciso momento (sì, ora), dopo mesi di sofferenza e duro lavoro, tu e un gruppo di amici siete in cima al mondo. Sì, hai ragione, sei sulla cima del Sagarmāthā .

Tuttavia, le cose non vanno come vorresti. Una fitta nebbia ti ha circondato e una tempesta incredibilmente brutta sta arrivando il più velocemente possibile. Non hai riparato nessuna corda durante la salita e le tue impronte sono state coperte di neve. Se vuoi sopravvivere (almeno per oggi), devi uscire da lì il più velocemente possibile, ma DEVI prima trovare un modo per sapere quale faccia della montagna è quella che dovresti scendere.

Fortunatamente, hai portato con te il tuo telefono satellitare che hai modificato prima del viaggio in modo da poter programmare ed eseguire programmi al suo interno.

Sfida

Sei stato in grado di scaricare sul tuo telefono la mappa della montagna in un modo ASCII vecchio stile illeggibile sulla cima del mondo. Il tuo compito è decidere quale faccia della montagna presenta la discesa più semplice in modo da poter aumentare le tue possibilità di sopravvivere. Per fare ciò, hai la brillante idea di codificare un programma sul tuo telefono che dirà qual è il modo più semplice verso il basso. (Dichiarazione di non responsabilità: queste attività sono state svolte da professionisti. Nessun programmatore è stato ferito durante questa narrazione. Per favore, non provarlo a casa.)

Le mappe sono costituite solo da personaggi /e \(più spazi e nuove righe). In qualsiasi mappa, la cima della montagna è sempre rappresentata da

 /\ 
 \/ 

e da ciascuno dei lati ( 1,2,3o 4) della cima troverete sempre una "possibile" strada lungo la montagna.

1 /\ 2
3 \/ 4

I percorsi sono sempre presentati nel modo seguente:

                      \
  Steep-> /          /
           /        / <-Flat
            /      \
      Flat-> \    \
              /  \ <-Steep
               /\
               \/

dove ogni nuovo personaggio è un posto a sinistra / a destra del suo predecessore. Il significato di ogni personaggio è:

• Se la barra / gioco è parallela al suo lato superiore -> conta come una parte "ripida".
• Se la barra / barra rovesciata è perpendicolare al suo lato superiore -> conta come una parte "piatta".

* Per ulteriori riferimenti vedere il grafico sopra.

Nota : i lati possono avere lunghezze diverse e anche i personaggi che costituiscono il vertice fanno parte del loro lato. In caso di pareggio, puoi sceglierne uno qualsiasi.

Le scappatoie standard non sono ammesse.

Ingresso

Una stringa che rappresenta la mappa della montagna o un file di testo semplice contenente le stesse informazioni.

O

C:\....\file.txt

o

                  \
      /          /
       /        /
        /      \
         \    \
          /  \
           /\
           \/
          \  /
         \    \
        \      \
       \        \
      /          /

come stringa sono input validi.

Produzione

Come output, dovresti produrre un file in testo normale o stdout di una rappresentazione del profilo ASCII del lato con la pendenza media più piccola usando _per le parti piatte e /per le parti ripide insieme alla pendenza media del lato (number of "/")/(total chars).

Esempio di output per la mappa sopra:

       /
   ___/
  /
  AS:0.5

Il formato non è importante finché hai il profilo e la pendenza media.

punteggio

Che cosa? Vuoi una ricompensa migliore che salvare la vita tua e dei tuoi amici ed essere il primo programmatore che abbia mai programmato in cima al mondo? Okay ... questo è il golf del codice, quindi vince il programma più breve in byte.

Casi test

Ingresso:

                  \
      /          /
       /        /
        /      \
         \    \
          /  \
           /\
           \/
          \  /
         \    \
        \      \
       \        \
      /          /

Produzione:

       /
   ___/
  /
  AS=0.5

Ingresso:

                  /
      \          /
       /        /
        \      /
         \    /
          /  /
           /\
           \/
          \  /
         \    \
        \      \
       \        \
      /          /
     / 
    / 

Produzione:

______/
AS=0.143 (1/7)

Ingresso:

           /        \
            \      \
             /    /
              /  \
               /\
               \/
              \  /
             \    /
            \      /
           /        \

Produzione:

        /        
       /
      /       
    _/
    AS=0.8

JavaScript (ES6), 303

Prova a eseguire lo snippet in un browser conforme a EcmaScript: sicuramente Firefox, probabilmente Chrome. Utilizzando stringhe di modelli, funzioni freccia.

// Golfed, no indentenation, all newlines are significant

f=s=>(s=`
${s}
`.split`
`,s.map((r,i)=>~(q=r.search(/\/\\/))&&(y=i,x=q),x=y=0),z=[],[0,2,0,2].map((d,i)=>{t=x+i%2,u=y+i/2|0,b=s[u][t];for(p=[''],n=l=0;(c=s[u][t])>' ';++l,t+=d-1,u+=(i&2)-1)c==b?p.push(p[n++].replace(/./g,' ',w='/')):w='_',p=p.map((r,i)=>(i<n?' ':w)+r);z=z[0]<(p[0]=n/l)?z:p}),z.join`
`)

// Less golfed

U=s=>(
  s=(`\n${s}\n`).split`\n`,
  x = y = 0,
  s.map((r,i)=>~(q=r.search(/\/\\/))&&(y=i,x=q)),
  z=[],
  [0,2,0,2].map((d,i) => {
    t = x+i%2,
    u = y+i/2|0,
    b = s[u][t];
    for(p=[''], n=l=0; (c=s[u][t])>' '; ++l, t += d-1, u +=(i&2)-1)
      c == b
        ? p.push(p[n++].replace(/./g,' ',w='/'))
        : w='_',
      p = p.map((r,i) => (i<n?' ':w)+r);
    z = z[0]<(p[0]=n/l)?z:p
  }),
  z.join`\n`
)

// TEST
// redirect console into the snippet body
console.log=x=>O.innerHTML+=x+'\n'

maps=[ // as javascript string literals, each baskslasch has to be repeated
`                  \\
      /          /
       /        /
        /      \\
         \\    \\
          /  \\
           /\\
           \\/
          \\  /
         \\    \\
        \\      \\
       \\        \\
      /          /`,
`                  /
      \\          /
       /        /
        \\      /
         \\    /
          /  /
           /\\
           \\/
          \\  /
         \\    \\
        \\      \\
       \\        \\
      /          /
     / 
    / `,
`           /        \\
            \\      \\
             /    /
              /  \\
               /\\
               \\/
              \\  /
             \\    /
            \\      /
           /        \\`]

maps.forEach(m=>console.log(m + '\n'+ f(m) +'\n'))

<pre id=O></pre>