Dalam terminologi pendakian gunung, "14er" adalah gunung apa pun dengan ketinggian 14.000 kaki atau lebih. Namun, ada perbedaan lain. Agar suatu puncak dapat dihitung sebagai 14er, puncak juga harus memiliki "keunggulan geografis" sebesar 300 kaki atau lebih. Ini berarti bahwa untuk bergerak dari satu 14er ke yang lain, Anda harus turun setidaknya 300 kaki sebelum naik lagi. Ambil contoh ini. Baris 1 dihitung sebagai 14 000 kaki, dan setiap baris dihitung sebagai 100 kaki.

  /\__/\  
 /      \ 
/        \

Sekarang, kedua puncak ini memiliki ketinggian yang cukup untuk dihitung, tetapi tidak ada penurunan ketinggian yang cukup di antara mereka untuk dihitung sebagai dua puncak yang terpisah. Oleh karena itu, salah satu dari ini dianggap sebagai 14er, dan yang lainnya hanya "puncak parsial". Berikut adalah contoh di mana kedua puncak dihitung sebagai dua 14er yang terpisah:

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

Mungkin juga ada puncak parsial pada penurunan antara dua 14ers. Berikut adalah versi pegunungan terakhir yang sedikit dimodifikasi:

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

Pegunungan ini juga dihitung sebagai dua 14ers.

Anda harus menulis sebuah program atau fungsi yang mengambil representasi ascii-art dari pegunungan, dan mengembalikan berapa banyak 14ers yang ada dalam jangkauan. Anda dapat mengambil input dalam format apa pun yang paling nyaman bagi Anda, baik itu array karakter 2D, string dengan baris baru, atau string dengan pembatas lainnya. Anda dapat mengasumsikan bahwa semua input hanya akan berisi karakter /\_, dan bahwa panjang setiap baris akan sama (termasuk spasi tambahan). Anda juga dapat mengasumsikan bahwa pegunungan dimulai di sudut kiri bawah dengan a /atau a _.

Jika bagian terakhir dari sebuah gunung tidak di garis bawah, Anda dapat mengasumsikan bahwa gunung hanya berkurang setelah itu, misalnya

  /
 /
/

Dihitung sebagai 14er tunggal.

Anda tidak harus menangani pegunungan yang tidak valid.

Berikut ini beberapa contoh I / O:

         /\___/\_             
        /        \    /\      
       /          \  /  \     
   _/\/            \/    \    
  /                       \   
 /                         \  
/                           \_

2

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

4

       /\                 
 _/\__/  \                
/         \               

1

      /\                  
     /  \   /\            
    /    \_/  \           
   /           \          
  /             \         
 /               \        
/                 \       

1

              /\          
    /\_/\    /  \_        
   /     \  /     \     /\
  /       \/       \   /  
 /                  \_/   
/                         

3

JavaScript (ES6), 133 byte

s=>[...s].map((_,i)=>(c=s[i%h*w+i/h|0])=="/"?++a>2&&(p+=!d,d=a=3):c=="\\"&&--a<1&&(d=a=0),w=s.search`
`+1,h=-~s.length/w,a=3,d=p=1)|p

Penjelasan

Karena spesifikasinya tidak dinyatakan dengan jelas, ini membuat beberapa asumsi:

• Intinya adalah tanda 14.000 kaki (sehingga semua posisi pada grid cukup tinggi untuk dihitung sebagai puncak).
• Grid dimulai pada (atau menanjak) puncak pertama (karena setidaknya sudah mencapai ketinggian 14.000 kaki seperti asumsi sebelumnya).
• Puncak yang terpisah hanya dihitung setelah turun 300 kaki kemudian naik 300 kaki .

Iterasi karakter karakter cmasing-masing kolom (khusus, iterate setiap kolom sampai menemukan karakter). Ketinggian saat ini disimpan di a. Itu dijepit ke minimum 0dan maksimum 3. Arah yang diperlukan untuk bergerak untuk menghitung puncak selanjutnya disimpan di d( false= atas, true= bawah). Jika amencapai 3dan dsedang false, jumlah puncak pbertambah dan ddiatur ke true(bawah). Setelah amencapai 0, ddiatur kembali ke false(atas).

var solution =

s=>
  [...s].map((_,i)=>   // loop
    (c=s[i%h*w+i/h|0]) // c = current character (moves down columns)
    =="/"?             // if c is '/'
      ++a>2&&          // increment a, if a equals 3 and d is true:
        (p+=!d,d=a=3)  // increment p, set d to true, clamp a to 3
    :c=="\\"&&         // if c is '\':
      --a<1&&          // decrement a, if a equals 0:
        (d=a=0),       // set d to false, clamp a to 0
    
    // Initialisation (happens BEFORE the above code)
    w=s.search`\n`+1,  // w = grid width
    h=-~s.length/w,    // h = grid height
    a=3,               // a = current altitude (min = 0, max = 3)
    d=                 // d = required direction (false = up, true = down)
    p=1                // p = number of found peaks
  )|p                  // output the number of peaks

var testCases = [`
/\\
`,`
/\\          
  \\         
   \\    /\\  
    \\  /  \\ 
     \\/    \\
`,`
\\    /
 \\  / 
  \\/  
`,`
            /\\            
         /\\/  \\/\\         
      /\\/        \\/\\      
   /\\/              \\/\\   
/\\/                    \\/\\
`,`
  /\\__/\\
 /      \\
/        \\
`,`
   /\\    /\\   
  /  \\  /  \\  
 /    \\/    \\ 
/            \\
`,`
   /\\      /\\   
  /  \\/\\  /  \\  
 /      \\/    \\ 
/              \\
`,`
         /\\___/\\_             
        /        \\    /\\      
       /          \\  /  \\     
   _/\\/            \\/    \\    
  /                       \\   
 /                         \\  
/                           \\_
`,`
                  /\\    /\\
         /\\      /  \\  /  
  /\\    /  \\    /    \\/   
 /  \\  /    \\  /          
/    \\/      \\/           
`,`
       /\\                 
 _/\\__/  \\                
/         \\               
`,`
      /\\                  
     /  \\   /\\            
    /    \\_/  \\           
   /           \\          
  /             \\         
 /               \\        
/                 \\       
`,`
              /\\          
    /\\_/\\    /  \\_        
   /     \\  /     \\     /\\
  /       \\/       \\   /  
 /                  \\_/   
/                         
`];
result.textContent = testCases.map(c=>c+"\n"+solution(c.slice(1,-1))).join`\n\n`;

<textarea id="input" rows="6" cols="40"></textarea><br /><button onclick="result.textContent=solution(input.value)">Go</button><pre id="result"></pre>

C, 174 byte

a[99],c,p,j,M,m;main(i){for(i=j=1;c=getchar(),~c;i++)c<11?a[i]=j++,i=0:c&4?a[i]=j:0;for(m=j;c=a[i++];c>a[i-2]?M-m>1&&c-m>1?M=c,m=j,p++:M<c?M=m=c:M:m>c?m=c:0);printf("%d",p);}

Membutuhkan baris tambahan di input, jika tidak +4 byte.

JavaScript (ES6), 154 byte

s=>s.split`\n`.map((s,i)=>s.replace(/\S/g,(c,j)=>{e[j]=i+(c!='\\');e[j+1]=i+(c>'/')}),e=[])&&e.map(n=>h-n+d?h-n-d*3?0:(c++,d=-d,h=n):h=n,h=e[0],c=d=1)|c>>1

Dimana \nmewakili karakter baris baru literal. Tidak Disatukan:

function climb(string) {
    var heights = [];
    // Split the array into lines so that we know the offset of each char
    var array = string.split("\n");
    // Calculate the height (actually depth) before and after each char
    for (var i = 0; i < array.length; i++) {
        for (var j = 0; j < string.length; j++) {
            switch (array[i][j]) {
            case '\':
                heights[j] = i;
                heights[j+1] = i + 1;
                break;
            case '_':
                heights[j] = i + 1;
                heights[j+1] = i + 1;
                break;
            case '/':
                heights[j] = i + 1;
                heights[j+1] = i;
                break;
        }
    }
    var count = 1;
    // Start by looking for an upward direction
    var direction = 1;
    var height = heights[0];
    for (var k = 1; k < heights.length; k++) {
        if (heights[i] == height - direction * 3) { // peak or trough
            direction *= -1;
            count++; // we're counting changes of direction = peaks * 2
            height = heights[i];
        } else if (heights[i] == height + direction) {
            // Track the current peak or trough to the tip or base
            height = heights[i];
        }
    }
    return count >> 1;
}