Dağcılık terminolojisinde "14er", 14000 feet veya daha fazla yüksekliğe sahip herhangi bir dağdır. Ancak başka bir ayrım daha var. Bir zirvenin 14er olarak sayılması için, 300 veya daha fazla fitlik bir "coğrafi öneme" sahip olması gerekir. Bu, bir 14er'den diğerine geçmek için, tekrar yükselmeden önce en az 300 feet inmeniz gerekir . Bu örneği ele alalım. Satır 1 14000 feet, her satır 100 fit olarak sayılır.

  /\__/\  
 /      \ 
/        \

Şimdi, bu zirvelerin her ikisi de saymak için yeterli yüksekliğe sahip, ancak aralarında iki ayrı tepe olarak saymak için yeterli yükseklik düşüşü yok. Bu nedenle, bunlardan biri 14er sayılır ve diğeri sadece "kısmi bir zirve" dir. İki zirvenin iki ayrı 14er olarak sayıldığı bir örnek:

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

İki 14er arasındaki düşüşte kısmi bir tepe de olabilir. İşte son dağ aralığının biraz değiştirilmiş bir versiyonu:

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

Bu dağ sırası aynı zamanda iki tane 14er.

Bir dağ aralığının ascii-art temsilini alan bir program veya işlev yazmalı ve aralıkta kaç 14er döndürmelisiniz. 2D karakter dizisi, yeni satırlı bir dize veya başka bir sınırlayıcıya sahip bir dize olsun, sizin için en uygun formatta girdi alabilirsiniz. Tüm girişlerin yalnızca karakter içereceğini /\_ve her satırın uzunluğunun aynı olacağını varsayabilirsiniz (arka boşluklar dahil). Dağ aralığının sol alt köşede a /veya a ile başladığını varsayabilirsiniz _.

Bir dağın son bölümü en alt satırda değilse, dağın ancak bundan sonra azaldığını varsayabilirsiniz, örn.

  /
 /
/

Tek bir 14er olarak sayılır.

Geçersiz dağ sıralarını idare etmek zorunda değilsiniz.

İşte bazı örnek I / O:

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

2

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

4

       /\                 
 _/\__/  \                
/         \               

1

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

1

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

3

JavaScript (ES6), 133 bayt

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

açıklama

Spesifikasyonlar açıkça belirtilmediğinden, bu birkaç varsayım yapar:

• Alt satır 14.000ft işaretidir (bu nedenle ızgaradaki tüm konumlar bir tepe noktası olarak kabul edilebilecek kadar yüksektir).
• Izgara ilk zirvede başlar (veya yükselir) (çünkü önceki varsayımlara göre en az 14.000ft yüksekliğindedir).
• Ayrı bir zirve sadece 300ft inip sonra 300ft yükseldikten sonra sayılır .

cHer sütunun karakteri üzerinde yinelenir (özellikle, bir karakter bulana kadar her sütunu tekrarlar). Geçerli yükseklik, içinde saklanır a. Minimum 0ve maksimum olarak kelepçelenir 3. Bir sonraki zirveyi saymak için hareket etmek için gereken yön kaydedilir d( false= yukarı, true= aşağı). Eğer aulaşır 3ve dbir false, tepe sayısı partırılır ve dayarlanır true(aşağı). Bir kez aulaşıldığında 0, (yukarı) dayarına geri alınır false.

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 bayt

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);}

Girişte sondaki bir yeni satır gerektirir, aksi takdirde +4 bayt.

JavaScript (ES6), 154 bayt

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

Burada \ngerçek satırsonu karakterini temsil eder. Ungolfed:

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;
}