Antecedentes

Hace unos meses, la aventura de tu vida estaba a punto de comenzar. Ahora, en este preciso momento (sí, ahora), después de meses de sufrimiento y trabajo duro, usted y un grupo de amigos se encuentran en la cima del mundo. Sí, tienes razón, estás en la cima de Sagarmāthā .

Sin embargo, las cosas no van tan bien como te gustaría. Una densa niebla te ha rodeado y una tormenta increíblemente mala se acerca lo más rápido que puede. No arreglaste ninguna cuerda en el camino, y tus huellas han estado cubiertas de nieve. Si quieres sobrevivir (al menos por hoy), debes salir de allí lo más rápido que puedas, pero primero DEBES encontrar una manera de saber qué cara de la montaña es la que debes descender.

Afortunadamente, trajo consigo su teléfono satelital que modificó antes del viaje para que pueda programar y ejecutar programas en él.

Desafío

Has podido descargar en tu teléfono el mapa de la montaña de una manera ASCII, antigua, ilegible, en la cima del mundo. Su tarea es decidir qué cara de la montaña presenta el descenso más fácil para que pueda aumentar sus posibilidades de sobrevivir. Para hacerlo, tiene la brillante idea de codificar un programa en su teléfono que le dirá cuál es la forma más fácil de bajar. (Descargo de responsabilidad: Estas actividades han sido realizadas por profesionales. Ningún programador resultó herido durante esta narración. Por favor, no intente esto en casa).

Los mapas solo están hechos de los caracteres /y \(más espacios y líneas nuevas). En cualquier mapa, la cumbre de la montaña siempre está representada por

 /\ 
 \/ 

y desde cada uno de los lados ( 1,2,3o 4) de la cumbre siempre encontrarás un camino "posible" bajando la montaña.

1 /\ 2
3 \/ 4

Las rutas siempre se presentan de la siguiente manera:

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

donde cada nuevo personaje es un lugar a la izquierda / derecha de su predecesor. El significado de cada personaje es:

• Si la barra oblicua / reacción es paralela a su lado de la cumbre -> cuenta como una parte 'empinada'.
• Si la barra oblicua / barra invertida es perpendicular a su lado de la cumbre -> cuenta como una parte 'plana'.

* Para mayor referencia ver gráfico arriba.

Nota : Los lados pueden tener diferentes longitudes y los personajes que constituyen la cumbre también cuentan como parte de su lado. En caso de empate, puede elegir cualquiera de ellos.

Las lagunas estándar no están permitidas.

Entrada

Una cadena que representa el mapa de la montaña o un archivo de texto sin formato que contiene la misma información.

Ya sea

C:\....\file.txt

o

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

como una cadena son entradas válidas.

Salida

Como salida, debe producir un archivo en texto plano o mediante una representación estándar de perfil ASCII del lado con la menor inclinación promedio usando _para partes planas y /para partes empinadas junto con la inclinación promedio del lado (number of "/")/(total chars).

Ejemplo de salida para el mapa anterior:

       /
   ___/
  /
  AS:0.5

El formato no es importante siempre que tenga el perfil y la inclinación promedio.

Puntuación

¿Qué? ¿Desea una mejor recompensa que salvarle la vida a usted y a su amigo y ser el primer programador que haya programado en la cima del mundo? De acuerdo ... este es el código de golf, por lo que gana el programa más corto en bytes.

Casos de prueba

Entrada:

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

Salida:

       /
   ___/
  /
  AS=0.5

Entrada:

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

Salida:

______/
AS=0.143 (1/7)

Entrada:

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

Salida:

        /        
       /
      /       
    _/
    AS=0.8

JavaScript (ES6), 303

Pruebe ejecutar el golpe de fragmento en un navegador compatible con EcmaScript, seguramente Firefox, probablemente Chrome. Usando cadenas de plantillas, funciones de flecha.

// 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>