fundo

Alguns meses atrás, a aventura de sua vida estava prestes a começar. Agora, neste exato momento (sim, agora), depois de meses de sofrimento e trabalho duro, você e um grupo de amigos estão no topo do mundo. Sim, você está certo, você está no cume de Sagarmāthā .

No entanto, as coisas não estão indo tão bem quanto você gostaria. Uma névoa densa o cercou e uma tempestade incrivelmente feia está chegando o mais rápido possível. Você não prendeu nenhuma corda no caminho e suas pegadas foram cobertas de neve. Se você quiser sobreviver (pelo menos por hoje), precisará sair de lá o mais rápido possível, mas DEVE primeiro encontrar uma maneira de saber qual face da montanha é a que deve descer.

Felizmente, você trouxe seu telefone via satélite que modificou antes da viagem para poder programar e executar programas nele.

Desafio

Você conseguiu fazer o download para o seu telefone do mapa da montanha de um modo ASCII, à moda antiga, ilegível e no topo do mundo. Sua tarefa é decidir qual face da montanha apresenta a descida mais fácil, para que você possa aumentar suas chances de sobreviver. Para fazer isso, você tem a brilhante idéia de codificar um programa no seu telefone que indique qual é a maneira mais fácil. (Isenção de responsabilidade: essas atividades foram realizadas por profissionais. Nenhum programador foi ferido durante esta narração. Por favor, não tente fazer isso em casa.)

Os mapas são feitos apenas dos caracteres /e \(mais espaços e novas linhas). Em qualquer mapa, o cume da montanha é sempre representado por

 /\ 
 \/ 

e de cada um dos lados ( 1,2,3ou 4) do cume, você sempre encontrará um caminho "possível" descendo a montanha.

1 /\ 2
3 \/ 4

As rotas são sempre apresentadas da seguinte maneira:

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

onde cada novo personagem é um local à esquerda / direita de seu antecessor. O significado de cada personagem é:

• Se a barra / folga for paralela ao seu lado do cume -> conta como uma parte 'íngreme'.
• Se a barra / barra invertida é perpendicular ao lado do cume -> conta como uma parte 'plana'.

* Para referência adicional, veja o gráfico acima.

Nota : Os lados podem ter comprimentos diferentes e os caracteres que constituem o cume também contam como parte do seu lado. Em caso de empate, você pode escolher qualquer um deles.

As brechas padrão não são permitidas.

Entrada

Uma sequência que representa o mapa da montanha ou um arquivo de texto sem formatação que contém as mesmas informações.

Ou

C:\....\file.txt

ou

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

como uma string são entradas válidas.

Resultado

Como saída, você deve produzir um arquivo em texto sem formatação ou por padrão uma representação em perfil ASCII do lado com a menor inclinação íngreme usando _peças planas e /íngremes, juntamente com a inclinação íngreme do lado (number of "/")/(total chars).

Exemplo de saída para o mapa acima:

       /
   ___/
  /
  AS:0.5

O formato não é importante desde que você tenha o perfil e a inclinação média.

Pontuação

O que? Você quer uma recompensa melhor do que salvar a vida de você e de seu amigo e ser o primeiro programador que já programou no topo do mundo? Ok ... isso é código de golfe, então o programa mais curto em bytes vence.

Casos de teste

Entrada:

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

Resultado:

       /
   ___/
  /
  AS=0.5

Entrada:

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

Resultado:

______/
AS=0.143 (1/7)

Entrada:

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

Resultado:

        /        
       /
      /       
    _/
    AS=0.8

JavaScript (ES6), 303

Teste a execução do snippet em um navegador compatível com EcmaScript - certamente Firefox, provavelmente Chrome. Usando seqüências de caracteres de modelo, as funções de seta.

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