የቁልል ንጥረ ነገሮች ጥንድ ቅደም ተከተል ያላቸው መሆናቸውን ያረጋግጡ


የችግር ደረጃ ቀላል
ውስጥ በተደጋጋሚ ተጠየቀ አቅርቦት ፋርስት አራት ኪይትስ
ክምር

የችግሩ መግለጫ

“የቁልል ንጥረ ነገሮች በተከታታይ የሚዛመዱ መሆናቸውን ያረጋግጡ” የሚለው ችግር ሀ እንደተሰጠ ይገልጻል ቁልል የውሂብ መዋቅር ኢንቲጀር ዓይነት ሁሉም የተሰጡት አካላት ጥንድ ሆነው በተከታታይ (በቅደም ተከተል በመጨመር ወይም በመቀነስ) መሆናቸውን ወይም አለመሆኑን ለማጣራት ተግባር ይፍጠሩ ፡፡ በቆለሉ ውስጥ የተሰጡት ንጥረ ነገሮች ብዛት እኩል ከሆነ ፣ ሁሉንም ጥንዶች ይፈትሹ ሌላውን በተሰጠው ቁልል አናት ላይ ያለውን ንጥረ ነገር ይተዉት ፡፡ እንዲሁም በፕሮግራሙ ወቅት የተሰጠውን ቁልል ንጥረ ነገሮችን ይያዙ እና በውጤቱ ያትሟቸው ፡፡

የቁልል ንጥረ ነገሮች ጥንድ ቅደም ተከተል ያላቸው መሆናቸውን ያረጋግጡ

ለምሳሌ

s = [4, 5, -2, -3, 11, 10, 5, 6, 20]
Yes

ማብራሪያ-ከተግባሩ ጥሪ በኋላ [20 6 5 10 11 -3 -2 5 4] ከተጠራ በኋላ የቁልል ይዘት (ከላይ) ፡፡ በቁልል ውስጥ ያሉት ንጥረ ነገሮች ቁጥር ያልተለመደ ነው። ስለሆነም 20 ከማንኛውም አካል ጋር አይጣመርም ፡፡ ግን ሌሎች አካላት ተጣምረው እነሱ በተከታታይ ጥንድ ናቸው ፡፡

s = [4, 6, 6, 7, 4, 3]
No

ማብራሪያ-ከተግባር ጥሪ በኋላ [3 4 7 6 6 4] ከተጠራ በኋላ የቁልል ይዘት (ከላይ) ፡፡ እና 4 እና 6 የ 2 ልዩነት ስላላቸው እነሱ ተከታታይ አይደሉም ፡፡ ስለሆነም ውጤቱ ቁጥር ነው

የቁልል ንጥረ ነገሮች ጥንድ ተመሳሳይነት ያላቸው መሆናቸውን ለመፈተሽ ስልተ ቀመር

1. Create a stack data structure of the integer type and insert/push the elements in it.
2. Create another auxiliary stack data structure of the integer type.
3. Traverse while the original stack is not empty and push the element at top of  the auxiliary stack and pop the element from the top of the original stack.
4. Create a variable result of the boolean type and set its value as true.
5. Traverse through the auxiliary stack and pop the top 2 elements in the auxiliary stack and store them in 2 integer variables.
6. Check if the absolute difference of both the integer variables is not equal to 1, update the boolean variable result as false. Push / insert both the integer variables in the original stack.
7. Check if the size of the auxiliary stack is equal to 1, Push/insert the element at the top of the auxiliary stack in the original stack.
8. Return the boolean variable result.
9. Check if the returned value is equal to true, print "Yes" else print "No".
10. Print the original stack.

በዚህ ችግር ውስጥ እኛ መፈተሽ ያለበት የመጀመሪያ ኦሪጅናል ቁልል ተሰጠን ፡፡ ስለዚህ እኛ የመጀመሪያውን ክምችት ማጣት ስለማንፈልግ ብቻ የተሰራ ረዳት ቁልል እንፈጥራለን ፡፡ የመጀመሪያውን ቁልል ማከማቸት ካልፈለግን እና የመጀመሪያውን ክምር መቀየር ከቻልን በቀላሉ ንጥረ ነገሮችን ከዋናው ክምችት ማውጣት ይቻል ነበር ፡፡ ስለዚህ ረዳት ቁልል እንደ ቁልል ቅጅ ሆኖ ያገለግላል ፡፡ አሁን ረዳት ቁልል ሲኖረን ከላይ 2 ንጥሎችን ከላይ ማስወገድ እንችላለን ከዚያም የግንኙነት መረጣችንን እንፈትሻለን ፡፡

ኮድ

የቁልፍ ንጥረ ነገሮች ጥንድ ተመሳሳይነት ያላቸው መሆናቸውን ለመፈተሽ የ C ++ ፕሮግራም

#include <bits/stdc++.h> 
using namespace std; 
  
bool isConsecutive(stack<int> s){ 
    stack<int> aux; 
    
    while(!s.empty()){ 
        aux.push(s.top()); 
        s.pop(); 
    } 
  
    bool result = true; 
    
    while(aux.empty() > 1){ 
        int x = aux.top(); 
        aux.pop(); 
        int y = aux.top(); 
        aux.pop(); 
        
        if(abs(x - y) != 1){ 
            result = false; 
        }
  
        s.push(x); 
        s.push(y); 
    } 
  
    if(aux.size() == 1){ 
        s.push(aux.top());
    }
  
    return result; 
} 
  
int main(){ 
    stack<int> s;
    
    s.push(4); 
    s.push(5); 
    s.push(-2); 
    s.push(-3); 
    s.push(11); 
    s.push(10); 
    s.push(5); 
    s.push(6); 
    s.push(20); 
  
    if(isConsecutive(s)){ 
        cout << "Yes" << endl; 
    }
    
    else{
        cout << "No" << endl;
    }
  
    cout << "Stack content (from top)"
          " after function call\n"; 
    
    while(s.empty() == false){ 
       cout << s.top() << " "; 
       s.pop(); 
    } 
  
    return 0; 
}
Yes
Stack content (from top) after function call
20 6 5 10 11 -3 -2 5 4

የጃቫ ፕሮግራም የተቆለሉ ንጥረነገሮች በተከታታይ የሚዛመዱ መሆናቸውን ለመፈተሽ

import java.util.*; 

class CheckPair{ 
    
    static boolean isConsecutive(Stack<Integer> s){  
        Stack<Integer> aux = new Stack<Integer> ();  
        
        while(!s.isEmpty()){  
            aux.push(s.peek());  
            s.pop();  
        }  
      
        boolean result = true;  
        
        while(aux.size() > 1){  
            int x = aux.peek();  
            aux.pop();  
            int y = aux.peek();  
            aux.pop();  
            
            if(Math.abs(x - y) != 1){  
                result = false;  
            }
      
            s.push(x);  
            s.push(y);  
        }  
      
        if(aux.size() == 1){  
            s.push(aux.peek());
        }
      
        return result;  
    }  
      
    public static void main(String[] args){  
        Stack<Integer> s = new Stack<Integer> ();
        
        s.push(4);  
        s.push(5);  
        s.push(-2);  
        s.push(-3);  
        s.push(11);  
        s.push(10);  
        s.push(5);  
        s.push(6);  
        s.push(20);  
      
        if(isConsecutive(s)){  
            System.out.println("Yes");
        }
        
        else{
            System.out.println("No");  
        }
      
        System.out.println("Stack content (from top) after function call");  
        
        while(s.isEmpty() == false){  
            System.out.print(s.peek() + " ");  
            s.pop();  
        }  
      
    }  
}
Yes
Stack content (from top) after function call
20 6 5 10 11 -3 -2 5 4

ውስብስብነት ትንተና

የጊዜ ውስብስብነት

ኦ (ኤን)፣ በቁጥር ውስጥ የኤን ንጥረ ነገሮች ብዛት የት ነው።

የቦታ ውስብስብነት

ኦ (ኤን)፣ ኤን አባሎችን ለማከማቸት ቁልል ተጠቅመናል። ስለዚህ የመስመር ቦታ ውስብስብነት ተገኝቷል።