Hintergrund

Vor ein paar Monaten begann das Abenteuer Ihres Lebens. Nun, genau in diesem Moment (ja, jetzt) ​​stehen Sie und eine Gruppe von Freunden nach Monaten des Leidens und der harten Arbeit auf der Weltspitze. Ja, du hast recht, du bist auf dem Gipfel des Sagarmāthā .

Es läuft jedoch nicht so, wie Sie es möchten. Ein dichter Nebel hat dich umgeben und ein unglaublich schlecht aussehender Sturm kommt so schnell es geht. Sie haben auf dem Weg nach oben kein Seil repariert und Ihre Fußabdrücke sind mit Schnee bedeckt. Wenn Sie überleben wollen (zumindest für heute), müssen Sie so schnell wie möglich von dort verschwinden, aber Sie MÜSSEN zuerst einen Weg finden, um herauszufinden, welches Gesicht des Berges das ist, das Sie herabsteigen sollten.

Glücklicherweise haben Sie Ihre gebracht Satellitentelefon , die Sie vor der Reise so modifiziert , dass Sie in der Lage zu programmieren sind und Ausführen von Programmen in ihm.

Herausforderung

Sie konnten die Karte des Berges auf eine ASCII-altmodische, nicht lesbare Art und Weise auf Ihr Telefon herunterladen. Ihre Aufgabe ist es, zu entscheiden, welches Gesicht des Berges die einfachste Abfahrt darstellt, damit Sie Ihre Überlebenschancen erhöhen können. Zu diesem Zweck haben Sie die brillante Idee, ein Programm auf Ihrem Telefon zu programmieren, mit dem ermittelt wird, welcher Weg am einfachsten ist. (Haftungsausschluss: Diese Aktivitäten wurden von Fachleuten durchgeführt. Während dieser Erzählung wurde kein Programmierer verletzt. Bitte versuchen Sie dies nicht zu Hause.)

Karten bestehen nur aus den Zeichen /und \(plus Leerzeichen und Zeilenumbrüchen). In jeder Karte wird der Gipfel des Berges immer durch dargestellt

 /\ 
 \/ 

und von jeder Seite ( 1,2,3oder 4) des Gipfels finden Sie immer einen "möglichen" Weg den Berg hinunter.

1 /\ 2
3 \/ 4

Die Routen werden immer wie folgt dargestellt:

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

Dabei ist jedes neue Zeichen eine Stelle links / rechts vom Vorgänger. Die Bedeutung jedes Zeichens ist:

• Wenn der Schrägstrich / das Spiel parallel zur Gipfelseite verläuft -> gilt als "steiler" Teil.
• Wenn der Schrägstrich / Backslash senkrecht zur Gipfelseite steht -> gilt als 'flacher' Teil.

* Weitere Informationen finden Sie in der obigen Grafik.

Hinweis : Die Seiten können unterschiedlich lang sein und die Zeichen, aus denen sich der Gipfel zusammensetzt, zählen ebenfalls zu ihrer Seite. Im Falle eines Unentschieden können Sie eine davon auswählen.

Standardlücken sind nicht zulässig.

Eingang

Eine Zeichenfolge, die die Karte des Berges darstellt, oder eine einfache Textdatei mit denselben Informationen.

Entweder

C:\....\file.txt

oder

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

als String sind gültige Eingaben.

Ausgabe

Als Ausgabe, sollten Sie entweder eine Datei im Klartext oder durch stdout eine erzeugen ASCII Profildarstellung von der Seite mit der kleinsten durchschnittlichen Steilheit mit _für flache Teile und /für steile Teile zusammen mit der durchschnittlichen Steilheit der Seite (number of "/")/(total chars).

Ausgabebeispiel für Karte oben:

       /
   ___/
  /
  AS:0.5

Das Format ist nicht wichtig, solange Sie das Profil und die durchschnittliche Steilheit haben.

Wertung

Was? Wünschen Sie sich eine bessere Belohnung, als das Leben Ihres Freundes und Ihres Freundes zu retten und der erste Programmierer zu sein, der jemals auf der Weltspitze programmiert hat? Okay ... das ist Codegolf, also gewinnt das kürzeste Programm in Bytes.

Testfälle

Eingang:

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

Ausgabe:

       /
   ___/
  /
  AS=0.5

Eingang:

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

Ausgabe:

______/
AS=0.143 (1/7)

Eingang:

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

Ausgabe:

        /        
       /
      /       
    _/
    AS=0.8

JavaScript (ES6), 303

Testen Sie den Snippet Blow in einem EcmaScript-kompatiblen Browser - sicherlich Firefox, wahrscheinlich Chrome. Verwenden von Vorlagenzeichenfolgen und Pfeilfunktionen.

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