Latar Belakang

Beberapa bulan yang lalu, petualangan hidup Anda baru saja akan dimulai. Sekarang, di saat yang tepat ini (ya, sekarang), setelah berbulan-bulan penderitaan dan kerja keras, Anda dan sekelompok teman berdiri di puncak dunia. Ya, Anda benar, Anda berada di puncak Sagarmāthā .

Namun, segala sesuatunya tidak berjalan sebaik yang Anda inginkan. Kabut tebal telah menyelimuti Anda dan badai yang tampak sangat buruk datang secepat mungkin. Anda tidak memperbaiki tali apa pun di jalan, dan jejak kaki Anda telah tertutup salju. Jika Anda ingin bertahan hidup (setidaknya untuk hari ini), Anda harus keluar dari sana secepat mungkin, tetapi Anda HARUS menemukan cara untuk mengetahui wajah gunung mana yang harus Anda turuni.

Untungnya, Anda membawa ponsel sat Anda yang telah dimodifikasi sebelum perjalanan sehingga Anda dapat memprogram dan menjalankan program di dalamnya.

Tantangan

Anda dapat mengunduh peta gunung di ponsel Anda dengan cara ASCII-kuno-tidak-terbaca-di-atas-dunia. Tugas Anda adalah memutuskan wajah gunung mana yang memberikan keturunan paling mudah sehingga Anda dapat meningkatkan peluang Anda untuk bertahan hidup. Untuk melakukannya, Anda memiliki ide cemerlang untuk membuat kode suatu program pada ponsel Anda yang akan memberi tahu jalan mana yang paling mudah. (Penafian: Kegiatan ini telah dilakukan oleh para profesional. Tidak ada programmer yang terluka selama narasi ini. Tolong, jangan coba ini di rumah.)

Peta hanya terbuat dari karakter /dan \(ditambah spasi dan baris baru). Di peta mana pun, puncak gunung selalu diwakili oleh

 /\ 
 \/ 

dan dari masing-masing sisi ( 1,2,3atau 4) puncak Anda akan selalu menemukan jalan yang "mungkin" menuruni gunung.

1 /\ 2
3 \/ 4

Rute selalu disajikan dengan cara berikut:

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

di mana setiap karakter baru adalah satu tempat di kiri / kanan pendahulunya. Arti setiap karakter adalah:

• Jika garis miring / reaksi sejajar dengan sisi puncaknya -> dianggap sebagai bagian 'curam'.
• Jika garis miring / garis miring terbalik tegak lurus terhadap sisi puncaknya -> dianggap sebagai bagian 'rata'.

* Untuk referensi lebih lanjut lihat gambar di atas.

Catatan : Sisi dapat memiliki panjang yang berbeda dan karakter yang membentuk puncak juga dihitung sebagai bagian dari sisi mereka. Dalam hal pengundian, Anda dapat memilih salah satunya.

Celah standar tidak diijinkan.

Memasukkan

String yang mewakili peta gunung atau file teks biasa yang berisi info yang sama.

Antara

C:\....\file.txt

atau

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

sebagai string adalah input yang valid.

Keluaran

Sebagai output, Anda harus menghasilkan file dalam teks biasa atau dengan menampilkan profil ASCII dari sisi dengan kecuraman rata-rata terkecil yang digunakan _untuk bagian datar dan /untuk bagian curam bersama dengan kecuraman rata-rata sisi (number of "/")/(total chars).

Contoh output untuk peta di atas:

       /
   ___/
  /
  AS:0.5

Formatnya tidak penting selama Anda memiliki profil dan kecuraman rata-rata.

Mencetak gol

Apa? Apakah Anda menginginkan hadiah yang lebih baik daripada menyelamatkan nyawa Anda dan teman Anda dan menjadi programmer pertama yang pernah diprogram di puncak dunia? Oke ... ini kode golf, jadi program terpendek dalam byte menang.

Uji kasus

Memasukkan:

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

Keluaran:

       /
   ___/
  /
  AS=0.5

Memasukkan:

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

Keluaran:

______/
AS=0.143 (1/7)

Memasukkan:

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

Keluaran:

        /        
       /
      /       
    _/
    AS=0.8

JavaScript (ES6), 303

Tes menjalankan potongan snippet di browser yang mendukung EcmaScript - pasti Firefox, mungkin Chrome. Menggunakan string template, fungsi panah.

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