NCERT Solutions for Class 12 Computer Science Chapter 3 : Stack

(a) True
Reason — A stack is a linear data structure following the Last In, First Out (LIFO) principle, where elements are arranged sequentially.

(b) False
Reason — A stack follows the Last In, First Out (LIFO) rule. In a stack, the last element added is the first one to be removed from the stack.

(c) False
Reason — When attempting to remove an element (POP operation) from an empty stack, it leads to an underflow condition, resulting in an exception being raised.

(d) True
Reason — In POSTFIX notation for expression, operators are placed after the corresponding operands.

 

Output

Result= 70

Explanation

The code initializes result to 0 and creates a list [10, 20, 30]. It appends 40 to the list and then performs two pop() operations on the list, which removes and returns the last element (40 and 30). These values are added to result, resulting in result being 70. Finally, the code prints "Result=" followed by the value of result, which is 70.

 

Output

Result= MAT

Explanation

The code initializes an empty list answer and an empty string output. It appends the characters 'T', 'A', and 'M' to the answer list. After appending, answer list becomes ['T', 'A', 'M'].
After that, three pop() operations are performed on answer, removing and returning the last element each time ('M', 'A', and 'T' respectively). These characters are concatenated to the output string. So, output string becomes MAT which is printed as the final output.

 

def push(stack, item):

    stack.append(item)

def pop(stack):

    if stack == []:

        return

    return stack.pop()

def reverse(string):

    n = len(string)

    stack = []

    for i in range(n):

        push(stack, string[i])

    string = ""

    for i in range(n):

        string += pop(stack)

    return string

string = input("Enter a string: ")

print("String:", string)

reversedStr = reverse(string)

print("Reversed String:", reversedStr)

Output

Enter a string: Hello world

String: Hello world

Reversed String: dlrow olleH

 

For matching parentheses, we can push in the stack for each opening parenthesis of the expression and pop from the stack for each closing parenthesis.

Scanning from left to right:

Empty stack => Balanced Parentheses

 

AB + C * = 35 + 1 *

Scanning from left to right :

Hence, AB + C * = 35 + 1 * = 8

 

AB * C / D * = 35 * / 4 *

Scanning from left to right :

Hence, AB * C / D * = 35 * / 4 * = 60

 

Given,

A + B - C * D

Scanning from left to right :

Postfix notation of A + B - C * D = AB+CD*-

 

Given,

A * (( C + D)/E)

Scanning from left to right:

Postfix notation of A * (( C + D)/E) = ACD+E/*

 

def push(stack, item):

    stack.append(item)

def pop(stack):

    if stack == []:

        return

    return stack.pop()

def oddStack(num):

    if num % 2 == 1:

        push(stack, num)

def GetLargest(stack):

    elem = pop(stack)

    large = elem

    while elem != None:

        if large < elem:

            large = elem

        elem = pop(stack)

    return large

n = int(input("How many numbers?"))

stack = []

for i in range(n):

    number = int(input("Enter number:"))

    oddStack(number)

print("Stack created is", stack)

bigNum = GetLargest(stack)

print("Largest number in stack", bigNum)

Output

How many numbers?8

Enter number:1

Enter number:2

Enter number:3

Enter number:4

Enter number:5

Enter number:6

Enter number:7

Enter number:8

Stack created is [1, 3, 5, 7]

Largest number in stack 7