W terminologii alpinistycznej „14er” oznacza dowolną górę o wysokości co najmniej 14 000 stóp. Istnieje jednak inne rozróżnienie. Aby szczyt mógł być liczony jako 14er, musi również mieć „ekspozycję geograficzną” wynoszącą 300 stóp lub więcej. Oznacza to, że aby przejść z jednego 14er do drugiego, musisz najpierw zejść co najmniej 300 stóp, zanim ponownie wstaniesz . Weź ten przykład. Linia 1 liczy się jako 14 000 stóp, a każda linia liczy się jako 100 stóp.

  /\__/\  
 /      \ 
/        \

Teraz oba te szczyty mają wystarczającą wysokość, aby liczyć, ale nie ma wystarczającego spadku wysokości między nimi, aby liczyć się jako dwa osobne szczyty. Dlatego jeden z nich liczy się jako 14er, a drugi jest tylko „częściowym pikiem”. Oto przykład, w którym dwa szczyty liczą się jako dwa oddzielne 14er:

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

Może również wystąpić częściowy szczyt spadku między dwoma czternastolatkami. Oto nieco zmodyfikowana wersja ostatniego pasma górskiego:

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

Ten łańcuch górski liczy się również jako dwa 14-osobowe.

Musisz napisać program lub funkcję, która przyjmuje ascii-artystyczną reprezentację pasma górskiego, i zwrócić, ile 14er jest w zasięgu. Możesz wprowadzać dane w dowolnym formacie, który jest dla ciebie najwygodniejszy, czy to tablica znaków 2D, ciąg znaków z nową linią, czy ciąg znaków z innym ogranicznikiem. Możesz założyć, że wszystkie dane wejściowe będą zawierały tylko znaki /\_i że długość każdego wiersza będzie taka sama (w tym końcowe spacje). Możesz także założyć, że pasmo górskie zaczyna się w lewym dolnym rogu literą a /lub a _.

Jeśli ostatni odcinek góry nie znajduje się na dolnej linii, możesz założyć, że góra następnie maleje, np

  /
 /
/

Liczy się jako pojedynczy 14er.

Nie musisz obsługiwać nieprawidłowych pasm górskich.

Oto kilka przykładowych operacji we / wy:

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

2

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

4

       /\                 
 _/\__/  \                
/         \               

1

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

1

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

3

JavaScript (ES6), 133 bajty

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

Wyjaśnienie

Ponieważ specyfikacje nie są jasno określone, czyni to kilka założeń:

• Dolna linia to znak 14 000 stóp (więc wszystkie pozycje na siatce są wystarczająco wysokie, aby liczyć się jako szczyt).
• Siatka zaczyna się od (lub wznosząc) pierwszego szczytu (ponieważ ma już co najmniej 14 000 stóp wysokości, zgodnie z poprzednim założeniem).
• Oddzielny szczyt liczy się dopiero po zejściu 300 stóp, a następnie wzniesieniu 300 stóp .

Iteruje po znaku ckażdej kolumny (w szczególności iteruje każdą kolumnę, aż znajdzie znak). Aktualna wysokość jest zapisana w a. Jest ograniczony do minimum 0i maksimum 3. Kierunek potrzebny do przejścia do zliczenia następnego piku jest zapisany w d( false= w górę, true= w dół). Jeśli aosiągnie 3i djest false, liczba pików pjest zwiększana i djest ustawiana na true(w dół). Po abiegu 0, dto zestaw z powrotem false(w górę).

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 bajtów

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

Wymaga wejścia nowego wiersza na wejściu, w przeciwnym razie +4 bajty.

JavaScript (ES6), 154 bajty

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

Gdzie \nreprezentuje dosłowny znak nowej linii. Nie golfowany:

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