मैंने कितने 14 पर चढ़ाई की?

Question

पर्वतारोहण शब्दावली में, एक "14er" 14 000 फीट या उससे अधिक की ऊंचाई वाला कोई भी पर्वत है। हालांकि, एक और अंतर है। एक चोटी को 14er के रूप में गिनने के लिए, इसमें 300 या अधिक पैरों की "भौगोलिक प्रमुखता" भी होनी चाहिए। इसका मतलब है कि एक 14er से दूसरे में जाने के लिए, आपको फिर से उठने से पहले कम से कम 300 फीट नीचे उतरना होगा । इसका उदाहरण लीजिए। लाइन 1 को 14 000 फीट के रूप में गिना जाता है, और प्रत्येक पंक्ति को 100 फीट के रूप में गिना जाता है।

  /\__/\  
 /      \ 
/        \

अब, इन दोनों चोटियों को गिनने के लिए पर्याप्त ऊँचाई है, लेकिन दो अलग-अलग चोटियों के रूप में गिनने के लिए उनके बीच ऊँचाई में पर्याप्त गिरावट नहीं है। इसलिए, इनमें से एक 14er के रूप में गिना जाता है, और दूसरा केवल एक "आंशिक शिखर" है। यहाँ एक उदाहरण है जहां दो चोटियों को दो अलग 14er के रूप में गिना जाता है:

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

दो 14ers के बीच की गिरावट पर एक आंशिक शिखर भी हो सकता है। यहाँ अंतिम पर्वत श्रृंखला का थोड़ा संशोधित संस्करण है:

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

यह पर्वत श्रृंखला भी दो 14ers के रूप में गिना जाता है।

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो एक पर्वत श्रृंखला के एससी-आर्ट प्रतिनिधित्व को लेता है, और यह बताता है कि रेंज में कितने 14 आर हैं। आप जो भी प्रारूप में आपके लिए सबसे सुविधाजनक है, उसमें इनपुट ले सकते हैं, यह अक्षरों का 2 डी सरणी होना चाहिए, न्यूलाइन के साथ एक स्ट्रिंग, या कुछ अन्य सीमांकक के साथ एक स्ट्रिंग। आप मान सकते हैं कि सभी इनपुट में केवल वर्ण होंगे /\_, और यह कि प्रत्येक पंक्ति की लंबाई समान होगी (अनुगामी रिक्त स्थान सहित)। आप यह भी मान सकते हैं कि पर्वत श्रृंखला एक /या तो एक के साथ निचले बाएँ कोने पर शुरू होती है _।

यदि किसी पर्वत का अंतिम भाग नीचे की रेखा पर नहीं है, तो आप मान सकते हैं कि पर्वत केवल उसके बाद घटता है, जैसे

  /
 /
/

एक एकल 14er के रूप में गिना जाता है।

आपको अमान्य पर्वत श्रृंखलाओं को संभालने की आवश्यकता नहीं है।

यहाँ कुछ नमूना I / O है:

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

2

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

4

       /\                 
 _/\__/  \                
/         \               

1

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

1

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

3

Comments

तो शुरुआती लाइन 14,000 फीट के रूप में गिना जाता है?

— आर। काप

@ R.Kap हां, मेरा मानना ​​है कि यह सही है, मान लें कि जब आप लाइन शुरू करते हैं तो आप नीचे की लाइन का मतलब समझते हैं।

— एलेक्स ए।

मुझे लगता है कि आपको कहीं और उल्लेख करना चाहिए कि एक _ही पंक्ति में एक स्लैश की तुलना में 100 फीट कम है। कम से कम आपके अंतिम परीक्षण मामले से यही पता चलता है।

— मार्टिन एंडर

कल्पना पतली लगती है ... क्या हम एक फ्लैट पीट कर सकते हैं / / / _ \ \ \ ? इसके अलावा, मुझे लगता है कि इनपुट में उच्चतम बिंदु को हमेशा एक चोटी के रूप में गिना जाना चाहिए, लेकिन यह स्पष्ट रूप से निर्दिष्ट नहीं है; एक कम ऊंचाई पर शुरू हो सकता है और एक अलग गिनती के साथ समाप्त हो सकता है।

— feersum

क्या यह हमेशा महाद्वीप रहेगा? क्या यह प्रत्येक कॉलम के लिए अधिकतम एक निरर्थक चरित्र होगा?

— लीक नन

Answer 1

जावास्क्रिप्ट (ईएस 6), 133 बाइट्स

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

व्याख्या

चूंकि विशिष्टताओं को स्पष्ट रूप से नहीं बताया गया है, इसलिए यह कुछ धारणाएं बनाता है:

• नीचे की रेखा 14,000 फीट का निशान है (इसलिए ग्रिड पर सभी स्थिति एक चोटी के रूप में गिनने के लिए पर्याप्त उच्च हैं)।
• ग्रिड पहली चोटी पर (या आरोही) शुरू होता है (क्योंकि यह पिछली धारणा के अनुसार कम से कम 14,000 फीट ऊंचा है)।
• एक अलग चोटी केवल 300 फीट नीचे उतरती है और फिर 300 फीट ऊपर चढ़ती है ।

cप्रत्येक स्तंभ के चरित्र पर Iterates (विशेष रूप से, यह प्रत्येक स्तंभ को तब तक पुनरावृत्त करता है जब तक कि वह एक वर्ण नहीं पाता)। वर्तमान ऊंचाई में संग्रहीत किया जाता है a। यह कम से कम 0और अधिकतम के लिए clamped है 3। अगली चोटी को गिनने के लिए स्थानांतरित करने के लिए आवश्यक दिशा d( false= ऊपर, true= नीचे) में संग्रहीत होती है । यदि aपहुंचता है 3और dहै false, तो चोटियों की संख्या बढ़ pजाती है और (नीचे) पर dसेट होती है true। एक बार aपहुंचने पर 0, dवापस 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>

Answer 2

सी, 174 बाइट्स

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

इनपुट में एक अनुगामी न्यूलाइन की आवश्यकता है, अन्यथा +4 बाइट्स।

Answer 3

जावास्क्रिप्ट (ईएस 6), 154 बाइट्स

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

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। 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;
}