Q.Consider a list named Nums which contains random integers. Write the following user defined functions in Python and perform the specified operations on a stack named BigNums.

Let's think about what a stack is first. A stack is a linear data structure that follows the Last In, First Out (LIFO) principle — the last element you put in is the first one you take out. Think of a stack of plates in a cafeteria: you add a plate on top, and when you need one, you take the topmost plate. Python lists can easily act as stacks because they have built-in methods like append() to push an item onto the top, and pop() to remove and return the topmost item.

Now, the problem gives you a list called Nums containing random integers. Your first function, PushBig(), needs to examine each number in this list and decide whether it belongs in the stack BigNums. The condition is simple: the number must have five or more digits. How do you check the number of digits? The cleanest way in Python is to convert the integer to a string using str() and then check its length with len(). For example, len(str(10025)) gives 5, so 10025 qualifies. But len(str(213)) gives 3, so 213 does not qualify.

The function should iterate through Nums, and for each number that meets the condition, it should push it onto BigNums using BigNums.append(number). Notice that the order in the stack will be the same as the order in which qualifying numbers appear in the original list — because you're pushing them one by one as you encounter them. In the example, the stack ends up as [10025, 254923, 1297653, 31498, 92765], which is exactly the order they appear in Nums.

Your second function, PopBig(), does the opposite. It needs to pop numbers from the stack one by one and display them. But there's a catch: you must keep popping until the stack is empty, and when it becomes empty, you must display "Stack Empty". The natural way to do this is with a while loop that continues as long as the stack is not empty. Inside the loop, you pop the top element and print it. After the loop ends (meaning the stack is now empty), you print "Stack Empty".

Imagine a stack of plates in a kitchen. You can only add a new plate to the top, and you can only take a plate from the top. This simple, intuitive concept is precisely what a "stack" is in computer science: a fundamental data structure that operates on the principle of Last-In, First-Out (LIFO). The last item added to the stack is always the first one to be removed.

In our university scenario, we're using a stack to manage course details. Each "plate" on our stack will be a record containing a course's name, its fees, and its duration. The challenge here is not just to manage a stack, but to do so with specific conditions, ensuring only relevant courses are added and that we handle situations where there are no courses left to retrieve.

Implementing the Stack Operations

We will use a standard Python list to represent our stack, as lists naturally support the append() method for adding elements to the end (our "push" operation) and the pop() method for removing elements from the end (our "pop" operation). The end of the list will serve as the "top" of our stack.

(i) Push_element() Function

The Push_element() function is designed to add a new course record to our Univ stack, but with a crucial condition: the course's fees must be greater than 100,000. This acts as a filter, ensuring only high-value courses, perhaps those requiring special attention or having a certain prestige, are tracked in this particular stack.

When a course record, which is itself a list like ["MCA", 200000, 3], is passed to this function, we first extract the fees. If these fees meet our criteria (i.e., fees > 100000), the entire course record is then added to the Univ stack using the append() method. If the fees do not meet the condition, the course is simply ignored for this stack, and a message indicating this is displayed.

(ii) Pop_element() Function

The Pop_element() function performs the reverse operation: it removes the topmost course record from the Univ stack. According to the LIFO principle, this will always be the last course that was successfully pushed onto the stack.

Before attempting to remove an element, it's vital to check if the stack actually contains any elements. If the stack is empty, trying to pop() from it would result in an error. This condition is known as "Underflow." Our function handles this by checking if the Univ list is empty (if not Univ:). If it is, an "Underflow" message is displayed, and no operation is performed. If the stack is not empty, the pop() method is called, which removes and returns the last element, and this element is then displayed.

Here is the Python code implementing these functions:

# Initialize the global stack named 'Univ'
Univ = []

def Push_element(course_details):
    """
    Pushes an object containing the Course_name, Fees, and Duration of a course
    to the 'Univ' stack, only if its fees are greater than 100000.
    """
    # course_details is expected to be a list: [Course_name, Fees, Duration]
    course_name = course_details[0]
    fees = course_details[1]
    duration = course_details[2]

    if fees > 100000:
        Univ.append(course_details)
        print(f"Pushed: {course_details} (Fees: {fees})")
    else:
        print(f"Skipped: {course_name} (Fees: {fees}) - Fees not greater than 100000.")

def Pop_element():
    """
    Pops an object from the 'Univ' stack and displays it.
    Displays "Underflow" when there is no element in the stack.
    """ …