আমি কত 14ers আরোহণ করেছি?

Question

পর্বতারোহণের পরিভাষায়, একটি "14er" হ'ল 14 000 ফুট বা তারও বেশি উচ্চতা সম্পন্ন যে কোনও পর্বত। তবে এর মধ্যে আরও একটি পার্থক্য রয়েছে। 14 ইয়ার হিসাবে গণনা করার জন্য শীর্ষের জন্য এটির 300 বা তারও বেশি ফুট একটি "ভৌগলিক বিশিষ্টতা" থাকতে হবে। এর অর্থ হ'ল এক 14er থেকে অন্য দিকে যেতে, আপনাকে আবার উঠার আগে প্রথমে কমপক্ষে 300 ফুট নেমে যেতে হবে । এই উদাহরণটি ধরুন। লাইন 1 14 000 ফুট হিসাবে গণনা করা হয়, এবং প্রতিটি লাইন 100 ফুট হিসাবে গণনা করা হয়।

  /\__/\  
 /      \ 
/        \

এখন, এই উভয় শিখরই গণনা করার জন্য যথেষ্ট উচ্চতা রয়েছে, তবে দুটি পৃথক শৃঙ্গ হিসাবে গণনা করার জন্য তাদের মধ্যে উচ্চতা বাড়ানোর পর্যাপ্ত পরিমাণ নেই। অতএব, এর মধ্যে একটি 14 ইয়ার হিসাবে গণনা করা হয়, এবং অন্যটি কেবল একটি "আংশিক শীর্ষ"। এখানে একটি উদাহরণ যেখানে দুটি শৃঙ্গ দুটি পৃথক 14er হিসাবে গণনা করেছে:

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

দুটি 14 বয়সের মধ্যে হ্রাসের বিষয়ে একটি আংশিক শিখরও থাকতে পারে। এখানে সর্বশেষ পর্বতমালার সামান্য পরিবর্তিত সংস্করণ রয়েছে:

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

এই পর্বতমালাটি দুটি 14 বছর হিসাবে গণনা করে।

আপনাকে অবশ্যই এমন একটি প্রোগ্রাম বা ফাংশন লিখতে হবে যা একটি পর্বতশ্রেণীর একটি আসকি-শিল্প উপস্থাপনা গ্রহণ করে এবং কত 14 জনের পরিসর রয়েছে তা ফিরিয়ে দিতে হবে। আপনার পক্ষে যে কোনও বিন্যাসে সবচেয়ে সুবিধাজনক তা আপনি ইনপুট নিতে পারেন, এটি 2D অক্ষরের অ্যারে, নিউলাইনযুক্ত স্ট্রিং বা অন্য কিছু ডিলিমিটারের স্ট্রিং হোক। আপনি ধরে নিতে পারেন যে সমস্ত ইনপুটগুলিতে কেবল অক্ষর থাকবে /\_এবং প্রতিটি লাইনের দৈর্ঘ্য সমান হবে (পিছনের জায়গাগুলি সহ)। আপনি ধরে নিতে পারেন যে পর্বতশ্রেণীটি নীচে বাম কোণে একটি /বা একটি দিয়ে শুরু হয় _।

যদি কোনও পর্বতের শেষ অংশটি নীচের লাইনে না থাকে তবে আপনি ধরে নিতে পারেন যে পর্বতটি তার পরে কেবল হ্রাস পাবে, যেমন

  /
 /
/

একক 14er হিসাবে গণনা করা হয়।

আপনাকে অবৈধ পর্বতমালা হ্যান্ডেল করতে হবে না।

এখানে কিছু নমুনা I / O:

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

2

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

4

       /\                 
 _/\__/  \                
/         \               

1

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

1

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

3

Comments

সুতরাং প্রারম্ভিক রেখাটি 14,000 ফুট হিসাবে গণনা করা হয়?

— আর কাপ,

@ আর.ক্যাপ হ্যাঁ, আমি বিশ্বাস করি যে এটি সঠিক ছিল, ধরে নিচ্ছি আপনি যখন সূচনা বলার সময় নীচের লাইনটি বোঝাচ্ছেন।

— অ্যালেক্স এ।

আমি মনে করি আপনার কোথাও উল্লেখ করা উচিত যে _একই লাইনের একটি স্ল্যাশের চেয়ে 100 ফুট নীচে গণনা করা। কমপক্ষে এটিই আপনার শেষ পরীক্ষার কেসটি পরামর্শ দেয়।

— মার্টিন ইন্ডার

অনুমানটি পাতলা মনে হচ্ছে ... আমরা কি ফ্ল্যাট পিট জাতীয় পছন্দ করতে পারি / / / _ \ \ \ ? এছাড়াও, আমি অনুমান করি যে ইনপুটটির সর্বোচ্চ পয়েন্টটি সর্বদা শীর্ষ হিসাবে গণনা করা উচিত তবে এটি স্পষ্টভাবে নির্দিষ্ট করা হয়নি; এক নীচের শীর্ষে শুরু হতে পারে এবং একটি পৃথক গণনা সহ শেষ হতে পারে।

— ফেয়ারসুম

এটা কি সর্বদা অবিচ্ছিন্ন থাকবে? এটিতে প্রতিটি কলামের জন্য সর্বাধিক একটি ননস্পেস অক্ষর থাকবে?

— লিকি নুন

Answer 1

জাভাস্ক্রিপ্ট (ES6), 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 ফুট উচ্চ)।
• একটি 30000 ফিট উপরে আরোহণের পরে 300Fft আরোহণের পরে একটি পৃথক শীর্ষের গণনা করা হয় ।

cপ্রতিটি কলামের চরিত্রের উপরে আইট্রেট করা হয় (বিশেষত এটি কোনও ক্যারেক্টার না পাওয়া পর্যন্ত এটি প্রতিটি কলামে পুনরাবৃত্তি করে)। বর্তমান উচ্চতা সংরক্ষণ করা হয় a। এটি সর্বনিম্ন 0এবং সর্বাধিকের উপরে চাপানো হয় 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

জাভাস্ক্রিপ্ট (ES6), 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;
}