In der Bergsteigerterminologie ist ein "14er" jeder Berg mit einer Höhe von 14.000 Fuß oder mehr. Es gibt jedoch einen anderen Unterschied. Damit ein Gipfel als 14er zählt, muss er auch eine "geografische Bekanntheit" von 300 oder mehr Fuß haben. Dies bedeutet, dass Sie, um von einem 14er zum anderen zu gelangen, mindestens 300 Fuß absteigen müssen, bevor Sie wieder aufstehen. Nehmen Sie dieses Beispiel. Zeile 1 zählt als 14 000 Fuß, und jede Zeile zählt als 100 Fuß.

  /\__/\  
 /      \ 
/        \

Jetzt haben diese beiden Peaks genug Höhe, um zu zählen, aber es gibt nicht genug Höhenunterschiede zwischen ihnen, um als zwei separate Peaks zu zählen. Daher zählt einer von diesen als ein 14er, und der andere ist nur ein "Teilpeak". Hier ist ein Beispiel, in dem die beiden Peaks als zwei separate 14er zählen:

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

Es kann auch eine teilweise Spitze des Rückgangs zwischen zwei 14ern geben. Hier ist eine leicht modifizierte Version der letzten Bergkette:

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

Diese Bergkette zählt auch als zwei 14er.

Sie müssen ein Programm oder eine Funktion schreiben, die eine Ascii-Art-Darstellung eines Gebirges übernimmt, und zurückgeben, wie viele 14er sich im Bereich befinden. Sie können Eingaben in jedem für Sie am besten geeigneten Format vornehmen, sei es ein 2D-Array von Zeichen, eine Zeichenfolge mit Zeilenumbruch oder eine Zeichenfolge mit einem anderen Trennzeichen. Sie können davon ausgehen, dass alle Eingaben nur die Zeichen enthalten /\_und dass die Länge jeder Zeile gleich ist (einschließlich Leerzeichen am Ende). Sie können auch davon ausgehen, dass die Bergkette in der linken unteren Ecke mit einem /oder einem beginnt _.

Befindet sich der letzte Abschnitt eines Berges nicht in der untersten Zeile, können Sie davon ausgehen, dass der Berg erst danach abnimmt, z

  /
 /
/

Zählt als einzelner 14er.

Sie müssen nicht mit ungültigen Gebirgszügen umgehen.

Hier ist ein Beispiel für 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

Erläuterung

Da die Spezifikationen nicht eindeutig angegeben sind, werden einige Annahmen getroffen:

• Das Endergebnis ist die 14.000-Fuß-Marke (alle Positionen im Raster sind also hoch genug, um als Peak zu gelten).
• Das Gitter beginnt am ersten Gipfel (oder steigt an) (da es bereits nach vorheriger Annahme mindestens 14.000 Fuß hoch ist).
• Ein separater Peak zählt erst nach 300ft Abstieg und 300ft Aufstieg .

Durchläuft das Zeichen cjeder Spalte (insbesondere durchläuft es jede Spalte, bis ein Zeichen gefunden wird). Die aktuelle Höhe wird in gespeichert a. Es wird auf ein Minimum von 0und ein Maximum von geklemmt 3. Die Richtung, die zum Zählen des nächsten Peaks benötigt wird, wird in d( false= auf, true= ab) gespeichert . Wenn aReach 3und Reach dist false, wird die Anzahl der Peaks pinkrementiert und dauf true(down) gesetzt. Sobald aerreicht 0, dwird wieder auf false(auf) gesetzt.

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 Bytes

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

Benötigt eine abschließende Newline in der Eingabe, sonst +4 Bytes.

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

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt. 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;
}