Comprobar si los elementos de la pila son consecutivos por pares

Dada una pila de enteros, escriba una función pairWiseConsecutive() que verifique si los números en la pila son pares consecutivos o no. Los pares pueden ser crecientes o decrecientes, y si la pila tiene un número impar de elementos, el elemento en la parte superior queda fuera de un par. La función debe conservar el contenido de la pila original.
Solo se permiten las siguientes operaciones estándar en la pila.

• push (X): ingrese un elemento X en la parte superior de la pila.
• pop(): elimina el elemento superior de la pila.
• vacío(): para verificar si la pila está vacía.

Ejemplos: 

Input : stack = [4, 5, -2, -3, 11, 10, 5, 6, 20]
Output : Yes
Each of the pairs (4, 5), (-2, -3), (11, 10) and
(5, 6) consists of consecutive numbers.

Input : stack = [4, 6, 6, 7, 4, 3]
Output : No
(4, 6) are not consecutive.

La idea es usar otra pila. 

1. Cree una pila auxiliar aux .
2. Transfiere el contenido de la pila dada a aux .
3. Travesaño auxiliar. Mientras atraviesa, busque los dos elementos superiores y verifique si son consecutivos o no. Después de verificar, vuelva a colocar estos elementos en la pila original.

Implementación:

// C++ program to check if successive
// pair of numbers in the stack are
// consecutive or not
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if elements are
// pairwise consecutive in stack
bool pairWiseConsecutive(stack<int> s)
{
    // Transfer elements of s to aux.
    stack<int> aux;
    while (!s.empty()) {
        aux.push(s.top());
        s.pop();
    }
 
    // Traverse aux and see if
    // elements are pairwise
    // consecutive or not. We also
    // need to make sure that original
    // content is retained.
    bool result = true;
    while (aux.size() > 1) {
 
        // Fetch current top two
        // elements of aux and check
        // if they are consecutive.
        int x = aux.top();
        aux.pop();
        int y = aux.top();
        aux.pop();
        if (abs(x - y) != 1)
          result = false;
 
        // Push the elements to original
        // stack.
        s.push(x);
        s.push(y);
    }
 
    if (aux.size() == 1)
        s.push(aux.top());
 
    return result;
}
 
// Driver program
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 (pairWiseConsecutive(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;
}

// Java program to check if successive
// pair of numbers in the stack are
// consecutive or not
import java.util.*;
class GfG {
 
// Function to check if elements are
// pairwise consecutive in stack
static boolean pairWiseConsecutive(Stack<Integer> s)
{
    // Transfer elements of s to aux.
    Stack<Integer> aux = new Stack<Integer> ();
    while (!s.isEmpty()) {
        aux.push(s.peek());
        s.pop();
    }
 
    // Traverse aux and see if
    // elements are pairwise
    // consecutive or not. We also
    // need to make sure that original
    // content is retained.
    boolean result = true;
    while (aux.size() > 1) {
 
        // Fetch current top two
        // elements of aux and check
        // if they are consecutive.
        int x = aux.peek();
        aux.pop();
        int y = aux.peek();
        aux.pop();
        if (Math.abs(x - y) != 1)
        result = false;
 
        // Push the elements to original
        // stack.
        s.push(x);
        s.push(y);
    }
 
    if (aux.size() == 1)
        s.push(aux.peek());
 
    return result;
}
 
// Driver program
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 (pairWiseConsecutive(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();
    }
 
}
}

# Python3 program to check if successive
# pair of numbers in the stack are
# consecutive or not
 
# Function to check if elements are
# pairwise consecutive in stack
def pairWiseConsecutive(s):
     
    # Transfer elements of s to aux.
    aux = []
    while (len(s) != 0):
        aux.append(s[-1])
        s.pop()
 
    # Traverse aux and see if elements
    # are pairwise consecutive or not.
    # We also need to make sure that
    # original content is retained.
    result = True
    while (len(aux) > 1):
 
        # Fetch current top two
        # elements of aux and check
        # if they are consecutive.
        x = aux[-1]
        aux.pop()
        y = aux[-1]
        aux.pop()
        if (abs(x - y) != 1):
            result = False
 
        # append the elements to
        # original stack.
        s.append(x)
        s.append(y)
 
    if (len(aux) == 1):
        s.append(aux[-1])
 
    return result
 
# Driver Code
if __name__ == '__main__':
 
    s = []
    s.append(4)
    s.append(5)
    s.append(-2)
    s.append(-3)
    s.append(11)
    s.append(10)
    s.append(5)
    s.append(6)
    s.append(20)
 
    if (pairWiseConsecutive(s)):
        print("Yes")
    else:
        print("No")
 
    print("Stack content (from top)",
               "after function call")
    while (len(s) != 0):
        print(s[-1], end = " ")
        s.pop()
 
# This code is contributed by PranchalK

// C# program to check if successive
// pair of numbers in the stack are
// consecutive or not
using System;
using System.Collections.Generic;
 
class GfG
{
 
// Function to check if elements are
// pairwise consecutive in stack
static bool pairWiseConsecutive(Stack<int> s)
{
    // Transfer elements of s to aux.
    Stack<int> aux = new Stack<int> ();
    while (s.Count != 0)
    {
        aux.Push(s.Peek());
        s.Pop();
    }
 
    // Traverse aux and see if
    // elements are pairwise
    // consecutive or not. We also
    // need to make sure that original
    // content is retained.
    bool result = true;
    while (aux.Count > 1)
    {
 
        // Fetch current top two
        // elements of aux and check
        // if they are consecutive.
        int x = aux.Peek();
        aux.Pop();
        int y = aux.Peek();
        aux.Pop();
        if (Math.Abs(x - y) != 1)
            result = false;
 
        // Push the elements to original
        // stack.
        s.Push(x);
        s.Push(y);
    }
 
    if (aux.Count == 1)
        s.Push(aux.Peek());
 
    return result;
}
 
// Driver code
public static void Main()
{
    Stack<int> s = new Stack<int> ();
    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 (pairWiseConsecutive(s))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
 
    Console.WriteLine("Stack content (from top)" +
                        "after function call");
    while (s.Count != 0)
    {
        Console.Write(s.Peek() + " ");
        s.Pop();
    }
 
}
}
 
/* This code contributed by PrinciRaj1992 */

<script>
 
// JavaScript program to check if successive
// pair of numbers in the stack are
// consecutive or not
 
// Function to check if elements are
// pairwise consecutive in stack
function pairWiseConsecutive( s)
{
    // Transfer elements of s to aux.
    var aux = [];
    while (s.length!=0) {
        aux.push(s[s.length-1]);
        s.pop();
    }
 
    // Traverse aux and see if
    // elements are pairwise
    // consecutive or not. We also
    // need to make sure that original
    // content is retained.
    var result = true;
    while (aux.length > 1) {
 
        // Fetch current top two
        // elements of aux and check
        // if they are consecutive.
        var x = aux[aux.length-1];
        aux.pop();
        var y = aux[aux.length-1];
        aux.pop();
        if (Math.abs(x - y) != 1)
          result = false;
 
        // Push the elements to original
        // stack.
        s.push(x);
        s.push(y);
    }
 
    if (aux.length == 1)
        s.push(aux[aux.length-1]);
 
    return result;
}
 
// Driver program
var 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 (pairWiseConsecutive(s))
    document.write( "Yes<br>" );
else
    document.write( "No<br>" );
document.write( "Stack content (from top)"+
      " after function call<br>");
while (s.length!=0)
{
   document.write( s[s.length-1] + " ");
   s.pop();
}
 
</script>

Yes
Stack content (from top) after function call
20 6 5 10 11 -3 -2 5 4 

Complejidad temporal: O(n). 
Espacio Auxiliar : O(n).

Este artículo es una contribución de Prakriti Gupta . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.