C#: Verify at least one element satisfy a condition

C# Sharp Stack: Exercise-26 with Solution

Write a C# program that implements a stack and checks if at least one element of the stack satisfies a condition.

Sample Solution:

C# Code:

using System;
using System.Collections.Generic;

public class Stack
{
    private int[] items; // Array to hold stack elements
    private int top; // Index of the top element in the stack

    // Constructor to initialize the stack with a specified size
    public Stack(int size)
    {
        items = new int[size]; // Create an array of integers with the given size
        top = -1; // Initialize top index to -1, indicating an empty stack
    }

    // Check if the stack is empty
    public bool IsEmpty()
    {
        return top == -1; // Returns true if the stack is empty
    }

    // Check if the stack is full
    public bool IsFull()
    {
        return top == items.Length - 1; // Returns true if the stack is full
    }

    // Push an element onto the stack
    public void Push(int item)
    {
        if (IsFull())
        {
            Console.WriteLine("Stack Full!"); // Display a message indicating stack overflow if the stack is full
            return;
        }

        items[++top] = item; // Increment top and add the item to the stack
    }

    // Pop an element from the stack
    public int Pop()
    {
        if (IsEmpty())
        {
            Console.WriteLine("Stack underflow"); // Display a message indicating stack underflow if the stack is empty
            return -1;
        }

        return items[top--]; // Return and decrement top to remove the element from the stack
    }

    // Peek at the top element of the stack without removing it
    public int Peek()
    {
        if (IsEmpty())
        {
            Console.WriteLine("Stack is empty"); // Display a message indicating the stack is empty
            return -1;
        }

        return items[top]; // Return the top element of the stack
    }

    // Static method to get the size of a stack
    public static int Size(Stack stack)
    {
        return stack.top + 1; // Return the size of the stack based on the current top index
    }

    // Method to count all the elements in a stack
    public static int Count(Stack stack)
    {
        int count = 0;
        Stack temp = new Stack(Size(stack));

        // Move elements from the original stack to a temporary stack and count them
        while (!stack.IsEmpty())
        {
            temp.Push(stack.Pop()); // Move elements from the original stack to the temporary stack
            count++; // Increment count for each element moved
        }

        // Restore the original stack by moving elements back from the temporary stack
        while (!temp.IsEmpty())
        {
            stack.Push(temp.Pop()); // Move elements back to the original stack
        }

        return count; // Return the total count of elements in the stack
    }

    // Method to verify if at least one stack element satisfies a given condition
    public static bool any(Stack stack, Func<int, bool> condition)
    {
        Stack temp = new Stack(Size(stack));
        bool result = false;

        while (!stack.IsEmpty())
        {
            int item = stack.Pop();
            if (condition(item)) // Check if the condition is satisfied for any element
            {
                result = true; // Update result to indicate at least one element satisfies the condition
            }
            temp.Push(item); // Push the element to the temporary stack
        }

        while (!temp.IsEmpty())
        {
            stack.Push(temp.Pop()); // Restore the original stack by moving elements back
        }

        return result; // Return whether at least one element satisfies the condition
    }

    // Method to display the elements of the stack
    public static void Display(Stack stack)
    {
        if (stack.IsEmpty())
        {
            Console.WriteLine("Stack is empty"); // Display a message if the stack is empty
            return;
        }

        Console.WriteLine("Stack elements:");
        for (int i = stack.top; i >= 0; i--)
        {
            Console.Write(stack.items[i] + " "); // Display elements of the stack
        }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Stack stack1 = new Stack(10);
        stack1.Push(1);
        stack1.Push(2);
        stack1.Push(3);
        stack1.Push(4);
        stack1.Push(5);
        stack1.Push(6);
        Stack.Display(stack1);
        Console.Write("\nCheck if at least one element of the stack is even? ");
        Boolean result = Stack.any(stack1, element => element % 2 == 0);
        Console.Write(result);        
        Console.Write("\nCheck if at least one element of the stack is greater than 10: ");
        Boolean result1 = Stack.any(stack1, element => element > 10);
        Console.Write(result1);
        Console.Write("\nCheck if at least one element of the stack is odd? ");
        result = Stack.any(stack1, element => element % 2 != 0);
        Console.Write(result);
        Console.Write("\nCheck if at least one element of the stack is less than 3: ");
        result = Stack.any(stack1, element => element < 3);
        Console.Write(result);
    }
}

Sample Output:

Stack elements:
6 5 4 3 2 1
Check if at least one element of the stack is odd? True
Check if at least one element of the stack is greater than 10: False
Check if at least one element of the stack is odd? True
Check if at least one element of the stack is less than 3: True

Flowchart:

C# Sharp Code Editor:

Improve this sample solution and post your code through Disqus

Previous: Verify all stack elements satisfy a condition.
Next: Remove elements from a stack that do not meet a condition.