Ստուգեք, արդյոք կույտի տարրերը զույգերով հաջորդական են


Դժվարության մակարդակ Հեշտ
Հաճախակի հարցնում են Առաքում Փաստեր Ֆուրկիտներ
Գրապահոց

Խնդիրի հայտարարություն

«Ստուգեք, արդյոք կույտի տարրերը զույգերով հաջորդական են» խնդիրը նշում է, որ ձեզ տրված է a բուրգ տվյալների կառուցվածքը ամբողջ թիվ տիպ. Ստեղծեք գործառույթ ՝ ստուգելու համար, արդյոք տրված բոլոր տարրերը զույգերով հաջորդական են (ավելացման կամ նվազման կարգով), թե ոչ: Եթե ​​տուփի մեջ տրված տարրերի քանակը հավասար է, ապա ստուգեք, թե մնացած բոլոր զույգերը տարրը թողնում են տրված դեղի վերևում: Theրագրի ընթացքում պահեք նաև տուփի տարրերը և տպեք արդյունքով:

Ստուգեք, արդյոք կույտի տարրերը զույգերով հաջորդական են

Օրինակ

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

Java ծրագիր ՝ ստուգելու, թե արդյոք stack տարրերը զույգերով հաջորդական են

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

Բարդության վերլուծություն

Timeամանակի բարդություն

ՎՐԱ), որտեղ N- ը դեղի տարրերի քանակն է:

Տիեզերական բարդություն

ՎՐԱ), մենք օգտագործել ենք դեղ ՝ N տարրեր պահելու համար: Այսպիսով, ձեռք է բերվում գծային տիեզերական բարդություն: