Trong thuật ngữ leo núi, "14er" là bất kỳ ngọn núi nào có độ cao từ 14 000 feet trở lên. Tuy nhiên, có một sự phân biệt khác. Để một đỉnh được tính là 14er, nó cũng phải có "điểm nổi bật về địa lý" từ 300 feet trở lên. Điều này có nghĩa là để di chuyển từ 14er này sang 14 khác, trước tiên bạn phải hạ xuống ít nhất 300 feet trước khi tăng trở lại. Lấy ví dụ này. Dòng 1 được tính là 14 000 feet và mỗi dòng được tính là 100 feet.

  /\__/\  
 /      \ 
/        \

Bây giờ, cả hai đỉnh này đều có đủ độ cao để đếm, nhưng không có đủ độ cao giữa chúng để tính là hai đỉnh riêng biệt. Do đó, một trong số này được tính là 14er và một trong số đó chỉ là "đỉnh một phần". Dưới đây là một ví dụ trong đó hai đỉnh được tính là hai 14er riêng biệt:

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

Cũng có thể có một đỉnh cao một phần về sự suy giảm giữa hai 14ers. Đây là một phiên bản sửa đổi một chút của dãy núi cuối cùng:

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

Dãy núi này cũng được tính là hai 14ers.

Bạn phải viết một chương trình hoặc chức năng có đại diện nghệ thuật của một dãy núi và trả lại số lượng 14ers trong phạm vi. Bạn có thể lấy đầu vào ở bất kỳ định dạng nào thuận tiện nhất cho bạn, có thể là mảng ký tự 2D, chuỗi có dòng mới hoặc chuỗi có một số dấu phân cách khác. Bạn có thể giả định rằng tất cả các đầu vào sẽ chỉ chứa các ký tự /\_và độ dài của mỗi dòng sẽ giống nhau (bao gồm cả khoảng trắng ở cuối). Bạn cũng có thể giả sử rằng dãy núi bắt đầu ở góc dưới bên trái với a /hoặc a _.

Nếu phần cuối cùng của ngọn núi không nằm ở điểm mấu chốt, bạn có thể giả sử rằng ngọn núi chỉ giảm sau đó, ví dụ:

  /
 /
/

Đếm như một 14er duy nhất.

Bạn không phải xử lý các dãy núi không hợp lệ.

Dưới đây là một số mẫu 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

Giải trình

Vì các thông số kỹ thuật không được nêu rõ ràng, điều này tạo ra một số giả định:

• Điểm mấu chốt là mốc 14.000ft (vì vậy tất cả các vị trí trên lưới đủ cao để được tính là một đỉnh).
• Lưới bắt đầu ở (hoặc tăng dần) đỉnh đầu tiên (vì nó cao ít nhất 14.000ft theo giả định trước đó).
• Một đỉnh riêng biệt chỉ được tính sau khi giảm 300ft rồi tăng 300ft .

Lặp lại ký tự ccủa mỗi cột (cụ thể, nó lặp xuống từng cột cho đến khi tìm thấy một ký tự). Độ cao hiện tại được lưu trữ trong a. Nó được kẹp ở mức tối thiểu 0và tối đa 3. Hướng cần thiết để di chuyển để đếm đỉnh tiếp theo được lưu trữ trong d( false= lên, true= xuống). Nếu ađạt 3và dlà false, số lượng đỉnh pđược tăng lên và dđược đặt thành true(xuống). Khi ađạt đến 0, dđược đặt trở lại false(lên).

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

Yêu cầu một dòng mới ở đầu vào, nếu không +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

Trường hợp \nđại diện cho nhân vật dòng chữ mới. Ung dung:

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