PRIP 10.1 Sumita Arora Solutions | Class 12 Computer Science

(a) Which stack element(s) can be accessed ?
Answer: only last inserted element can be accessed 

(b) Name three operations which can be performed on a stack.
Answer:   
push: to push element on the top of stack
pop: to remove element from the top of stack
top: to get the element on the top of the stack

(c) A stack is called a LIFO structure. What does this mean ?
Answer:
    LIFO stands for Last In First Out – last added element will get out first

(d) Give an example of an application of the stack.
Answer:

1. undo operation in text editor
2. used to evaluate prefix, postfix and infix expressions
3. String reversal

Answer:
a) [ 20 ]
b) [ 20, 51 ]
c) [ 20 ]
d) []
e) []
f) [ 43 ]

Answer:

Code:
def evaluate(a, i, b):
    a = int(a)
    b = int(b)
    if i == '+':
        return b+a
    if i == '-':
        return b-a
    if i == '*':
        return b*a
    if i == '**':
        return b**a
    if i == '/':
        return b/a
    if i == '%':
        return b%a
        
def postfix_evaluate(expression):
    operators = "+ * / - ** % ^"
    stack = []
    for i in expression:
        if i in operators:    # if i is operator
            a = stack.pop()   # pop two operands
            b = stack.pop()   
            ans = evaluate(a,i,b) # evaluate their result
            stack.append(ans)     # push result into stack 
        else:
            stack.append(int(i)) # append works same as push in list
        print(stack)  # to see status of stack each time
    return stack.pop()
#__main__    
expression = "30, 5, 2, **, 12, 6, /, +, -, 3"
expression = expression.split(", ")
print("Answer is: {}".format(postfix_evaluate(expression) ))
   
   
Output:
[30]
[30, 5]
[30, 5, 2]
[30, 25]
[30, 25, 12]
[30, 25, 12, 6]
[30, 25, 2.0]
[30, 27]
[3]
[3, 3]
Answer is: 3

Answer:

Code:
def StackSize(stack):
    return len(stack)

def evaluate(a, i, b):
    a = int(a)
    b = int(b)
    if i == '+':
        return b+a
    if i == '-':
        return b-a
    if i == '*':
        return b*a
    if i == '**':
        return b**a
    if i == '/':
        return b/a
    if i == '%':
        return b%a
     
def postfix_evaluate(expression):
    operators = "+ * / - ** % ^"
    stack = []
    for i in expression:
        if i in operators:    # if i is operator
            a = stack.pop()   # pop two operands
            b = stack.pop()   
            ans = evaluate(a,i,b) # evaluate their result
            stack.append(ans)     # push result into stack 
        else:
            stack.append(int(i)) # append works same as push in list
        print(stack, end=' ')  # to see status of stack each time
        size = StackSize(stack)
        print("stack size: {}".format(size))  # print stacksize  
    return stack.pop()
    
expression = "30, 5, 2, **, 12, 6, /, +, -, 3"
expression = expression.split(", ")
print("Answer is: {}".format(postfix_evaluate(expression) ))
 

Output:
[30] stack size: 1
[30, 5] stack size: 2
[30, 5, 2] stack size: 3
[30, 25] stack size: 2
[30, 25, 12] stack size: 3
[30, 25, 12, 6] stack size: 4
[30, 25, 2.0] stack size: 3
[30, 27] stack size: 2
[3] stack size: 1
[3, 3] stack size: 2

Answer is: 3

Answer: for solution stack functionality is implemented using class

Code:
class stack:          # class stack 
    def __init__(self):    # init function
        self.stack = list() # sreated a empty list
        
    def push(self, year):    # fucntion to push year into stack
        self.stack.append(year)
    
    def pop(self):           # function to pop year from stack
        self.stack.pop()
    
    def top(self):           # function to get top year from stack
        return self.stack[-1]

    def isEmpty(self):       # fucntion to check if stack is empty
        if len(self.stack)==0:
            return True
        return False

#__main__
s = stack()             # created a object of stack

s.push(1896)            # pushed all years in stack
s.push(1900)
s.push(1908)
s.push(1912)
s.push(1916)
s.push(1920)
s.push(1924)
s.push(1928)
s.push(1936)
s.push(1940)
s.push(1944)
s.push(1948)
s.push(1952)
s.push(1956)
s.push(1960)
s.push(1964)
s.push(1988)
s.push(2008)

print("Years in decending order:")    #printing stack
while(not s.isEmpty()):               # while loop till stack is empty
    print(s.top())                    # print top year 
    s.pop()                           # pop top year  


Output:
Years in decending order:  
2008
1988
1964
1960
1956
1952
1948
1944
1940
1936
1928
1924
1920
1916
1912
1908
1900
1896    

Answer:

Code:
def isEmpty(stack):
    if(len(stack))==0:
        return True
    return False

def reverse(str):
    stack = []        #create a empty stack
    
    for i in str:     # push each character to stack
        stack.append(i)
        
    output = ""       # create a empty string
    
    while(not isEmpty(stack)): # till stack becomes empty append each charecter to output string
        temp = stack.pop()
        output+=temp
    
    return output         # return output string

reverse("Welcome to computer tutor")


Output:
'rotut retupmoc ot emocleW'

Answer:

Code:
def isEmpty(stack):
    if(len(stack)) == 0:
        return True
    return False

def check_palindrome(string):
    str1 = []
    stack = [] 
    for i in string:
        stack.append(i)   # pushing to stack
        str1.append(i)     # adding to character array/list
    j = 0
    done = False
    while(not isEmpty(stack) and not done):
        ch = stack.pop()
        if(str1[j]== ch):
            j+=1
        else:
            done = True
            break
    if(done):
        print("String is not palindrome")
    else:
        print("String is  palindrome")
             
#__main__

string = "deed"
check_palindrome(string)

string = "able was I ere I saw elba"
check_palindrome(string)

string = "computer tutor"
check_palindrome(string) 


Output:
String is  palindrome
String is  palindrome
String is not palindrome