COMPUTER SCIENCE

CS GPT

SSVM

REGISTER NUMBER :

NAME : V. ADITHYA

CLASS : XII

SCHOOL : SSVM SCHOOL OF EXCELLENCE, COIMBATORE

YEAR : 2024-2025
 CERTIFICATE

This is to certify that Master/Miss of class XII

SSVM School of Excellence, Coimbatore has completed this project file under my
supervision. He/She has taken proper care and shown utmost sincerity in
completion of this project. This is to certify that this project is up to my expectations
and as per the guidelines issued by CBSE.

____________________ ___________________

External Examiner Internal Examiner

________________

(Dr. Stephenson)
Principal
SSVM School of Excellence- Coimbator
 ACKNOWLEDGEMENT

I would like to take this opportunity to express my deep sense

of gratitude to all those people without whom this project
could have never been completed. First and foremost I like to
thank God for giving me such a great opportunity to work on
this project, and I would like to express my special thanks and
gratitude to the Management, the Directors and the
Correspondent of SSVM School of Excellence, for their
constant guidance and providing a very nice platform to learn.

I would also like to thank our Principal – Dr.Stephenson, for

his constant encouragement and moral support without which I
would have never be able to give my best.

I would also like to thank Mr. Arul (PGT -CS), SSVM School
of Excellence, who gave me the wonderful opportunity to do
this project, which also helped me in doing a lot of research
and I came to know about so many new things from this study
I am really thankful to all.
 INDEX

SNO TITLES PAGE

NO
1 ACKNOWLEDGEMENT 1

2 SYSTEM REQUIREMENTS 2

3 INTRODUCTION 3

4 ABOUT THE PROGRAM 4

5 KEY FEATURES 6

6 SOURCE CODE 8

7 OUTPUT 13

8 SOURCE CODE MAIN 15

9 BACK END 101

10 CONCLUSION 142

11 BIBLIOGRAPHY 143
 SYSTEM REQUIREMENTS
Hardware requirements:
• A computer/laptop with a operating system-windows 7 or
above
• X86 64-bit CPU (intel/AMD architecter)
• 4GB RAM
• 5GB free disk space

Software requirements:
• Python 3.9 or high

Hardware used:
• Processor: Intel(R) Core(TM) i3-6006U CPU @ 2.00GHz
2.00GHz
• RAM: 8.00GB
• System type: 64-bit Operating System
• x64 Based processor
• Windows edition: Windows 10 pro

Software's used:
• Microsoft Windows 10 as Operating System.
• Python 3.7 as Front-end for GUI development.
• MS-Word 2010 for documentation.

2
 INTRODUCTION

In today's digital age, programming has become an essential skill,

particularly for students pursuing a Computer Science (CS)
curriculum. Python, known for its simplicity and readability, is a
popular programming language in educational settings. It serves as a
powerful tool for students to grasp fundamental concepts in
programming, logic building, and computational thinking.
This GRADE 11 CS gpt project is designed to encapsulate all the
essential Python code that a Class 11 CBSE student is expected to
know. By integrating these concepts into a comprehensive, menu-
driven program, the project aims to provide a practical and
interactive way for students to learn and apply their knowledge. The
program covers a wide range of topics, including basic syntax,
control structures, functions, data structures, and file handling,
among others.
Through this project, students will gain a deeper understanding of
how various Python constructs work together to solve real-world
problems. The menu-driven approach not only makes the program
user-friendly but also enables students to explore different Python
topics at their own pace, reinforcing their learning through hands-on
experience.
The objective of this project is to serve as a comprehensive learning
tool that can assist students in mastering Python programming in
alignment with the CBSE curriculum. It is also intended to
demonstrate the practical applications of Python in solving everyday
problems, thus encouraging students to think critically and creatively

3
 ABOUT THE PROGRAM
The program developed in this investigation project is a
comprehensive, menu-driven Python application designed
specifically for Class 11 CBSE students. It aims to provide a hands-
on, interactive platform for learning and reinforcing key
programming concepts covered in the CBSE Computer Science
curriculum.
Objectives
The primary objectives of this program are:
• To offer a structured approach to learning Python
programming.
• To help students understand and apply Python concepts through
practical examples.
• To enhance problem-solving skills by demonstrating real-world
applications of Python.
Structure and Organization
The program is organized into several modules, each corresponding
to a major topic in the CBSE Class 11 Python syllabus. These
modules are presented in a menu-driven format, allowing users to
select and explore specific topics based on their learning needs.
Topics Covered
The program covers a wide range of Python topics, including but not
limited to:
• Basic Syntax and Data Types: Introduction to Python syntax,
variables, and data types like strings, integers, and floats.
• Control Structures: Conditional statements (if, elif, else), loops
(for, while), and control flow.

4
 • Functions: Definition and usage of functions, including
parameters, return values, and scope.
• Data Structures: Lists, tuples, dictionaries, and their methods.
• Error Handling: Try-except blocks, common errors, and
debugging techniques.
User Interface
The user interface is designed to be intuitive and easy to navigate.
Upon launching the program, users are presented with a main menu
that lists the available topics. Each topic can be selected to access
submenus or directly engage with the content, which includes
explanations, examples, and exercises.
Interaction and Output
The program is interactive, prompting users to enter inputs where
necessary and displaying outputs that reflect the results of the code
execution. This interactivity helps reinforce learning by providing
immediate feedback on the user's actions.
Educational Value
The program serves as a practical tool for both learning and revision.
It helps students understand how to write clean, efficient code and
encourages them to experiment with different Python features. By
integrating various Python concepts into a single program, students
can see how different aspects of the language work together,
providing a holistic view of Python programming.
Future Enhancements
The program is designed with scalability in mind. Future
enhancements could include the addition of more advanced
topics, integration of graphical user interface (GUI) elements and
the inclusion of a database to manage user progress and scores.

5
 KEY FEATURES
The investigation project on Python programming for Class 11 CBSE
students is designed with the following key features:
1. Comprehensive Coverage:

• The project includes all the essential Python concepts

required by the CBSE Class 11 syllabus. This ensures that
students have access to a wide range of topics, from basic
syntax and data types to more advanced topics like
functions, loops.
2. Menu-Driven Interface:

• The program is designed with a user-friendly, menu-driven

interface. This allows students to easily navigate through
different sections and select specific topics they wish to
explore. The interface ensures that even beginners can use
the program without difficulty.
3. Interactive Learning:

• Each topic is presented with practical code

implementations. This hands-on approach helps
students understand how theoretical concepts are
applied in real- world programming scenarios.
4. Modular Design:

• The program is organized into modules corresponding to

different Python topics. This modularity allows for easy
updates and extensions, making the program a dynamic
tool for ongoing learning.

6
5. Real-World Applications:

• The project demonstrates how Python can be used to

solve real-world problems. This helps students connect
their learning to practical applications, enhancing their
problem- solving skills.
6. Scalability:

• The structure of the program is designed to be easily

scalable, allowing for the inclusion of additional topics or
more advanced Python concepts as students progress in
their studies.
7. Educational Resource:

• The project can serve as a valuable resource for both

students and educators. It can be used as a teaching aid in
classrooms or as a study tool for individual learning.

7
 SOURCE CODE

"""

@author: Adithya.v

"""

import mysql.connector as ak

ak47=ak.connect(host="localhost",user="root",passwd="Adithya008",database="dummy")

cursor=ak47.cursor()

cursor.execute("SELECT Sno FROM odd_or_even ORDER BY Sno DESC LIMIT 1;")

t=cursor.fetchone()

a,=t

c=a+1

import tkinter as tk

from PIL import Image, ImageTk

import numpy as np

from sklearn.cluster import KMeans

# Function to find the dominant color using k-means clustering

def find_dominant_color(image_path, k=3):

# Load the image

image = Image.open(image_path)

# Resize image to speed up processing

image = image.resize((100, 100)) # Adjust the size as needed

# Convert image to numpy array

image_array = np.array(image)

8
 # Reshape the image array to be a list of RGB pixels

reshaped_array = image_array.reshape((-1, 3))

# Use k-means clustering to find the dominant colors

kmeans = KMeans(n_clusters=k)

kmeans.fit(reshaped_array)

# Get the RGB values of the cluster centers

dominant_colors = kmeans.cluster_centers_.astype(int)

# Convert RGB values to hexadecimal color code

hex_colors = ['#{:02x}{:02x}{:02x}'.format(r, g, b) for r, g, b in dominant_colors]

# Return the dominant color (first cluster center)

return hex_colors[0]

# Function to navigate to the second page

def go_to_second_page():

# Hide the first page widgets

entry.pack_forget()

enter_button.pack_forget()

label.pack_forget()

# Show the second page widgets

second_page_label.pack(pady=20)

number_entry.pack(pady=10)

check_button.pack(pady=10)

result_label.pack(pady=20)

9
# Function to check if the number is odd or even

def check_odd_even():

user_input = number_entry.get()

if user_input.isdigit():

number = int(user_input)

if number % 2 == 0:

result.set(f"{number} is Even")

cursor.execute(f"insert into odd_or_even values({c},{user_input},'Even')")

ak47.commit()

else:

result.set(f"{number} is Odd")

cursor.execute(f"insert into odd_or_even values({c},{user_input},'Odd')")

ak47.commit()

else:

result.set("Please enter a valid number")

# Path to the image

image_path = r"C:\Users\MADHU\OneDrive\Desktop\ADITHYA\photo for dummy project.jpg"

# Get the dominant color of the image

bg_color = find_dominant_color(image_path)

# Create the main window

root = tk.Tk()

root.title("GRADE 11 CS gpt")

root.configure(bg=bg_color)

10
# Set fixed geometry for the window

root.geometry('525x550')

root.resizable(False, False)

# Load the image using PIL

pil_image = Image.open(image_path)

image = ImageTk.PhotoImage(pil_image)

# Create a label to display the image

label = tk.Label(root, image=image, bg=bg_color)

label.pack(pady=10)

# Create an entry box

entry = tk.Entry(root, font=('Helvetica', 14))

entry.pack(pady=10)

# Create a button that leads to the second page

enter_button = tk.Button(root, text="Enter", command=go_to_second_page, bg=bg_color, fg='white',

font=('Helvetica', 14))

enter_button.pack(pady=10)

# Create the second page label (initially hidden)

second_page_label = tk.Label(root, text="Enter a number to check if it's odd or even:", bg=bg_color,

fg='white', font=('Helvetica', 18))

second_page_label.pack_forget()

# Create an entry box for the number input on the second page

number_entry = tk.Entry(root, font=('Helvetica', 18))

11
number_entry.pack_forget()

# Create a button to check if the number is odd or even

check_button = tk.Button(root, text="Check", command=check_odd_even, bg=bg_color, fg='white',

font=('Helvetica', 18))

check_button.pack_forget()

# Variable to store the result

result = tk.StringVar()

# Create a label to display the result

result_label = tk.Label(root, textvariable=result, bg=bg_color, fg='white', font=('Helvetica', 18))

result_label.pack_forget()

# Run the Tkinter event loop

root.mainloop()

#backend

import mysql.connector as ak

ak47=ak.connect(host="localhost",user="root",passwd="Adithya008",database="dummy")

cursor=ak47.cursor()

cursor.execute("SELECT Sno FROM calculator ORDER BY Sno DESC LIMIT 1;")

t=cursor.fetchone()

a,=t

if t==():

cursor.execute("insert into odd_or_even valuses(1,user_input,);")

12
OUTPUT

13
14
 SOURCE CODE MAIN
"""

@author: Adithya.v

"""

def cs():

try:

def perfect_number():

def finding_perfect_number():

print()

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

b=[]

for i in range(1,a+1):

if a%i==0:

b.append(i)

c=0

for z in b:

c+=z

c=c-a

print(c)

if c==a:

print("it is a perfect number")

cursor.execute(f"update VERIFING_A_PERFECT_NUMBER set ANSWER='it is a

perfect number' where sno={c};")

ak47.commit()

else:

print("it is not a perfect number")

cursor.execute(f"update VERIFING_A_PERFECT_NUMBER set ANSWER='it is not a

perfect number' where sno={c};")

ak47.commit()

15
 cursor.execute(f"update VERIFING_A_PERFECT_NUMBER set NUMBER={a} where
sno={c};")

ak47.commit()

def perfect_numbers_in_a_particular_range():

print()

a=input("Enter the range(start limit:stop limit):")

aa=a.split(":")

b=[]

for k in aa:

d=""

c=k.split()

for j in c:

d+=j

b.append(int(d))

e=b[0]

f=b[1]

g=[]

for a in range(e,f+1):

h=[]

for i in range(1,a+1):

if a%i==0:

h.append(i)

c=0

for z in h:

c+=z

c=c-a

if c==a:

g.append(a)

print("All perfect numbers in that particular range is:")

16
 for i in g:

print(i)

cursor.execute(f"update FINDING_PERFECT_NUMBERS_IN_A_PARTICLAR_RANGE
set P_RANGE={aa} where sno={c};")

ak47.commit()

cursor.execute(f"update FINDING_PERFECT_NUMBERS_IN_A_PARTICLAR_RANGE
set ANSWER={g} where sno={c};")

ak47.commit()

print()

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for VERIFING A

PERFECT NUMBER \nPRESS 2 for FINDING PERFECT NUMBERS IN A PARTICLAR
RANGE:"))

if ch==1:

finding_perfect_number()

cursor.execute(f"update perfect_number set

VERIFING_A_PERFECT_NUMBER='Selected' where sno={c};")

ak47.commit()

elif ch==2:

perfect_numbers_in_a_particular_range()

cursor.execute(f"update perfect_number set

FINDING_PERFECT_NUMBERS_IN_A_PARTICLAR_RANGE='Selected' where sno={c};")

ak47.commit()

def neon_number():

def neon_numbers_in_a_particular_range():

print()

a=input("Enter the range(start limit:stop limit):")

aa=a.split(":")

b=[]

for k in aa:

d=""

c=k.split()

17
 for j in c:

d+=j

b.append(int(d))

e=b[0]

f=b[1]

g=[]

for i in range(e,f+1):

s=0

h=i**2

for j in str(h):

s+=int(j)

if s==i:

g.append(i)

print("All neon numbers in that particular range is:")

for i in g:

print(i)

cursor.execute(f"update FINDING_NEON_NUMBERS_IN_A_PARTICLAR_RANGE set

P_RANGE={aa} where sno={c};")

ak47.commit()

cursor.execute(f"update FINDING_NEON_NUMBERS_IN_A_PARTICLAR_RANGE set

ANSWER={g} where sno={c};")

ak47.commit()

def finding_neon_number():

print()

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

b=a**2

c=str(b)

d=0

for i in c:

18
 d+=int(i)

if d==a:

print("It is a neon number")

cursor.execute(f"update VERIFING_A_NEON_NUMBER set ANSWER='it is a neon

number' where sno={c};")

ak47.commit()

else:

print("It is not a neon number")

cursor.execute(f"update VERIFING_A_NEON_NUMBER set ANSWER='it is not a

neon number' where sno={c};")

ak47.commit()

cursor.execute(f"update VERIFING_A_NEON_NUMBER set NUMBER={a} where

sno={c};")

ak47.commit()

print()

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for VERIFING A

NEON NUMBER \nPRESS 2 for FINDING NEON NUMBERS IN A PARTICLAR RANGE:"))

if ch==1:

finding_neon_number()

cursor.execute(f"update neon_number set VERIFING_A_NEON_NUMBER='Selected'

where sno={c};")

ak47.commit()

elif ch==2:

neon_numbers_in_a_particular_range()

cursor.execute(f"update neon_number set

FINDING_NEON_NUMBERS_IN_A_PARTICLAR_RANGE='Selected' where sno={c};")

ak47.commit()

def armstrong_number():

def finding_armstrong_number():

print()

a=input("Enter the number:")

19
 b=int(a)

c=0

D="It is a Armstrong number"

E="It is not a Armstrong number"

for i in a:

c+=int(i)**3

if c==b:

print(D)

cursor.execute(f"update VERIFING_A_ARMSTRONG_NUMBER set ANSWER='It is

a armstrong number' where sno={c};")

ak47.commit()

else :

print(E)

cursor.execute(f"update VERIFING_A_ARMSTRONG_NUMBER set ANSWER='It is

not a armstrong number' where sno={c};")

ak47.commit()

cursor.execute(f"update VERIFING_A_ARMSTRONG_NUMBER set NUMBER={a}

where sno={c};")

ak47.commit()

def armstrong_numbers_in_a_particular_range():

print()

a=input("Enter the range(start limit:stop limit):")

aa=a.split(":")

b=[]

for k in aa:

d=""

c=k.split()

for j in c:

d+=j

b.append(int(d))

20
 e=b[0]

f=b[1]

g=[]

for i in range(e,f+1):

h=0

k=i

for j in str(i):

h+=int(j)**3

if h==k:

g.append(i)

print("All armstrong numbers in that particular range is:")

for l in g:

print(l)

cursor.execute(f"update
FINDING_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE set P_RANGE={aa} where
sno={c};")

ak47.commit()

cursor.execute(f"update
FINDING_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE set ANSWER={g} where
sno={c};")

ak47.commit()

def sum_of_armstrong_numbers_in_a_particular_range():

print()

a=input("Enter the range(start limit:stop limit):")

aa=a.split(":")

b=[]

s=0

for k in aa:

d=""

c=k.split()

21
 for j in c:

d+=j

b.append(int(d))

e=b[0]

f=b[1]

g=[]

for i in range(e,f+1):

h=0

k=i

for j in str(i):

h+=int(j)**3

if h==k:

g.append(i)

print("All armstrong numbers in that particular range is:")

for l in g:

print(l)

s+=l

cursor.execute(f"update
SUM_OF_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE set P_RANGE={aa} where
sno={c};")

ak47.commit()

cursor.execute(f"update
SUM_OF_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE set ANSWER={s} where
sno={c};")

ak47.commit()

print("Sum of all prime numbers in that range=",s)

print()

ch=int(input("WHAT DO YOU WANT TO CALCULATE \nPRESS 1 for VERIFING A

ARMSTRONG NUMBER \nPRESS 2 for FINDING ARMSTRONG NUMBERS IN A PARTICLAR
RANGE \nPRESS 3 for FINDING SUM OF ARMSTRONG NUMBERS IN A PARTICLAR
RANGE"))

22
 if ch==1:

finding_armstrong_number()

cursor.execute(f"update armstrong_number set

VERIFING_A_ARMSTRONG_NUMBER='Selected' where sno={c};")

ak47.commit()

elif ch==2:

armstrong_numbers_in_a_particular_range()

cursor.execute(f"update armstrong_number set

FINDING_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE='Selected' where sno={c};")

ak47.commit()

elif ch==3:

sum_of_armstrong_numbers_in_a_particular_range()

cursor.execute(f"update armstrong_number set

SUM_OF_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE='Selected' where sno={c};")

ak47.commit()

def prime_numbers():

def finding_prime_number():

print()

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

A="It is a prime number"

B="It is not a prime number"

lim=int(n/2)+1

for i in range(2,lim):

rem=n%i

if rem==0:

print(B)

cursor.execute(f"update Finding_prime_number set ANSWER={B} where sno={c};")

ak47.commit()

break

else:

23
 print(A)

cursor.execute(f"update Finding_prime_number set ANSWER={A} where sno={c};")

ak47.commit()

cursor.execute(f"update Finding_prime_number set NUMBER={n} where sno={c};")

ak47.commit()

def prime_numbers_in_a_particular_range():

print()

a=input("Enter the range(start limit:stop limit):")

aa=a.split(":")

b=[]

for k in aa:

d=""

c=k.split()

for j in c:

d+=j

b.append(int(d))

e=b[0]

f=b[1]

g=[]

for i in range(e,f+1):

h=[]

for j in range (1,i+1):

if i%j==0:

h.append(j)

if h==[1,i]:

g.append(i)

print("All prime numbers in that particular range is:")

for l in g:

24
 print(l)

cursor.execute(f"update Prime_numbers_in_a_particular_range set P_RANGE={aa} where

sno={c};")

ak47.commit()

cursor.execute(f"update Prime_numbers_in_a_particular_range set ANSWER={g} where

sno={c};")

ak47.commit()

def sum_of_prime_numbers_in_a_particular_range():

print()

a=input("Enter the range(start limit:stop limit):")

aa=a.split(":")

b=[]

s=0

for k in aa:

d=""

c=k.split()

for j in c:

d+=j

b.append(int(d))

e=b[0]

f=b[1]

g=[]

for i in range(e,f+1):

h=[]

for j in range (1,i+1):

if i%j==0:

h.append(j)

if h==[1,i]:

g.append(i)

25
 print("All prime numbers in that particular range is:")

for l in g:

print(l)

s+=i

print("Sum of all prime numbers in that range=",s)

cursor.execute(f"update Sum_of_prime_numbers_in_a_particular_range set

P_RANGE={aa} where sno={c};")

ak47.commit()

cursor.execute(f"update Sum_of_prime_numbers_in_a_particular_range set ANSWER={s}

where sno={c};")

ak47.commit()

print()

ch=int(input("WHAT DO YOU WANT TO CALCULATE \nPRESS 1 for VERIFING A

PRIME NUMBER \nPRESS 2 for FINDING PRIME NUMBERS IN A PARTICLAR RANGE
\nPRESS 3 for FINDING SUM OF PRIME NUMBERS IN A PARTICLAR RANGE"))

if ch==1:

finding_prime_number()

cursor.execute(f"update prime_number set Finding_prime_number='Selected' where

sno={c};")

ak47.commit()

elif ch==2:

prime_numbers_in_a_particular_range()

cursor.execute(f"update prime_number set

Prime_numbers_in_a_particular_range='Selected' where sno={c};")

ak47.commit()

elif ch==3:

sum_of_prime_numbers_in_a_particular_range()

cursor.execute(f"update prime_number set

Sum_of_prime_numbers_in_a_particular_range='Selected' where sno={c};")

ak47.commit()

def class_10_percentage_calculator():

26
 l=0

m=0

sci=0

ssc=0

s=0

n=0

e=0

t=0

h=0

sans=0

while True:

print()

ch=int(input("PRESS 1 for Language \nPRESS 2 for Maths\nPRESS 3 for Sciences

\nPRESS 4 for Social Science:"))

if ch==1:

if l<3:

print()

chh=int(input("PRESS 1 for English \nPRESS 2 for Tamil\nPRESS 3 for Hindi

\nPRESS 4 for Sanskrit:"))

if chh==1:

if e<1:

print()

c=float(input("Enter the English Marks:"))

s+=c

e+=1

n+=1

else:

print()

print("Already selected English")

27
if chh==2:

if t<1:

print()

c=float(input("Enter the Tamil Marks:"))

s+=c

t=+1

n+=1

else:

print()

print("Already selected Tamil")

if chh==3:

if h<1:

print()

c=float(input("Enter the Hindi Marks:"))

s+=c

h=+1

n+=1

else:

print()

print("Already selected Hindi")

if chh==4:

if sans<1:

print()

c=float(input("Enter the Sanskrit Marks:"))

s+=c

sans+=1

n+=1

else:

28
 print()

print("Already selected Sanskrit")

l+=1

else:

print()

print("Already selected two languages")

if ch==2:

if m<1:

print()

c=float(input("Enter the Maths Marks:"))

s+=c

m+=1

n+=1

else:

print()

print("Already selected Maths")

if ch==3:

if sci<1:

print()

c=float(input("Enter the Science Marks:"))

s+=c

sci+=1

n+=1

else:

print()

print("Already selected Science")

if ch==4:

if ssc<1:

29
 print()

c=float(input("Enter the Social Science Marks:"))

s+=c

ssc=+1

n+=1

else:

print()

print("Already selected Social science")

if n==5:

break

print()

print("Total mark=",s)

p=s/5

print("Percentage=",p)

if p>85:

print("A")

elif p<85 and p>=75:

print("B")

elif p<75 and p>=50:

print("C")

elif p>30 and p<=50:

print("D")

elif p<30:

print("Reappear")

cursor.execute(f"update class_10_percentage_calculator set TOTAL_MARK={s} where

sno={c};")

ak47.commit()

cursor.execute(f"update class_10_percentage_calculator set PERENTAGE={p} where

sno={c};")

30
 ak47.commit()

def calculator():

print()

def add():

n=int(input("Enter the no. of terms you want to add:"))

c=0

for i in range(n):

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

c+=a

print("Answer=",c)

cursor.execute(f"update ADDITION set NUMBER_OF_TERMS=n where sno={c};")

ak47.commit()

cursor.execute(f"update ADDITION set ANSWER={c} where sno={c};")

ak47.commit()

def sub():

n=int(input("Enter the no. of terms you want to subtract:"))

c=0

for i in range(n):

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

c-=a

print("Answer=",c)

cursor.execute(f"update SUBTRACTION set NUMBER_OF_TERMS=n where sno={c};")

ak47.commit()

cursor.execute(f"update SUBTRACTION set ANSWER={c} where sno={c};")

ak47.commit()

def mul():

n=int(input("Enter the no. of terms you want to multiply:"))

c=1

31
 for i in range(n):

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

c*=a

print("Answer=",c)

cursor.execute(f"update MULTIPLICATION set NUMBER_OF_TERMS=n where

sno={c};")

ak47.commit()

cursor.execute(f"update MULTIPLICATION set ANSWER={c} where sno={c};")

ak47.commit()

def div():

n=int(input("Enter the no. of terms you want to divid:"))

cc=0

c=int(input("Enter the first number(it cannot be zero):"))

while cc<n:

a=int(input("Enter the next number:"))

if a!=0:

c/=a

else:

print("we cannot divide by zero")

n+=1

ch=input("Do u want to contnue(y/n)")

if ch in "nN":

break

cc+=1

print("Answer=",c)

cursor.execute(f"update DIVISION set NUMBER_OF_TERMS=n where sno={c};")

ak47.commit()

cursor.execute(f"update DIVISION set ANSWER={c} where sno={c};")

ak47.commit()

32
def square():

side=float(input('Enter the length:'))

area1=side*side

print('Area of square=',area1)

cursor.execute(f"update square set SIDE={side} where sno={c};")

ak47.commit()

cursor.execute(f"update square set ANSWER={area1} where sno={c};")

ak47.commit()

def rectangle():

a1=float(input('Enter the lenght:'))

b1=float(input('Enter the breadth:'))

area2=a1*b1

print('Area of rectangle=',area2)

cursor.execute(f"update RECTANGLE set LENGHT={a1} where sno={c};")

ak47.commit()

cursor.execute(f"update RECTANGLE set BREADTH={b1} where sno={c};")

ak47.commit()

cursor.execute(f"update RECTANGLE set ANSWER={area2} where sno={c};")

ak47.commit()

def trianle():

a4=float(input("Enter the base:"))

b4=float(input("Enter the hight:"))

area4=(1/2)*a4*b4

print('Area of Triangle=',area4)

cursor.execute(f"update TRIANGLE set BASE={a4} where sno={c};")

ak47.commit()

cursor.execute(f"update TRIANGLE set HIGHT={b4} where sno={c};")

ak47.commit()

33
 cursor.execute(f"update TRIANGLE set ANSWER={area4} where sno={c};")

ak47.commit()

def circle():

r=float(input('Enter the radius:'))

area3=3.14*r**2

print("Area of circle=",area3)

cursor.execute(f"update CIRCLE set RADIUS={r} where sno={c};")

ak47.commit()

cursor.execute(f"update CIRCLE set ANSWER={area3} where sno={c};")

ak47.commit()

def semicircle():

r=float(input('Enter the radius:'))

area=(3.14*r**2)*1/2

print("Area of Semi-circle=",area)

cursor.execute(f"update SEMI_CIRCLE set RADIUS={r} where sno={c};")

ak47.commit()

cursor.execute(f"update SEMI_CIRCLE set ANSWER={area} where sno={c};")

ak47.commit()

def parallelogram():

a2=float(input('Enter the base:'))

h1=float(input('Enter the height:'))

area4=a2*h1

print('Area of parallelogram=',area4)

cursor.execute(f"update PARALLELOGRAM set BASE={a2} where sno={c};")

ak47.commit()

cursor.execute(f"update PARALLELOGRAM set HIGHT={h1} where sno={c};")

ak47.commit()

cursor.execute(f"update PARALLELOGRAM set ANSWER={area4} where sno={c};")

34
 ak47.commit()

def trapezium():

a3=float(input('Enter the base1:'))

b3=float(input('Enter the base2:'))

h2=float(input('Enter the height:'))

area5=((a3+b3)/2)*h2

print('Area of trapezium=',area5)

cursor.execute(f"update TRAPEZIUM set BASE1={a3} where sno={c};")

ak47.commit()

cursor.execute(f"update TRAPEZIUM set BASE2={a3} where sno={c};")

ak47.commit()

cursor.execute(f"update TRAPEZIUM set HIGHT={h2} where sno={c};")

ak47.commit()

cursor.execute(f"update TRAPEZIUM set ANSWER={area5} where sno={c};")

ak47.commit()

def rhombus():

a=float(input('Enter the diagonal1:'))

b=float(input('Enter the diagonal2:'))

area=1/2*a*b

print("Area of Rhombus=",area)

cursor.execute(f"update RHOMBUS set DIAGONAL1={a} where sno={c};")

ak47.commit()

cursor.execute(f"update RHOMBUS set DIAGONAL2={b} where sno={c};")

ak47.commit()

cursor.execute(f"update RHOMBUS set ANSWER={area} where sno={c};")

ak47.commit()

def diamond():

a=float(input('Enter the diagonal1:'))

35
 b=float(input('Enter the diagonal2:'))

area=1/2*a*b

print("Area of Diamond=",area)

cursor.execute(f"update RHOMBUS set DIAGONAL1={a} where sno={c};")

ak47.commit()

cursor.execute(f"update RHOMBUS set DIAGONAL2={b} where sno={c};")

ak47.commit()

cursor.execute(f"update RHOMBUS set ANSWER={area} where sno={c};")

ak47.commit()

def pentagon():

import math

a=float(input('Enter the length:'))

b=math.sqrt(5)

d=math.sqrt(5*(5+2*b))

area=1/4*(a**2)*d

print("Area of Pentagon=",area)

cursor.execute(f"update PENTAGON set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update PENTAGON set ANSWER={area} where sno={c};")

ak47.commit()

def hexagon():

import math

a=float(input('Enter the length:'))

b=math.sqrt(3)

d=(3*b)*1/2*(a**2)

print("Area of Hexagon=",d)

cursor.execute(f"update HEXAGON set LENGTH={a} where sno={c};")

ak47.commit()

36
 cursor.execute(f"update HEXAGON set ANSWER={d} where sno={c};")

ak47.commit()

def heptagon():

a=float(input('Enter the length:'))

area=3.63391*a*a

print("Area of Heptagon=",area)

cursor.execute(f"update HEPTAGON set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HEPTAGON set ANSWER={area} where sno={c};")

ak47.commit()

def octagon():

import math

a=float(input('Enter the length:'))

b=math.sqrt(2)

e=1+b

d=2*e

area=d*(a**2)

print("Area of Octagon",area)

cursor.execute(f"update OCTAGON set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update OCTAGON set ANSWER={area} where sno={c};")

ak47.commit()

def nonagon():

a=float(input('Enter the length:'))

area=6.18182*a*a

print("Area of Nonagon=",area)

cursor.execute(f"update NONAGON set LENGTH={a} where sno={c};")

ak47.commit()

37
 cursor.execute(f"update NONAGON set ANSWER={area} where sno={c};")

ak47.commit()

def decagon():

a=float(input('Enter the length:'))

area=7.69421*a*a

print("Area of decagon=",area)

cursor.execute(f"update DECAGON set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update DECAGON set ANSWER={area} where sno={c};")

ak47.commit()

def polygon():

a=float(input('Enter the length of an apothem:'))

b=float(input("Enter the perimeter:"))

area=(1/2)*a*b

print("Area of polygon=",area)

cursor.execute(f"update OCTAGON set LENGTH_OF_APOTHEM={a} where sno={c};")

ak47.commit()

cursor.execute(f"update DECAGON set PERIMETER={b} where sno={c};")

ak47.commit()

cursor.execute(f"update OCTAGON set ANSWER={area} where sno={c};")

ak47.commit()

def VOLcube():

a=float(input('Enter the length:'))

vol=a**3

print("Volume of Cube=",vol)

cursor.execute(f"update VOLCUBE set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCUBE set ANSWER={vol} where sno={c};")

38
 ak47.commit()

def CSAcube():

a=float(input('Enter the length:'))

area=4*a**2

print("Curved surface Area of Cube=",area)

cursor.execute(f"update CSA_CUBE set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CUBE set ANSWER={area} where sno={c};")

ak47.commit()

def TSAcube():

a=float(input("Enter the length:"))

area=6*a**2

print("Total Surface Area of Cube:",area)

cursor.execute(f"update TSA_CUBE set LENGTH={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CUBE set ANSWER={area} where sno={c};")

ak47.commit()

def VOLcuboid():

a=float(input('Enter the length:'))

b=float(input('Enter the breadth:'))

d=float(input('Enter the height:'))

vol=a*b*d

print("Volume of cuboid =",vol)

cursor.execute(f"update VOLCUBOID set LENGHT={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCUBOID set BREADTH={b} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCUBOID set HEIGHT={d} where sno={c};")

39
 ak47.commit()

cursor.execute(f"update VOLCUBOID set ANSWER={vol} where sno={c};")

ak47.commit()

def CSAcuboid():

a=float(input('Enter the length:'))

b=float(input('Enter the breadth:'))

d=float(input('Enter the height:'))

area=2*d*(a+b)

print("Curved surface Area of cuboid=",area)

cursor.execute(f"update CSA_CUBOID set LENGHT={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CUBOID set BREADTH={b} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CUBOID set HEIGHT={d} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CUBOID set ANSWER={area} where sno={c};")

ak47.commit()

def TSAcuboid():

a=float(input('Enter the length:'))

b=float(input('Enter the breadth:'))

d=float(input('Enter the height:'))

area=2*(a*b+b*d+a*d)

print("Total Surface Area of Cuboid=",area)

cursor.execute(f"update TSA_CUBOID set LENGHT={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CUBOID set BREADTH={b} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CUBOID set HEIGHT={d} where sno={c};")

40
 ak47.commit()

cursor.execute(f"update TSA_CUBOID set ANSWER={area} where sno={c};")

ak47.commit()

def VOLcone():

a=float(input('Enter the radius:'))

b=float(input('Enter the height:'))

vol=3.14*(a**3)*(b/3)

print("Volume of cone=",vol)

cursor.execute(f"update VOLCONE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCONE set HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCONE set ANSWER={vol} where sno={c};")

ak47.commit()

def CSAcone():

a=float(input('Enter the radius:'))

b=float(input('Enter the slant height:'))

area=3.14*a*b

print("Curved Surface Area of cone=",area)

cursor.execute(f"update CSA_CONE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CONE set HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CONE set ANSWER={area} where sno={c};")

ak47.commit()

def TSAcone():

a=float(input('Enter the radius:'))

b=float(input('Enter the slant height:'))

41
 area=3.14*a*(a+b)

print("Curved Surface Area of cone=",area)

cursor.execute(f"update TSA_CONE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CONE set HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CONE set ANSWER={area} where sno={c};")

ak47.commit()

def VOLcylinder():

a=float(input('Enter the radius:'))

b=float(input('Enter the height:'))

vol=3.14*a*a*b

print("Volume of Cylinder=",vol)

cursor.execute(f"update VOLCYLINDER set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCYLINDER set HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLCYLINDER set ANSWER={vol} where sno={c};")

ak47.commit()

def CSAcylinder():

a=float(input('Enter the radius:'))

b=float(input('Enter the height:'))

area=2*3.14*a*b

print("Curved Surface Area of Cylinder=",area)

cursor.execute(f"update CSA_CYLINDER set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_CYLINDER set HEIGHT={b} where sno={c};")

ak47.commit()

42
 cursor.execute(f"update CSA_CYLINDER set ANSWER={area} where sno={c};")

ak47.commit()

def TSAcylinder():

a=float(input('Enter the radius:'))

b=float(input('Enter the height:'))

area=2*3.14*a*(a+b)

print("Total Surface Area of Cylinder=",area)

cursor.execute(f"update TSA_CYLINDER set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CYLINDER set HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_CYLINDER set ANSWER={area} where sno={c};")

ak47.commit()

def VOLsphere():

a=float(input('Enter the radius:'))

vol=(4/3)*3.14*a**3

print("volume of Sphere=",vol)

cursor.execute(f"update VOLSPHERE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLSPHERE set ANSWER={vol} where sno={c};")

ak47.commit()

def CSAsphere():

a=float(input('Enter the radius:'))

area=4*3.14*a**2

print("Curved Surface Area of Sphere=",area)

cursor.execute(f"update CSA_SPHERE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_SPHERE set ANSWER={area} where sno={c};")

43
 ak47.commit()

def TSAsphere():

a=float(input('Enter the radius:'))

area=4*3.14*a**2

print("Total Surface Area of Sphere=",area)

cursor.execute(f"update TSA_SPHERE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_SPHERE set ANSWER={area} where sno={c};")

ak47.commit()

def VOLhemisphere():

a=float(input('Enter the radius:'))

vol=(2/3)*3.14*a**3

print("volume of hemisphere=",vol)

cursor.execute(f"update VOL_HEMISPHERE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOL_HEMISPHERE set ANSWER={vol} where sno={c};")

ak47.commit()

def CSAhemisphere():

a=float(input('Enter the radius:'))

area=2*3.14*a**2

print("Curved Surface Area of Hemisphere=",area)

cursor.execute(f"update CSA_HEMISPHERE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_HEMISPHERE set ANSWER={area} where sno={c};")

ak47.commit()

def TSAhemisphere():

a=float(input('Enter the radius:'))

area=3*3.14*a**2

44
 print("Total Surface Area of Hemisphere=",area)

cursor.execute(f"update TSA_HEMISPHERE set RADIUS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TSA_HEMISPHERE set ANSWER={area} where sno={c};")

ak47.commit()

def VOLpyramid():

a=float(input('Enter the base length:'))

b=float(input('Enter the base width:'))

d=float(input('Enter the pyramid height:'))

vol=(a*b*d)/3

print("Volume of pyramid=",vol)

cursor.execute(f"update VOLPYRAMID set BASE_PERIMETER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLPYRAMID set SLANT_HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLPYRAMID set PYRAMID_HEIGHT={d} where sno={c};")

ak47.commit()

cursor.execute(f"update VOLPYRAMID set ANSWER={vol} where sno={c};")

ak47.commit()

def CSApyramid():

a=float(input('Enter the base perimeter:'))

b=float(input('Enter the slant heght:'))

area=(1/2)*a*b

print("Curved Surface Area of Pyramid",area)

cursor.execute(f"update CSA_PYRAMID set BASE_PERIMETER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_PYRAMID set SLANT_HEIGHT={b} where sno={c};")

ak47.commit()

45
 cursor.execute(f"update CSA_PYRAMID set ANSWER={area} where sno={c};")

ak47.commit()

def TSApyramid():

a=float(input('Enter the base length:'))

b=float(input('Enter the base width:'))

d=float(input('Enter the pyramid height:'))

area=(1/2)*a*b+d

print("Total Surface Area of Pyramid",area)

cursor.execute(f"update CSA_PYRAMID set BASE_PERIMETER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_PYRAMID set SLANT_HEIGHT={b} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_PYRAMID set PYRAMID_HEIGHT={d} where sno={c};")

ak47.commit()

cursor.execute(f"update CSA_PYRAMID set ANSWER={area} where sno={c};")

ak47.commit()

def oval():

a=float(input('Enter the length of major axis:'))

b=float(input('Enter the length of minor axis:'))

area=3.14*a*b

print("Area of Oval=",area)

cursor.execute(f"update OVAL set MAJOR_AXIS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update OVAL set MINOR_AXIS={b} where sno={c};")

ak47.commit()

cursor.execute(f"update OVAL set ANSWER={area} where sno={c};")

ak47.commit()

def ellipse():

46
 a=float(input('Enter the length of major axis:'))

b=float(input('Enter the length of minor axis:'))

area=3.14*a*b

print("Area of Ellipse=",area)

cursor.execute(f"update ELLIPSE set MAJOR_AXIS={a} where sno={c};")

ak47.commit()

cursor.execute(f"update ELLIPSE set MINOR_AXIS={b} where sno={c};")

ak47.commit()

cursor.execute(f"update ELLIPSE set ANSWER={area} where sno={c};")

ak47.commit()

def kite():

a=float(input('Enter the diagonal1:'))

b=float(input('Enter the diagonal2:'))

area=1/2*a*b

print("Area of Kite=",area)

cursor.execute(f"update KITE set DIAGONAL1={a} where sno={c};")

ak47.commit()

cursor.execute(f"update KITE set DIAGONAL2={b} where sno={c};")

ak47.commit()

cursor.execute(f"update KITE set ANSWER={area} where sno={c};")

ak47.commit()

def sin():

import math

a=int(input("Enter the degree:"))

b=math.sin(a)

print('Sin ',a,"=",b)

cursor.execute(f"update SIN set DEGREE={a} where sno={c};")

ak47.commit()

47
 cursor.execute(f"update SIN set ANSWER={b} where sno={c};")

ak47.commit()

def cos():

import math

a=int(input("Enter the degree:"))

b=math.cos(a)

print("Cos ",a,"=",b)

cursor.execute(f"update COS set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update COS set ANSWER={b} where sno={c};")

ak47.commit()

def tan():

import math

a=int(input("Enter the degree:"))

b=math.tan(a)

print("Tan ",a,"=",b)

cursor.execute(f"update TAN set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TAN set ANSWER={b} where sno={c};")

ak47.commit()

def cosec():

import math

a=int(input("Enter the degree:"))

b=1/math.sin(a)

print("Cosec ",a,"=",b)

cursor.execute(f"update COSEC set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update COSEC set ANSWER={b} where sno={c};")

48
 ak47.commit()

def sec():

import math

a=int(input("Enter the degree:"))

b=1/math.cos(a)

print("Sec ",a,"=",b)

cursor.execute(f"update SEC set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update SEC set ANSWER={b} where sno={c};")

ak47.commit()

def cot():

import math

a=int(input("Enter the degree:"))

b=1/math.tan(a)

print("Cot ",a,"=",b)

cursor.execute(f"update COT set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update COT set ANSWER={b} where sno={c};")

ak47.commit()

def asin():

import math

a=int(input("Enter the degree:"))

b=math.asin(a)

print('Sin inverse',a,"=",b)

cursor.execute(f"update SIN_INVERSE set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update SIN_INVERSE set ANSWER={b} where sno={c};")

ak47.commit()

49
def acos():

import math

a=int(input("Enter the degree:"))

b=math.acos(a)

print("Cos inverse",a,"=",b)

cursor.execute(f"update COS_INVERSE set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update COS_INVERSE set ANSWER={b} where sno={c};")

ak47.commit()

def atan():

import math

a=int(input("Enter the degree:"))

b=math.atan(a)

print("Tan inverse",a,"=",b)

cursor.execute(f"update TAN_INVERSE set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update TAN_INVERSE set ANSWER={b} where sno={c};")

ak47.commit()

def acosec():

import math

a=int(input("Enter the degree:"))

b=math.asin(1/a)

print("Cosec inverse",a,"=",b)

cursor.execute(f"update COSEC_INVERSE set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update COSEC_INVERSE set ANSWER={b} where sno={c};")

ak47.commit()

def asec():

50
 import math

a=int(input("Enter the degree:"))

b=math.acos(1/a)

print("Sec inverse",a,"=",b)

cursor.execute(f"update SEC_INVERSE set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update SEC_INVERSE set ANSWER={b} where sno={c};")

ak47.commit()

def acot():

import math

a=int(input("Enter the degree:"))

b=math.atan(1/a)

print("Cot inverse",a,"=",b)

cursor.execute(f"update COT_INVERSE set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update COT_INVERSE set ANSWER={b} where sno={c};")

ak47.commit()

def sinh():

import math

a=int(input("Enter the degree:"))

b=math.sinh(a)

print('Hyperbolic Sin ',a,"=",b)

cursor.execute(f"update HYPERBOLIC_SIN set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HYPERBOLIC_SIN set ANSWER={b} where sno={c};")

ak47.commit()

def cosh():

import math

51
 a=int(input("Enter the degree:"))

b=math.cosh(a)

print("Hyperbolic Cos ",a,"=",b)

cursor.execute(f"update HYPERBOLIC_COS set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HYPERBOLIC_COS set ANSWER={b} where sno={c};")

ak47.commit()

def tanh():

import math

a=int(input("Enter the degree:"))

b=math.tanh(a)

print("Hyperbolic Tan ",a,"=",b)

cursor.execute(f"update HYPERBOLIC_TAN set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HYPERBOLIC_TAN set ANSWER={b} where sno={c};")

ak47.commit()

def cosech():

import math

a=int(input("Enter the degree:"))

b=1/math.sinh(a)

print("Hyperbolic Cosec ",a,"=",b)

cursor.execute(f"update HYPERBOLIC_COSEC set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HYPERBOLIC_COSEC set ANSWER={b} where sno={c};")

ak47.commit()

def sech():

import math

a=int(input("Enter the degree:"))

52
 b=1/math.cosh(a)

print("Hyperbolic Sec ",a,"=",b)

cursor.execute(f"update HYPERBOLIC_SEC set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HYPERBOLIC_SEC set ANSWER={b} where sno={c};")

ak47.commit()

def coth():

import math

a=int(input("Enter the degree:"))

b=1/math.tanh(a)

print("Hyperbolic Cot ",a,"=",b)

cursor.execute(f"update HYPERBOLIC_COT set DEGREE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update HYPERBOLIC_COT set ANSWER={b} where sno={c};")

ak47.commit()

def asinh():

import math

a=int(input("Enter the degree:"))

b=math.asinh(a)

print('Inverse hyperbolic Sin ',a,"=",b)

cursor.execute(f"update INVERSE_HYPERBOLIC_SIN set DEGREE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INVERSE_HYPERBOLIC_SIN set ANSWER={b} where

sno={c};")

ak47.commit()

def acosh():

import math

a=int(input("Enter the degree:"))

53
 b=math.acosh(a)

print("Inverse hyperbolic Cos ",a,"=",b)

cursor.execute(f"update INVERSE_HYPERBOLIC_COS set DEGREE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INVERSE_HYPERBOLIC_COS set ANSWER={b} where

sno={c};")

ak47.commit()

def atanh():

import math

a=int(input("Enter the degree:"))

b=math.atanh(a)

print("Inverse hyperbolic Tan ",a,"=",b)

cursor.execute(f"update INVERSE_HYPERBOLIC_TAN set DEGREE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INVERSE_HYPERBOLIC_TAN set ANSWER={b} where

sno={c};")

ak47.commit()

def acosech():

import math

a=int(input("Enter the degree:"))

b=math.asinh(1/a)

print("Inverse hyperbolic Cosec ",a,"=",b)

cursor.execute(f"update INVERSE_HYPERBOLIC_COSEC set DEGREE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INVERSE_HYPERBOLIC_COSEC set ANSWER={b} where

sno={c};")

ak47.commit()

def asech():

54
 import math

a=int(input("Enter the degree:"))

b=math.acosh(1/a)

print("Inverse hyperbolic Sec ",a,"=",b)

cursor.execute(f"update INVERSE_HYPERBOLIC_SEC set DEGREE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INVERSE_HYPERBOLIC_SEC set ANSWER={b} where

sno={c};")

ak47.commit()

def acoth():

import math

a=int(input("Enter the degree:"))

b=math.atanh(1/a)

print("Inverse hyperbolic Cot ",a,"=",b)

cursor.execute(f"update INVERSE_HYPERBOLIC_COT set DEGREE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INVERSE_HYPERBOLIC_COT set ANSWER={b} where

sno={c};")

ak47.commit()

def percentage():

a=float(input("Enter the value:"))

b=float(input("Enter the max value:"))

d=(a/b)*100

print("percentage=",d)

cursor.execute(f"update percentage set VALUE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update percentage set MAX_VALUE={b} where sno={c};")

ak47.commit()

55
 cursor.execute(f"update percentage set ANSWER={d} where sno={c};")

ak47.commit()

def power():

a=float(input("Enter the number:"))

b=float(input("Enter the power:"))

d=a**b

print("Answer=",d)

cursor.execute(f"update power set NUMBER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update power set POWER={b} where sno={c};")

ak47.commit()

cursor.execute(f"update power set ANSWER={d} where sno={c};")

ak47.commit()

def Square_root():

import math

a=float(input("Enter the number:"))

b=math.sqrt(a)

print("Square Root=",b)

cursor.execute(f"update power set NUMBER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update power set ANSWER={b} where sno={c};")

ak47.commit()

def cube_root():

a=float(input("Enter the number:"))

b=a**(1/3)

print("Square Root=",b)

cursor.execute(f"update cube_root set NUMBER={a} where sno={c};")

ak47.commit()

56
 cursor.execute(f"update cube_root set ANSWER={b} where sno={c};")

ak47.commit()

def log():

import math

a=float(input("Enter the value:"))

b=float(input("Enter the base:"))

d=math.log(a,b)

print("Log value=",d)

cursor.execute(f"update log set VALUE={a} where sno={c};")

ak47.commit()

cursor.execute(f"update log set BASE={b} where sno={c};")

ak47.commit()

cursor.execute(f"update log set ANSWER={d} where sno={c};")

ak47.commit()

def antilog():

import math

a=float(input("Enter the exponent:"))

b=float(input("Enter the base:"))

d=math.pow(b,a)

print("Antilog value=",d)

cursor.execute(f"update antilog set EXPONENT={a} where sno={c};")

ak47.commit()

cursor.execute(f"update antilog set BASE={b} where sno={c};")

ak47.commit()

cursor.execute(f"update antilog set ANSWER={d} where sno={c};")

ak47.commit()

print("THE CALCULATOR")

print()

57
 ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for SIMPLE
CALCULATION\nPress 2 for AREA OF 2D SHAPES\nPRESS 3 for AREA OR VOLUME OF 3D
SHAPES\nPRESS 4 for TRIGONOMETRIC VALUES\nPRESS 5 for INVERSE
TRIGONOMETRIC VALUES\nPRESS 6 for HYPERBOLIC TRIGONOMETRIC
VALUES\nPRESS 7 for INVERSE HYPERBOLIC TRIGONOMETRIC VALUES\nPRESS 8 for
PERCENTAGE\nPRESS 9 for POWER\nPRESS 10 for SQUARE ROOT\nPRESS 11 for CUBE
ROOT\nPRESS 12 for LOG\nPRESS 13 for ANTILOG:"))

print()

if ch==1:

ch1=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

ADDITION/nPRESS 2 for SUBTRACTION\nPRESS 3 for MULTIPLICATION\nPRESS 4 for
DIVISION:"))

print()

if ch1==1:

print()

add()

cursor.execute(f"update simple_calculation set ADDITION='Selected' where sno={c};")

ak47.commit()

elif ch1==2:

print()

sub()

cursor.execute(f"update simple_calculation set SUBTRACTION='Selected' where

sno={c};")

ak47.commit()

elif ch1==3:

print()

mul()

cursor.execute(f"update simple_calculation set MULTIPLICATION='Selected' where

sno={c};")

ak47.commit()

elif ch1==4:

print()

58
 div()

cursor.execute(f"update simple_calculation set DIVISION='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update CALCULATOR set SIMPLE_CALCULATION='Selected' where

sno={c};")

ak47.commit()

elif ch==2:

ch2=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

SQUARE\nPREESS 2 for RECTANGLE\nPRESS 3 for TRIANGLE\nPRESS 4 for
CIRCLE\nPRESS 5 for SEMI-CIRCLE\nPRESS 6 for PARALLELOGRAM\nPRESS 7 for
TRAPEZIUM\nPRESS 8 for RHOMBUS\nPRESS 9 for DIAMOND\nPRESS 10 for KITE\nPRESS
11 for OVAL\nPRESS 12 for ELLIPSE\nPRESS 13 for PENTAGON\nPRESS 14 for
HEXAGON\nPRESS 15 for HEPTAGON\nPRESS 16 for OCTAGON\nPRESS 17 for
NONAGON\nPRESS 18 for DECAGON\nPRESS 19 for POLYGON:"))

print()

if ch2==1:

print()

square()

cursor.execute(f"update area_of_2d_shapes set SQUARE='Selected' where sno={c};")

ak47.commit()

elif ch2==2:

print()

rectangle()

cursor.execute(f"update area_of_2d_shapes set RECTANGLE='Selected' where

sno={c};")

ak47.commit()

elif ch2==3:

print()

trianle()

cursor.execute(f"update area_of_2d_shapes set TRIANGLE='Selected' where sno={c};")

59
 ak47.commit()

elif ch2==4:

print()

circle()

cursor.execute(f"update area_of_2d_shapes set CIRCLE='Selected' where sno={c};")

ak47.commit()

elif ch2==5:

print()

semicircle()

cursor.execute(f"update area_of_2d_shapes set SEMI_CIRCLE='Selected' where

sno={c};")

ak47.commit()

elif ch2==6:

print()

parallelogram()

cursor.execute(f"update area_of_2d_shapes set PARALLELOGRAM='Selected' where

sno={c};")

ak47.commit()

elif ch2==7:

print()

trapezium()

cursor.execute(f"update area_of_2d_shapes set TRAPEZIUM='Selected' where

sno={c};")

ak47.commit()

elif ch2==8:

print()

rhombus()

cursor.execute(f"update area_of_2d_shapes set RHOMBUS='Selected' where sno={c};")

ak47.commit()

elif ch2==9:

60
 print()

diamond()

cursor.execute(f"update area_of_2d_shapes set DIAMOND='Selected' where sno={c};")

ak47.commit()

elif ch2==10:

print()

kite()

cursor.execute(f"update area_of_2d_shapes set KITE='Selected' where sno={c};")

ak47.commit()

elif ch2==11:

print()

oval()

cursor.execute(f"update area_of_2d_shapes set OVAL='Selected' where sno={c};")

ak47.commit()

elif ch2==12:

print()

ellipse()

cursor.execute(f"update area_of_2d_shapes set ELLIPSE='Selected' where sno={c};")

ak47.commit()

elif ch2==13:

print()

pentagon()

cursor.execute(f"update area_of_2d_shapes set PENTAGON='Selected' where

sno={c};")

ak47.commit()

elif ch2==14:

print()

hexagon()

cursor.execute(f"update area_of_2d_shapes set HEXAGON='Selected' where sno={c};")

61
 ak47.commit()

elif ch2==15:

print()

heptagon()

cursor.execute(f"update area_of_2d_shapes set HEPTAGON='Selected' where

sno={c};")

ak47.commit()

elif ch2==16:

print()

octagon()

cursor.execute(f"update area_of_2d_shapes set OCTAGON='Selected' where sno={c};")

ak47.commit()

elif ch2==17:

print()

nonagon()

cursor.execute(f"update area_of_2d_shapes set NONAGON='Selected' where sno={c};")

ak47.commit()

elif ch2==18:

print()

decagon()

cursor.execute(f"update area_of_2d_shapes set DECAGON='Selected' where sno={c};")

ak47.commit()

elif ch2==19:

print()

polygon()

cursor.execute(f"update area_of_2d_shapes set POLYGON='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

62
 cursor.execute(f"update CALCULATOR set AREA_OF_2D_SHAPES='Selected' where
sno={c};")

ak47.commit()

elif ch==3:

ch3=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

VOLUME\nPRESS 2 for CURVED SURFACE AREA\nPRESS 3 for TOTAL SURFACE AREA:"))

print()

if ch3==1:

ch3a=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

CUBE\nPRESS 2 for CUBOID\nPRESS 3 for CYLINDER\nPRESS 4 for CONE\nPRESS 5 for
PYRAMID\nPRESS 6 for SPHERE\nPRESS 7 for HEMISPHERE:"))

if ch3a==1:

print()

VOLcube()

cursor.execute(f"update VOLUME set VOLCUBE='Selected' where sno={c};")

ak47.commit()

elif ch3a==2:

print()

VOLcuboid()

cursor.execute(f"update VOLUME set VOLCUBOID='Selected' where sno={c};")

ak47.commit()

elif ch3a==3:

print()

VOLcylinder()

cursor.execute(f"update VOLUME set VOLCYLINDER='Selected' where sno={c};")

ak47.commit()

elif ch3a==4:

print()

VOLcone()

cursor.execute(f"update VOLUME set VOLCONE='Selected' where sno={c};")

63
 ak47.commit()

elif ch3a==5:

print()

VOLpyramid()

cursor.execute(f"update VOLUME set VOLPYRAMID='Selected' where sno={c};")

ak47.commit()

elif ch3a==6:

print()

VOLsphere()

cursor.execute(f"update VOLUME set VOLSPHERE='Selected' where sno={c};")

ak47.commit()

elif ch3a==7:

print()

VOLhemisphere()

cursor.execute(f"update VOLUME set VOL_HEMISPHERE='Selected' where

sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update area_or_volume_of_3d_shapes set VOLUME='Selected' where

sno={c};")

ak47.commit()

if ch3==2:

ch3b=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

CUBE\nPRESS 2 for CUBOID\nPRESS 3 for CYLINDER\nPRESS 4 for CONE\nPRESS 5 for
PYRAMID\nPRESS 6 for SPHERE\nPRESS 7 for HEMISPHERE:"))

if ch3b==1:

print()

CSAcube()

64
 cursor.execute(f"update CURVED_SURFACE_AREA set CSA_CUBE='Selected'
where sno={c};")

ak47.commit()

elif ch3b==2:

print()

CSAcuboid()

cursor.execute(f"update CURVED_SURFACE_AREA set CSA_CUBOID='Selected'

where sno={c};")

ak47.commit()

elif ch3b==3:

print()

CSAcylinder()

cursor.execute(f"update CURVED_SURFACE_AREA set

CSA_CYLINDER='Selected' where sno={c};")

ak47.commit()

elif ch3b==4:

print()

CSAcone()

cursor.execute(f"update CURVED_SURFACE_AREA set CSA_CONE='Selected'

where sno={c};")

ak47.commit()

elif ch3b==5:

print()

CSApyramid()

cursor.execute(f"update CURVED_SURFACE_AREA set

CSA_PYRAMID='Selected' where sno={c};")

ak47.commit()

elif ch3b==6:

print()

CSAsphere()

65
 cursor.execute(f"update CURVED_SURFACE_AREA set CSA_SPHERE='Selected'
where sno={c};")

ak47.commit()

elif ch3b==7:

print()

CSAhemisphere()

cursor.execute(f"update CURVED_SURFACE_AREA set

CSA_HEMISPHERE='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update area_or_volume_of_3d_shapes set

CURVED_SURFACE_AREA='Selected' where sno={c};")

ak47.commit()

if ch3==3:

ch3C=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

CUBE\nPRESS 2 for CUBOID\nPRESS 3 for CYLINDER\nPRESS 4 for CONE\nPRESS 5 for
PYRAMID\nPRESS 6 for SPHERE\nPRESS 7 for HEMISPHERE:"))

if ch3C==1:

print()

TSAcube()

cursor.execute(f"update TOTAL_SURFACE_AREA set TSA_CUBE='Selected' where

sno={c};")

ak47.commit()

elif ch3C==2:

print()

TSAcuboid()

cursor.execute(f"update TOTAL_SURFACE_AREA set TSA_CUBOID='Selected'

where sno={c};")

ak47.commit()

elif ch3C==3:

66
 print()

TSAcylinder()

cursor.execute(f"update TOTAL_SURFACE_AREA set TSA_CYLINDER='Selected'

where sno={c};")

ak47.commit()

elif ch3C==4:

print()

TSAcone()

cursor.execute(f"update TOTAL_SURFACE_AREA set TSA_CONE='Selected' where

sno={c};")

ak47.commit()

elif ch3C==5:

print()

TSApyramid()

cursor.execute(f"update TOTAL_SURFACE_AREA set TSA_PYRAMID='Selected'

where sno={c};")

ak47.commit()

elif ch3C==6:

print()

TSAsphere()

cursor.execute(f"update TOTAL_SURFACE_AREA set TSA_SPHERE='Selected'

where sno={c};")

ak47.commit()

elif ch3C==7:

print()

TSAhemisphere()

cursor.execute(f"update TOTAL_SURFACE_AREA set

TSA_HEMISPHERE='Selected' where sno={c};")

ak47.commit()

else:

67
 print("Out of range")

cursor.execute(f"update area_or_volume_of_3d_shapes set

TOTAL_SURFACE_AREA='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CALCULATOR set

AREA_OR_VOLUME_OF_3D_SHAPES='Selected' where sno={c};")

ak47.commit()

elif ch==4:

ch4=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for SIN\nPRESS 2

for COS\nPRESS 3 for TAN\nPRESS 4 for COSEC\nPRESS 5 for SEC\nPRESS 6 for COT:"))

print()

if ch4==1:

print()

sin()

cursor.execute(f"update trigonometric_values set SIN='Selected' where sno={c};")

ak47.commit()

elif ch4==2:

print()

cos()

cursor.execute(f"update trigonometric_values set COS='Selected' where sno={c};")

ak47.commit()

elif ch4==3:

print()

tan()

cursor.execute(f"update trigonometric_values set TAN='Selected' where sno={c};")

ak47.commit()

elif ch4==4:

print()

cosec()

cursor.execute(f"update trigonometric_values set COSEC='Selected' where sno={c};")

68
 ak47.commit()

elif ch4==5:

print()

sec()

cursor.execute(f"update trigonometric_values set SEC='Selected' where sno={c};")

ak47.commit()

elif ch4==6:

print()

cot()

cursor.execute(f"update trigonometric_values set COT='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update CALCULATOR set TRIGONOMETRIC_VALUES='Selected'

where sno={c};")

ak47.commit()

elif ch==5:

ch4=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for SIN

INVERSE\nPRESS 2 for COS INVERSE\nPRESS 3 for TAN INVERSE\nPRESS 4 for COSEC
INVERSE\nPRESS 5 for SEC INVERSE\nPRESS 6 for COT INVERSE:"))

print()

if ch4==1:

print()

asin()

cursor.execute(f"update inverse_trigonometric_values set SIN_INVERSE='Selected'

where sno={c};")

ak47.commit()

elif ch4==2:

print()

acos()

69
 cursor.execute(f"update inverse_trigonometric_values set COS_INVERSE='Selected'
where sno={c};")

ak47.commit()

elif ch4==3:

print()

atan()

cursor.execute(f"update inverse_trigonometric_values set TAN_INVERSE='Selected'

where sno={c};")

ak47.commit()

elif ch4==4:

print()

acosec()

cursor.execute(f"update inverse_trigonometric_values set COSEC_INVERSE='Selected'

where sno={c};")

ak47.commit()

elif ch4==5:

print()

asec()

cursor.execute(f"update inverse_trigonometric_values set SEC_INVERSE='Selected'

where sno={c};")

ak47.commit()

elif ch4==6:

print()

acot()

cursor.execute(f"update inverse_trigonometric_values set COT_INVERSE='Selected'

where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update CALCULATOR set

INVERSE_TRIGONOMETRIC_VALUES='Selected' where sno={c};")

70
 ak47.commit()

elif ch==6:

ch4=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for HYPERBOLIC

SIN\nPRESS 2 for HYPERBOLIC COS\nPRESS 3 for HYPERBOLIC TAN\nPRESS 4 for
HYPERBOLIC COSEC\nPRESS 5 for HYPERBOLIC SEC\nPRESS 6 for HYPERBOLIC COT:"))

print()

if ch4==1:

print()

sinh()

cursor.execute(f"update hyperbolic_trigonometric_values set

HYPERBOLIC_SIN='Selected' where sno={c};")

ak47.commit()

elif ch4==2:

print()

cosh()

cursor.execute(f"update hyperbolic_trigonometric_values set

HYPERBOLIC_COS='Selected' where sno={c};")

ak47.commit()

elif ch4==3:

print()

tanh()

cursor.execute(f"update hyperbolic_trigonometric_values set

HYPERBOLIC_TAN='Selected' where sno={c};")

ak47.commit()

elif ch4==4:

print()

cosech()

cursor.execute(f"update hyperbolic_trigonometric_values set

HYPERBOLIC_COSEC='Selected' where sno={c};")

ak47.commit()

elif ch4==5:

71
 print()

sech()

cursor.execute(f"update hyperbolic_trigonometric_values set

HYPERBOLIC_SEC='Selected' where sno={c};")

ak47.commit()

elif ch4==6:

print()

coth()

cursor.execute(f"update hyperbolic_trigonometric_values set

HYPERBOLIC_COT='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update CALCULATOR set

HYPERBOLIC_TRIGONOMETRIC_VALUES='Selected' where sno={c};")

ak47.commit()

elif ch==7:

ch4=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for INVERSE

HYPERBOLIC SIN\nPRESS 2 for INVERSE HYPERBOLIC COS\nPRESS 3 for INVERSE
HYPERBOLIC TAN\nPRESS 4 for INVERSE HYPERBOLIC COSEC\nPRESS 5 for INVERSE
HYPERBOLIC SEC\nPRESS 6 for INVERSE HYPERBOLIC COT:"))

print()

if ch4==1:

print()

asinh()

cursor.execute(f"update inverse_hyperbolic_trigonometric_values set

INVERSE_HYPERBOLIC_SIN='Selected' where sno={c};")

ak47.commit()

elif ch4==2:

print()

acosh()

72
 cursor.execute(f"update inverse_hyperbolic_trigonometric_values set
INVERSE_HYPERBOLIC_COS='Selected' where sno={c};")

ak47.commit()

elif ch4==3:

print()

atanh()

cursor.execute(f"update inverse_hyperbolic_trigonometric_values set

INVERSE_HYPERBOLIC_TAN='Selected' where sno={c};")

ak47.commit()

elif ch4==4:

print()

acosech()

cursor.execute(f"update inverse_hyperbolic_trigonometric_values set

INVERSE_HYPERBOLIC_COSEC='Selected' where sno={c};")

ak47.commit()

elif ch4==5:

print()

asech()

cursor.execute(f"update inverse_hyperbolic_trigonometric_values set

INVERSE_HYPERBOLIC_SEC='Selected' where sno={c};")

ak47.commit()

elif ch4==6:

print()

acoth()

cursor.execute(f"update inverse_hyperbolic_trigonometric_values set

INVERSE_HYPERBOLIC_COT='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update CALCULATOR set

INVERSE_HYPERBOLIC_TRIGONOMETRIC_VALUES='Selected' where sno={c};")

73
 ak47.commit()

elif ch==8:

percentage()

cursor.execute(f"update CALCULATOR set PERCENTAGE='Selected' where sno={c};")

ak47.commit()

elif ch==9:

power()

cursor.execute(f"update CALCULATOR set POWER='Selected' where sno={c};")

ak47.commit()

elif ch==10:

Square_root()

cursor.execute(f"update CALCULATOR set SQUARE_ROOT='Selected' where sno={c};")

ak47.commit()

elif ch==11:

cube_root()

cursor.execute(f"update CALCULATOR set CUBE_ROOT='Selected' where sno={c};")

ak47.commit()

elif ch==12:

log()

cursor.execute(f"update CALCULATOR set LOG='Selected' where sno={c};")

ak47.commit()

elif ch==13:

antilog()

cursor.execute(f"update CALCULATOR set ANTILOG='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

def palindrome():

74
 print()

a=input("ENTER:")

pal=a

b=a[::-1]

C="It is a Palindrome"

D="It is not a Palindrome"

if b==pal:

print(C)

cursor.execute(f"update palindrome set ANSWER={C} where sno={c};")

ak47.commit()

else:

print(D)

cursor.execute(f"update palindrome set ANSWER={D} where sno={c};")

ak47.commit()

cursor.execute(f"update palindrome set VALUE={a} where sno={c};")

ak47.commit()

def Greatest_number():

print()

a=input("Enter numbers which should be seperatered with comma:")

aa=a.split(",")

list(aa)

b=0

for i in aa:

if int(i)>b:

b=int(i)

print("The Greatest number=",b)

cursor.execute(f"update factorial set VALUE={a} where sno={c};")

ak47.commit()

75
 cursor.execute(f"update factorial set ANSWER={b} where sno={c};")

ak47.commit()

def vote_eligibility():

print()

a=int(input("Enter your age:"))

B="You are Eligibile for Voting"

C="You are not Eligibile for Voting"

if a>18:

print(B)

cursor.execute(f"update vote_eligibility set ANSWER='Eligibile' where sno={c};")

ak47.commit()

else:

print(C)

cursor.execute(f"update vote_eligibility set ANSWER='not Eligibile' where sno={c};")

ak47.commit()

cursor.execute(f"update vote_eligibility set AGE={a} where sno={c};")

ak47.commit()

def factorial():

print()

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

fact=1

while n>0:

fact*=n

n-=1

print("Factorial=",fact)

cursor.execute(f"update factorial set VALUE={n} where sno={c};")

ak47.commit()

cursor.execute(f"update factorial set ANSWER={fact} where sno={c};")

76
 ak47.commit()

def odd_or_even():

print()

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

B="Even numnber"

C="Odd number"

if a%2==0:

print(B)

cursor.execute(f"update odd_or_even set ANSWER={B} where sno={c};")

ak47.commit()

else:

print(C)

cursor.execute(f"update odd_or_even set ANSWER={C} where sno={c};")

ak47.commit()

cursor.execute(f"update odd_or_even set VALUE={a} where sno={c};")

ak47.commit()

def tables():

print()

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

for i in range(1,21):

print(n,"x",i,"=",n*i)

cursor.execute(f"update tables set VALUE={n} where sno={c};")

ak47.commit()

def pattern():

def Character_square_pattern():

a=input("Enter the character you want in the pattern:")

n=int(input("Enter the number of lines:"))

for i in range(n):

77
 for j in range(n):

print(a,end=" ")

print()

cursor.execute(f"update Character_square_pattern set CS_CHARACTER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update Character_square_pattern set CS_NUMBER_OF_LINES={n}

where sno={c};")

ak47.commit()

def CONSTANT_NUMBER_square_pattern():

a=input("Enter the number you want in the pattern:")

n=int(input("Enter the number of lines:"))

for i in range(n):

for j in range(n):

print(a,end=" ")

print()

cursor.execute(f"update CONSTANT_NUMBER_square_pattern set CNS_NUMBER={a}

where sno={c};")

ak47.commit()

cursor.execute(f"update CONSTANT_NUMBER_square_pattern set

CNS_NUMBER_OF_LINES={n} where sno={c};")

ak47.commit()

def INCREASING_NUMBER_square_pattern():

a=int(input("Enter the number you want in the pattern:"))

n=int(input("Enter the number of lines:"))

for i in range(n):

for j in range(n):

print(a,end=" ")

a+=1

print()

78
 cursor.execute(f"update INCREASING_NUMBER_square_pattern set INS_NUMBER={a}
where sno={c};")

ak47.commit()

cursor.execute(f"update INCREASING_NUMBER_square_pattern set

INS_NUMBER_OF_LINES={n} where sno={c};")

ak47.commit()

def CHARATER_diamond_pattern():

a=input("Enter the character you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end=" ")

print()

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CHARATER_diamond_pattern set CD_CHARACTER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update CHARATER_diamond_pattern set

CD_NUMBER_OF_LINES={row} where sno={c};")

79
 ak47.commit()

def CONSTANT_number_diamond_pattern():

a=input("Enter the number you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end=" ")

print()

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CONSTANT_number_diamond_pattern set CND_NUMBER={a}

where sno={c};")

ak47.commit()

cursor.execute(f"update CONSTANT_number_diamond_pattern set

CND_NUMBER={row} where sno={c};")

ak47.commit()

def INCREASING_number_diamond_pattern():

a=int(input("Enter the number you want in the pattern:"))

row=int(input("Enter the number of lines:"))

80
 k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end=" ")

a+=1

print()

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end="")

a-=1

print()

cursor.execute(f"update INCREASING_number_diamond_pattern set IND_NUMBER={a}

where sno={c};")

ak47.commit()

cursor.execute(f"update INCREASING_number_diamond_pattern set

IND_NUMBER_OF_LINES={row} where sno={c};")

ak47.commit()

def CHARACTER_right_aligned_triangle_pattern():

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

INCREASE(RHS)\nPRESS 2 for DECREASE(RHS)\nPRESS 3 for INCREASE(lHS)\nPRESS 4 for
DECREASE(LHS):"))

if ch==1:

a=input("Enter the character you want in the pattern:")

81
 n=int(input("Enter the number of lines:"))

for i in range(1,n+1):

for j in range(1,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CHARACTER_right_aligned_triangle_pattern set

RT_INCREASE_RHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update RT_INCREASE_RHS set RTIR_CHARACTER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update RT_INCREASE_RHS set RTIR_NUMBER_OF_LINESS={n}

where sno={c};")

ak47.commit()

elif ch==2:

a=input("Enter the character you want in the pattern:")

n=int(input("Enter the number of lines:"))

for i in range(n,0,-1):

for j in range(1,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CHARACTER_right_aligned_triangle_pattern set

RT_DECREASE_RHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update RT_DECREASE_RHS set RTDR_CHARACTER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update RT_DECREASE_RHS set RTDR_NUMBER_OF_LINESS={n}

where sno={c};")

ak47.commit()

elif ch==3:

82
 a=input("Enter the character you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end="")

print()

cursor.execute(f"update CHARACTER_right_aligned_triangle_pattern set

RT_INCREASE_lHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update RT_INCREASE_lHS set RTIL_CHARACTER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update RT_INCREASE_lHS set RTIL_NUMBER_OF_LINESS={row}

where sno={c};")

ak47.commit()

elif ch==4:

a=input("Enter the character you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end="")

print()

83
 cursor.execute(f"update CHARACTER_right_aligned_triangle_pattern set
RT_DECREASE_LHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update RT_DECREASE_LHS set RTDL_CHARACTER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update RT_DECREASE_LHS set

RTDL_NUMBER_OF_LINESS={row} where sno={c};")

ak47.commit()

else:

print("Out of range")

def CONSTANT_number_right_aligned_triangle_pattern():

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

INCREASE(RHS)\nPRESS 2 for DECREASE(RHS)\nPRESS 3 for INCREASE(lHS)\nPRESS 4 for
DECREASE(LHS):"))

if ch==1:

a=input("Enter the number you want in the pattern:")

n=int(input("Enter the number of lines:"))

for i in range(1,n+1):

for j in range(1,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CONSTANT_number_right_aligned_triangle_pattern set

CTNRT_INCREASE_RHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_INCREASE_RHS set CTNRTIR_CHARACTER={a}

where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_INCREASE_RHS set

CTNRTIR_NUMBER_OF_LINES={n} where sno={c};")

ak47.commit()

elif ch==2:

84
 a=input("Enter the number you want in the pattern:")

n=int(input("Enter the number of lines:"))

for i in range(n,0,-1):

for j in range(1,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CONSTANT_number_right_aligned_triangle_pattern set

CTNRT_DECREASE_RHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_DECREASE_RHS set CTNRTDR_CHARACTER={a}

where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_DECREASE_RHS set

CTNRTDR_NUMBER_OF_LINES={n} where sno={c};")

ak47.commit()

elif ch==3:

a=input("Enter the number you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end="")

print()

cursor.execute(f"update CONSTANT_number_right_aligned_triangle_pattern set

CTNRT_INCREASE_LHS='Selected' where sno={c};")

ak47.commit()

85
 cursor.execute(f"update CTNRT_INCREASE_LHS set CTNRTIL_CHARACTER={a}
where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_INCREASE_LHS set

CTNRTIL_NUMBER_OF_LINES={row} where sno={c};")

ak47.commit()

elif ch==4:

a=input("Enter the number you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end="")

print()

cursor.execute(f"update CONSTANT_number_right_aligned_triangle_pattern set

CTNRT_DECREASE_LHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_DECREASE_LHS set CTNRTDL_CHARACTER={a}

where sno={c};")

ak47.commit()

cursor.execute(f"update CTNRT_DECREASE_LHS set

CTNRTDL_NUMBER_OF_LINES={row} where sno={c};")

ak47.commit()

else:

print("Out of range")

def INCREASING_number_right_aligned_triangle_pattern():

86
 ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for
INCREASE(RHS)\nPRESS 2 for DECREASE(RHS)\nPRESS 3 for INCREASE(lHS)\nPRESS 4 for
DECREASE(LHS):"))

if ch==1:

a=int(input("Enter the starting number you want in the pattern:"))

n=int(input("Enter the number of lines:"))

for i in range(1,n+1):

for j in range(1,i+1):

print(a,end=" ")

n+=1

print()

cursor.execute(f"update INCREASING_number_right_aligned_triangle_pattern set

INRT_INCREASE_RHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update INRT_INCREASE_RHS set INRTIR_VALUE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INRT_INCREASE_RHS set

INRTIR_NUMBER_OF_LINES={n} where sno={c};")

ak47.commit()

elif ch==2:

a=int(input("Enter the starting number you want in the pattern:"))

n=int(input("Enter the number of lines:"))

for i in range(n,0,-1):

for j in range(1,i+1):

print(a,end=" ")

a+=1

print()

cursor.execute(f"update INCREASING_number_right_aligned_triangle_pattern set

INRT_DECREASE_RHS='Selected' where sno={c};")

ak47.commit()

87
 cursor.execute(f"update INRT_DECREASE_RHS set INRTDR_VALUE={a} where
sno={c};")

ak47.commit()

cursor.execute(f"update INRT_DECREASE_RHS set

INRTDR_NUMBER_OF_LINES={n} where sno={c};")

ak47.commit()

elif ch==3:

a=int(input("Enter the starting number you want in the pattern:"))

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end="")

a+=1

print()

cursor.execute(f"update INCREASING_number_right_aligned_triangle_pattern set

INRT_INCREASE_LHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update INRT_INCREASE_LHS set INRTIL_VALUE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INRT_INCREASE_LHS set

INRTIL_NUMBER_OF_LINES={row} where sno={c};")

ak47.commit()

elif ch==4:

a=int(input("Enter the starting number you want in the pattern:"))

row=int(input("Enter the number of lines:"))

88
 k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end="")

a+=1

print()

cursor.execute(f"update INCREASING_number_right_aligned_triangle_pattern set

INRT_DECREASE_LHS='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update INRT_DECREASE_LHS set INRTDL_VALUE={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update INRT_DECREASE_LHS set

INRTDL_NUMBER_OF_LINES={row} where sno={c};")

ak47.commit()

else:

print("Out of range")

def CHARATER_trangle_pattern():

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

NORMAL\nPRESS 2 for UPSIDEDOWN:"))

if ch==1:

a=input("Enter the character you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

89
 k-=1

for j in range(0,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CHARATER_trangle_pattern set CT_NORMAL='Selected'

where sno={c};")

ak47.commit()

cursor.execute(f"update CT_NORMAL set CTN_CHARACTER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CT_NORMAL set CTN_NUMBER_OF_LINES={row} where

sno={c};")

ak47.commit()

elif ch==2:

a=input("Enter the character you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CHARATER_trangle_pattern set

CT_UPSIDEDOWN='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CT_UPSIDEDOWN set CTU_CHARACTER={a} where

sno={c};")

ak47.commit()

90
 cursor.execute(f"update CT_UPSIDEDOWN set CTU_NUMBER_OF_LINES={row}
where sno={c};")

ak47.commit()

else:

print("Out of range")

def CONSTANT_number_trangle_pattern():

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

NORMAL\nPRESS 2 for UPSIDEDOWN:"))

if ch==1:

a=input("Enter the number you want in the pattern:")

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

for j in range(0,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CONSTANT_number_trangle_pattern set

CNT_NORMAL='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CNT_NORMAL set CNTN_NUMBER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update CNT_NORMAL set CNTN_NUMBER_OF_LINES={row}

where sno={c};")

ak47.commit()

elif ch==2:

a=input("Enter the number you want in the pattern:")

row=int(input("Enter the number of lines:"))

91
 k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end=" ")

print()

cursor.execute(f"update CONSTANT_number_trangle_pattern set

CNT_UPSIDEDOWN='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update CNT_UPSIDEDOWN set CNTU_NUMBER={a} where

sno={c};")

ak47.commit()

cursor.execute(f"update CNT_UPSIDEDOWN set

CNTU_NUMBER_OF_LINES={row} where sno={c};")

ak47.commit()

else:

print("Out of range")

def INCREASING_number_trangle_pattern():

ch=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for

NORMAL\nPRESS 2 for UPSIDEDOWN:"))

if ch==1:

a=int(input("Enter the starting number you want in the pattern:"))

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(0,row):

for j in range(0,k):

print(end=" ")

k-=1

92
 for j in range(0,i+1):

print(a,end=" ")

a+=1

print()

cursor.execute(f"update INCREASING_number_trangle_pattern set

INT_NORMAL='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update INT_NORMAL set INTN_NUMBER={a} where sno={c};")

ak47.commit()

cursor.execute(f"update INT_NORMAL set INTN_NUMBER_OF_LINES={row} where

sno={c};")

ak47.commit()

elif ch==2:

a=int(input("Enter the starting number you want in the pattern:"))

row=int(input("Enter the number of lines:"))

k=2*row-2

for i in range(row,-1,-1):

for j in range(k,0,-1):

print(end=" ")

k+=1

for j in range(0,i+1):

print(a,end="")

a+=1

print()

cursor.execute(f"update INCREASING_number_trangle_pattern set

INT_UPSIDEDOWN='Selected' where sno={c};")

ak47.commit()

cursor.execute(f"update INT_UPSIDEDOWN set INTU_NUMBER={a} where

sno={c};")

ak47.commit()

93
 cursor.execute(f"update INT_UPSIDEDOWN set INTU_NUMBER_OF_LINES={row}
where sno={c};")

ak47.commit()

else:

print("Out of range")

print()

cho=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for RIGHT

ALIGNED TRIANGLE PATTERN\nPRESS 2 for TRIANGLE PATTERN\nPRESS 3 for
DIAMOND PATTERN:\nPRESS 4 for SQUARE PATTERN:"))

print()

if cho==1:

chh=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for CHARACTER

RIGHT ALIGNED TRIANGLE PATTERN\nPRESS 2 for CONSTANT NUMBER RIGHT
ALIGNED TRIANGLE PATTERN\nPRESS 3 for INCREASING NUMBER RIGHT ALIGNED
TRIANGLE PATTERN:"))

print()

if chh==1:

CHARACTER_right_aligned_triangle_pattern()

cursor.execute(f"update RIGHT_ALIGNED_TRIAGLE_PATTERN set

CHARACTER_right_aligned_triangle_pattern='Selected' where sno={c};")

ak47.commit()

elif chh==2:

CONSTANT_number_right_aligned_triangle_pattern()

cursor.execute(f"update RIGHT_ALIGNED_TRIAGLE_PATTERN set

CONSTANT_number_right_aligned_triangle_pattern='Selected' where sno={c};")

ak47.commit()

elif chh==3:

INCREASING_number_right_aligned_triangle_pattern()

cursor.execute(f"update RIGHT_ALIGNED_TRIAGLE_PATTERN set

INCREASING_number_right_aligned_triangle_pattern='Selected' where sno={c};")

ak47.commit()

else:

94
 print("Out of range")

cursor.execute(f"update pattern set RIGHT_ALIGNED_TRIAGLE_PATTERN='Selected'

where sno={c};")

ak47.commit()

elif cho==2:

chh=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for CHARACTER

TRIANGLE PATTERN\nPRESS 2 for CONSTANT NUMBER TRIANGLE PATTERN\nPRESS 3
for INCREASING NUMBER TRIANGLE PATTERN:"))

print()

if chh==1:

CHARATER_trangle_pattern()

cursor.execute(f"update TRIANGLE_PATTERN set

CHARATER_trangle_pattern='Selected' where sno={c};")

ak47.commit()

elif chh==2:

CONSTANT_number_trangle_pattern()

cursor.execute(f"update TRIANGLE_PATTERN set

CONSTANT_number_trangle_pattern='Selected' where sno={c};")

ak47.commit()

elif chh==3:

INCREASING_number_trangle_pattern()

cursor.execute(f"update TRIANGLE_PATTERN set

INCREASING_number_trangle_pattern='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update pattern set TRIANGLE_PATTERN='Selected' where sno={c};")

ak47.commit()

elif cho==3:

chh=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for CHARACTER

DIAMOND PATTERN\nPRESS 2 for CONSTANT NUMBER DIAMOND PATTERN\nPRESS 3
for INCREASING NUMBER DIAMOND PATTERN:"))

95
 print()

if chh==1:

CHARATER_diamond_pattern()

cursor.execute(f"update DIAMOND_PATTERN set

CHARATER_diamond_pattern='Selected' where sno={c};")

ak47.commit()

if chh==2:

CONSTANT_number_diamond_pattern()

cursor.execute(f"update DIAMOND_PATTERN set

CONSTANT_number_diamond_pattern='Selected' where sno={c};")

ak47.commit()

if chh==3:

INCREASING_number_diamond_pattern()

cursor.execute(f"update DIAMOND_PATTERN set

INCREASING_number_diamond_pattern='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update pattern set DIAMOND_PATTERN='Selected' where sno={c};")

ak47.commit()

elif cho==4:

chh=int(input("WHAT DO YOU WANT TO CALCULATE\nPRESS 1 for CHARACTER

SQUARE PATTERN\nPRESS 2 for CONSTANT NUMBER SQUARE PATTERN\nPRESS 3 for
INCREASING NUMBER SQUARE PATTERN:"))

print()

if chh==1:

Character_square_pattern()

cursor.execute(f"update SQUARE_PATTERN set Character_square_pattern='Selected'

where sno={c};")

ak47.commit()

if chh==2:

96
 CONSTANT_NUMBER_square_pattern()

cursor.execute(f"update SQUARE_PATTERN set

CONSTANT_NUMBER_square_pattern='Selected' where sno={c};")

ak47.commit()

if chh==3:

INCREASING_NUMBER_square_pattern()

cursor.execute(f"update SQUARE_PATTERN set

INCREASING_NUMBER_square_pattern='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

cursor.execute(f"update pattern set SQUARE_PATTERN='Selected' where sno={c};")

ak47.commit()

def dice_game():

print()

n=int(input("Enter the number of chances:"))

c="you won"

d='you lose'

for i in range(n):

print()

num1=int(input('enter the first number:'))

num2=int(input('enter the second numbe:'))

import random

a=random.randint(1,6)

b=random.randint(1,6)

if num1==a and num2==b:

print('the computers random numbers are',a,',',b)

print(c)

cursor.execute(f"update dice_game set ANSWER={c} where sno={c};")

97
 ak47.commit()

break

elif num1==b and num2==a:

print('the computers random numbers are',a,',',b)

print(c)

cursor.execute(f"update dice_game set ANSWER={c} where sno={c};")

ak47.commit()

break

else:

print('the computers random numbers are',a,',',b)

print(d)

cursor.execute(f"update dice_game set ANSWER={d} where sno={c};")

ak47.commit()

n-=1

print('game over')

cursor.execute(f"update dice_game set NUMBER_OF_CHANCES={n} where sno={c};")

ak47.commit()

while True:

import mysql.connector as ak

ak47=ak.connect(host="localhost",user="root",passwd="Adithya008",database="ak47")

cursor=ak47.cursor()

cursor.execute("SELECT Sno FROM calculator ORDER BY Sno DESC LIMIT 1;")

t=cursor.fetchone()

a,=t

c=a+1

l=['the_computer_science_grade_11_gpt', 'calculator', 'antilog', 'area_of_2d_shapes',

'area_or_volume_of_3d_shapes', 'armstrong_number', 'class_10_percentage_calculator', 'cube_root',
'dice_game', 'factorial', 'finding_armstrong_numbers_in_a_particlar_range',
'finding_neon_numbers_in_a_particlar_range', 'finding_perfect_numbers_in_a_particlar_range',
'finding_prime_number', 'greatest_number', 'hyperbolic_trigonometric_values',

98
'inverse_hyperbolic_trigonometric_values', 'inverse_trigonometric_values', 'log', 'neon_number',
'odd_or_even', 'palindrome', 'pattern', 'percentage', 'perfect_number', 'power',
'prime_numbers_in_a_particular_range', 'prime_number', 'simple_calculation', 'square_root',
'sum_of_armstrong_numbers_in_a_particlar_range', 'sum_of_prime_numbers_in_a_particular_range',
'tables', 'trigonometric_values', 'verifing_a_armstrong_number', 'verifing_a_neon_number',
'verifing_a_perfect_number', 'vote_eligibility', 'circle', 'diamond', 'ellipse', 'heptagon', 'hexagon', 'kite',
'nonagon', 'octagon','DECAGON', 'oval', 'parallelogram', 'pentagon', 'polygon', 'rectangle', 'rhombus',
'semi_circle', 'square', 'trapezium', 'triangle', 'curved_surface_area', 'total_surface_area', 'volcone',
'volcube', 'volcuboid', 'volcylinder', 'volpyramid', 'volsphere', 'volume', 'vol_hemisphere',
'hyperbolic_cosec', 'hyperbolic_cos', 'hyperbolic_cot', 'hyperbolic_sec', 'hyperbolic_sin',
'hyperbolic_tan', 'inverse_hyperbolic_cosec', 'inverse_hyperbolic_cos', 'inverse_hyperbolic_cot',
'inverse_hyperbolic_sec', 'inverse_hyperbolic_sin', 'inverse_hyperbolic_tan', 'cosec_inverse',
'cos_inverse', 'cot_inverse', 'sec_inverse', 'sin_inverse', 'tan_inverse', 'diamond_pattern',
'right_aligned_triagle_pattern', 'square_pattern', 'triangle_pattern', 'addition', 'division', 'multiplication',
'subtraction', 'cosec', 'cos', 'cot', 'sec', 'sin', 'tan', 'csa_cone', 'csa_cube', 'csa_cuboid', 'csa_cylinder',
'csa_hemisphere', 'csa_pyramid', 'csa_sphere', 'tsa_cone', 'tsa_cube', 'tsa_cuboid', 'tsa_cylinder',
'tsa_hemisphere', 'tsa_pyramid', 'tsa_sphere', 'charater_diamond_pattern',
'constant_number_diamond_pattern', 'increasing_number_diamond_pattern',
'character_right_aligned_triangle_pattern', 'constant_number_right_aligned_triangle_pattern',
'increasing_number_right_aligned_triangle_pattern', 'character_square_pattern',
'constant_number_square_pattern', 'increasing_number_square_pattern', 'charater_trangle_pattern',
'constant_number_trangle_pattern', 'increasing_number_trangle_pattern', 'rt_decrease_lhs',
'rt_decrease_rhs', 'rt_increase_lhs', 'rt_increase_rhs', 'ctnrt_decrease_lhs', 'ctnrt_decrease_rhs',
'ctnrt_increase_lhs', 'ctnrt_increase_rhs', 'inrt_decrease_lhs', 'inrt_decrease_rhs', 'inrt_increase_lhs',
'inrt_increase_rhs', 'ct_normal', 'ct_upsidedown', 'cnt_normal', 'cnt_upsidedown', 'int_normol',
'int_upsidedown']

for i in l:

cursor.execute(f"insert into {i}(Sno) values({c});")

ak47.commit()

print()

print("THE COMPUTER SCIENCE GRADE 11 GPT")

print()

choose=int(input("WHAT DO YOU WANT TO CALCULATOR\nPRESS 1 for

CALCULATOR\nPRESS 2 for PALINDROME IDENTIFIER \nPRESS 3 for GREATEST
NUMBER\nPRESS 4 for VOTE ELIGIBILITY\nPRESS 5 for FACTORIAL\nPRESS 6 for EVEN
OR ODD\nPRESS 7 for TABLES\nPRESS 8 for PATTERN\nPRESS 9 for DICE GAME \nPRESS
10 for CLASS 10 PERCENTAGE CALCULATOR \nPRESS 11 for PRIME NUMBER \nPRESS 12
for ARMSTRONG NUMBER \nPRESS 13 for NEON NUMBER \nPRESS 14 for PERFECT
NUMBER:"))

if choose==1:

calculator()

99
 cursor.execute(f"update the_computer_science_grade_11_gpt set
CALCULATOR='Selected' where sno={c};")

ak47.commit()

elif choose==2:

palindrome()

cursor.execute(f"update the_computer_science_grade_11_gpt set

PALINDROME_IDENTIFIER='Selected' where sno={c};")

ak47.commit()

elif choose==3:

Greatest_number()

cursor.execute(f"update the_computer_science_grade_11_gpt set

GREATEST_NUMBER='Selected' where sno={c};")

ak47.commit()

elif choose==4:

vote_eligibility()

cursor.execute(f"update the_computer_science_grade_11_gpt set

VOTE_ELIGIBILITY='Selected' where sno={c};")

ak47.commit()

elif choose==5:

factorial()

cursor.execute(f"update the_computer_science_grade_11_gpt set FACTORIAL='Selected'

where sno={c};")

ak47.commit()

elif choose==6:

odd_or_even()

cursor.execute(f"update the_computer_science_grade_11_gpt set

EVEN_OR_ODD='Selected' where sno={c};")

ak47.commit()

elif choose==7:

tables()

100
 cursor.execute(f"update the_computer_science_grade_11_gpt set TABLES='Selected'
where sno={c};")

ak47.commit()

elif choose==8:

pattern()

cursor.execute(f"update the_computer_science_grade_11_gpt set PATTERN='Selected'

where sno={c};")

ak47.commit()

elif choose==9:

dice_game()

cursor.execute(f"update the_computer_science_grade_11_gpt set DICE_GAME='Selected'

where sno={c};")

ak47.commit()

elif choose==10:

class_10_percentage_calculator()

cursor.execute(f"update the_computer_science_grade_11_gpt set

CLASS_10_PERCENTAGE_CALCULATOR='Selected' where sno={c};")

ak47.commit()

elif choose==11:

prime_numbers()

cursor.execute(f"update the_computer_science_grade_11_gpt set

PRIME_NUMBER='Selected' where sno={c};")

ak47.commit()

elif choose==12:

armstrong_number()

cursor.execute(f"update the_computer_science_grade_11_gpt set

ARMSTRONG_NUMBER='Selected' where sno={c};")

ak47.commit()

elif choose==13:

neon_number()

101
 cursor.execute(f"update the_computer_science_grade_11_gpt set
NEON_NUMBER='Selected' where sno={c};")

ak47.commit()

elif choose==14:

perfect_number()

cursor.execute(f"update the_computer_science_grade_11_gpt set

PERFECT_NUMBER='Selected' where sno={c};")

ak47.commit()

else:

print("Out of range")

print()

c=input(("DO YOU WANT TO CONTINUE(Y/N):"))

if c in "Nn":

break

except TypeError:

print("\033[31mUSE APPROPRIATE DATA TYPE\033[0m")

print("\033[31mTRY AGAIN\033[0m")

except ZeroDivisionError:

print("\033[31mYOU CAN'T DIVIDE BY ZERO\033[0m")

print("\033[31mTRY AGAIN\033[0m")

except:

print("\033[31mTRY AGAIN\033[0m")

cs()

BACK END
TABLES:

1 addition
2 antilog
3 area_of_2d_shapes

102
4 area_or_volume_of_3d_shapes
5 armstrong_number
6 calculator
7 character_right_aligned_triangle_pattern
8 character_square_pattern
9 charater_diamond_pattern
10 charater_trangle_pattern
11 circle
12 class_10_percentage_calculator
13 cnt_normal
14 cnt_upsidedown
15 constant_number_diamond_pattern
16 constant_number_right_aligned_triangle_pattern
17 constant_number_square_pattern
18 constant_number_trangle_pattern
19 cos
20 cos_inverse
21 cosec
22 cosec_inverse
23 cot
24 cot_inverse
25 csa_cone
26 csa_cube
27 csa_cuboid
28 csa_cylinder
29 csa_hemisphere
30 csa_pyramid
31 csa_sphere
32 ct_normal
33 ct_upsidedown
34 ctnrt_decrease_lhs
35 ctnrt_decrease_rhs
36 ctnrt_increase_lhs
37 ctnrt_increase_rhs
38 cube_root
39 curved_surface_area
40 decagon
41 diamond
42 diamond_pattern
43 dice_game
44 division
45 ellipse
46 factorial
47 finding_armstrong_numbers_in_a_particlar_range
48 finding_neon_numbers_in_a_particlar_range
49 finding_perfect_numbers_in_a_particlar_range
50 finding_prime_number

103
51 greatest_number
52 heptagon
53 hexagon
54 hyperbolic_cos
55 hyperbolic_cosec
56 hyperbolic_cot
57 hyperbolic_sec
58 hyperbolic_sin
59 hyperbolic_tan
60 hyperbolic_trigonometric_values
61 increasing_number_diamond_pattern
62 increasing_number_right_aligned_triangle_pattern
63 increasing_number_square_pattern
64 increasing_number_trangle_pattern
65 inrt_decrease_lhs
66 inrt_decrease_rhs
67 inrt_increase_lhs
68 inrt_increase_rhs
69 int_normal
70 int_upsidedown
71 inverse_hyperbolic_cos
72 inverse_hyperbolic_cosec
73 inverse_hyperbolic_cot
74 inverse_hyperbolic_sec
75 inverse_hyperbolic_sin
76 inverse_hyperbolic_tan
77 inverse_hyperbolic_trigonometric_values
78 inverse_trigonometric_values
79 kite
80 log
81 multiplication
82 neon_number
83 nonagon
84 octagon
85 odd_or_even
86 oval
87 palindrome
88 parallelogram
89 pattern
90 pentagon
91 percentage
92 perfect_number
93 polygon
94 power
95 prime_number
96 prime_numbers_in_a_particular_range
97 rectangle

104
98 rhombus
99 right_aligned_triagle_pattern
100 rt_decrease_lhs
101 rt_decrease_rhs
102 rt_increase_lhs
103 rt_increase_rhs
104 sec
105 sec_inverse
106 semi_circle
107 simple_calculation
108 sin
109 sin_inverse
110 square
111 square_pattern
112 square_root
113 subtraction
114 sum_of_armstrong_numbers_in_a_particlar_range
115 sum_of_prime_numbers_in_a_particular_range
116 tables
117 tan
118 tan_inverse
119 the_computer_science_grade_11_gpt
120 total_surface_area
121 trapezium
122 triangle
123 triangle_pattern
124 trigonometric_values
125 tsa_cone
126 tsa_cube
127 tsa_cuboid
128 tsa_cylinder
129 tsa_hemisphere
130 tsa_pyramid
131 tsa_sphere
132 verifing_a_armstrong_number
133 verifing_a_neon_number
134 verifing_a_perfect_number
135 vol_hemisphere
136 volcone
137 volcube
138 volcuboid
139 volcylinder
140 volpyramid
141 volsphere
142 volume
143 vote_eligibility

105
1) Table: addition
CREATE TABLE `addition` (
`SNO` int NOT NULL,
`NUMBER_OF_TERMS` int,
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `addition_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `simple_calculation`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

2)Table: antilog
CREATE TABLE `antilog` (
`SNO` int NOT NULL,
`EXPONENT` float(200,15),
`BASE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `antilog_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

3)Table: area_of_2d_shapes
CREATE TABLE `area_of_2d_shapes` (
`SNO` int NOT NULL,
`SQUARE` enum('Selected'),
`RECTANGLE` enum('Selected'),
`TRIANGLE` enum('Selected'),
`CIRCLE` enum('Selected'),
`SEMI_CIRCLE` enum('Selected'),
`PARALLELOGRAM` enum('Selected'),
`TRAPEZIUM` enum('Selected'),
`RHOMBUS` enum('Selected'),
`DIAMOND` enum('Selected'),
`KITE` enum('Selected'),
`OVAL` enum('Selected'),
`ELLIPSE` enum('Selected'),
`PENTAGON` enum('Selected'),
`HEXAGON` enum('Selected'),
`HEPTAGON` enum('Selected'),
`OCTAGON` enum('Selected'),
`NONAGON` enum('Selected'),
`DECAGON` enum('Selected'),

106
 `POLYGON` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `area_of_2d_shapes_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

4)Table: area_or_volume_of_3d_shapes
CREATE TABLE `area_or_volume_of_3d_shapes` (
`SNO` int NOT NULL,
`VOLUME` enum('Selected'),
`CURVED_SURFACE_AREA` enum('Selected'),
`TOTAL_SURFACE_AREA` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `area_or_volume_of_3d_shapes_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

5)Table: armstrong_number
CREATE TABLE `armstrong_number` (
`SNO` int NOT NULL,
`VERIFING_A_ARMSTRONG_NUMBER` enum('Selected'),
`FINDING_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE` enum('Selected'),
`SUM_OF_ARMSTRONG_NUMBERS_IN_A_PARTICLAR_RANGE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `armstrong_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

6)Table: calculator
CREATE TABLE `calculator` (
`SNO` int NOT NULL,
`SIMPLE_CALCULATION` enum('Selected'),
`AREA_OF_2D_SHAPES` enum('Selected'),
`AREA_OR_VOLUME_OF_3D_SHAPES` enum('Selected'),
`TRIGONOMETRIC_VALUES` enum('Selected'),
`INVERSE_TRIGONOMETRIC_VALUES` enum('Selected'),
`HYPERBOLIC_TRIGONOMETRIC_VALUES` enum('Selected'),
`INVERSE_HYPERBOLIC_TRIGONOMETRIC_VALUES` enum('Selected'),
`PERCENTAGE` enum('Selected'),
`POWER` enum('Selected'),
`SQUARE_ROOT` enum('Selected'),
`CUBE_ROOT` enum('Selected') DEFAULT NULL,
`LOG` enum('Selected'),
`ANTILOG` enum('Selected'),
PRIMARY KEY (`SNO`),

107
 CONSTRAINT `calculator_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`the_computer_science_grade_11_gpt` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

7)Table: character_right_aligned_triangle_pattern
CREATE TABLE `character_right_aligned_triangle_pattern` (
`SNO` int NOT NULL,
`RT_INCREASE_RHS` enum('Selected'),
`RT_DECREASE_RHS` enum('Selected'),
`RT_INCREASE_lHS` enum('Selected'),
`RT_DECREASE_LHS` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `character_right_aligned_triangle_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `right_aligned_triagle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

8)Table: character_square_pattern
CREATE TABLE `character_square_pattern` (
`SNO` int NOT NULL,
`CS_CHARACTER` varchar(100),
`CS_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `character_square_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`square_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

9)Table: charater_diamond_pattern
CREATE TABLE `charater_diamond_pattern` (
`SNO` int NOT NULL,
`CD_CHARACTER` varchar(100),
`CD_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `charater_diamond_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`diamond_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

10)Table: charater_trangle_pattern
CREATE TABLE `charater_trangle_pattern` (
`SNO` int NOT NULL,
`CT_NORMAL` enum('Selected'),
`CT_UPSIDEDOWN` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `charater_trangle_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`triangle_pattern` (`SNO`)

108
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

11)Table: circle
CREATE TABLE `circle` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `circle_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

12)Table: class_10_percentage_calculator
CREATE TABLE `class_10_percentage_calculator` (
`SNO` int NOT NULL,
`TOTAL_MARK` float(20,15),
`PERENTAGE` float(20,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `class_10_percentage_calculator_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

13)Table: cnt_normal
CREATE TABLE `cnt_normal` (
`SNO` int NOT NULL,
`CNTN_NUMBER` int,
`CNTN_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `cnt_normal_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`constant_number_trangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

14)Table: cnt_upsidedown
CREATE TABLE `cnt_upsidedown` (
`SNO` int NOT NULL,
`CNTU_NUMBER` int,
`CNTU_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `cnt_upsidedown_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`constant_number_trangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

15)Table: constant_number_diamond_pattern
CREATE TABLE `constant_number_diamond_pattern` (

109
 `SNO` int NOT NULL,
`CND_NUMBER` int,
`CND_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `constant_number_diamond_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `diamond_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

16)Table: constant_number_right_aligned_triangle_pattern
CREATE TABLE `constant_number_right_aligned_triangle_pattern` (
`SNO` int NOT NULL,
`CTNRT_INCREASE_RHS` enum('Selected'),
`CTNRT_DECREASE_RHS` enum('Selected'),
`CTNRT_INCREASE_LHS` enum('Selected'),
`CTNRT_DECREASE_LHS` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `constant_number_right_aligned_triangle_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `right_aligned_triagle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

17)Table: constant_number_square_pattern
CREATE TABLE `constant_number_square_pattern` (
`SNO` int NOT NULL,
`CNS_NUMBER` int,
`CNS_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `constant_number_square_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `square_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

18)Table: constant_number_trangle_pattern
CREATE TABLE `constant_number_trangle_pattern` (
`SNO` int NOT NULL,
`CNT_NORMAL` enum('Selected') DEFAULT NULL,
`CNT_UPSIDEDOWN` enum('Selected') DEFAULT NULL,
PRIMARY KEY (`SNO`),
CONSTRAINT `constant_number_trangle_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

19)Table: cos
CREATE TABLE `cos` (
`SNO` int NOT NULL,
`dEGREE` float(200,15),
`ANSWER` float(200,15),

110
 PRIMARY KEY (`SNO`),
CONSTRAINT `cos_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `trigonometric_values`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

20)Table: cos_inverse
CREATE TABLE `cos_inverse` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `cos_inverse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

21)Table: cosec
CREATE TABLE `cosec` (
`SNO` int NOT NULL,
`dEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `cosec_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `trigonometric_values`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

22)Table: cosec_inverse
CREATE TABLE `cosec_inverse` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `cosec_inverse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

23)Table: cot
CREATE TABLE `cot` (
`SNO` int NOT NULL,
`dEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `cot_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `trigonometric_values`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

111
24)Table: cot_inverse
CREATE TABLE `cot_inverse` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `cot_inverse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

25)Table: csa_cone
CREATE TABLE `csa_cone` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_cone_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `curved_surface_area`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

26)Table: csa_cube
CREATE TABLE `csa_cube` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_cube_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `curved_surface_area`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

27)Table: csa_cuboid
CREATE TABLE `csa_cuboid` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`BREADTH` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_cuboid_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`curved_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

28)Table: csa_cylinder
CREATE TABLE `csa_cylinder` (

112
 `SNO` int NOT NULL,
`RADIUS` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_cylinder_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`curved_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

29)Table: csa_hemisphere
CREATE TABLE `csa_hemisphere` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_hemisphere_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`curved_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

30)Table: csa_pyramid
CREATE TABLE `csa_pyramid` (
`SNO` int NOT NULL,
`BASE_PERIMETER` float(200,15),
`SLANT_HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_pyramid_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`curved_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

31)Table: csa_sphere
CREATE TABLE `csa_sphere` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `csa_sphere_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`curved_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

32)Table: ct_normal
CREATE TABLE `ct_normal` (
`SNO` int NOT NULL,
`CTN_CHARACTER` varchar(100),
`CTN_NUMBER_OF_LINES` int,

113
 PRIMARY KEY (`SNO`),
CONSTRAINT `ct_normal_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`charater_trangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

33)Table: ct_upsidedown
CREATE TABLE `ct_upsidedown` (
`SNO` int NOT NULL,
`CTU_CHARACTER` varchar(100),
`CTU_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `ct_upsidedown_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`charater_trangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

34)Table: ctnrt_decrease_lhs
CREATE TABLE `ctnrt_decrease_lhs` (
`SNO` int NOT NULL,
`CTNRTDL_CHARACTER` varchar(10),
`CTNRTDL_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `ctnrt_decrease_lhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`constant_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

35)Table: ctnrt_decrease_rhs
CREATE TABLE `ctnrt_decrease_rhs` (
`SNO` int NOT NULL,
`CTNRTDR_CHARACTER` varchar(10),
`CTNRTDR_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `ctnrt_decrease_rhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`constant_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

36)Table: ctnrt_increase_lhs
CREATE TABLE `ctnrt_increase_lhs` (
`SNO` int NOT NULL,
`CTNRTIL_CHARACTER` varchar(10),
`CTNRTIL_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `ctnrt_increase_lhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`constant_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

114
37)Table: ctnrt_increase_rhs
CREATE TABLE `ctnrt_increase_rhs` (
`SNO` int NOT NULL,
`CTNRTIR_CHARACTER` varchar(10),
`CTNRTIR_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `ctnrt_increase_rhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`constant_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

38)Table: cube_root
CREATE TABLE `cube_root` (
`SNO` int NOT NULL,
`NUMBER` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `cube_root_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

39)Table: curved_surface_area
CREATE TABLE `curved_surface_area` (
`SNO` int NOT NULL,
`CSA_CUBE` enum('Selected'),
`CSA_CUBOID` enum('Selected'),
`CSA_CYLINDER` enum('Selected'),
`CSA_CONE` enum('Selected'),
`CSA_PYRAMID` enum('Selected'),
`CSA_SPHERE` enum('Selected'),
`CSA_HEMISPHERE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `curved_surface_area_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

40)Table: decagon
CREATE TABLE `decagon` (
`sno` int NOT NULL,
`LENGTH` float(200,15) DEFAULT NULL,
`ANSWER` float(200,15) DEFAULT NULL,
PRIMARY KEY (`sno`),
CONSTRAINT `decagon_ibfk_1` FOREIGN KEY (`sno`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

115
41)Table: diamond
CREATE TABLE `diamond` (
`SNO` int NOT NULL,
`DIAGONAL1` float(200,15),
`DIAGONAL2` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `diamond_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

42)Table: diamond_pattern
CREATE TABLE `diamond_pattern` (
`SNO` int NOT NULL,
`CHARATER_diamond_pattern` enum('Selected'),
`CONSTANT_number_diamond_pattern` enum('Selected'),
`INCREASING_number_diamond_pattern` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `diamond_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `pattern`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

43)Table: dice_game
CREATE TABLE `dice_game` (
`SNO` int NOT NULL,
`NUMBER_OF_CHANCES` int,
`ANSWER` enum('you won','you lose'),
PRIMARY KEY (`SNO`),
CONSTRAINT `dice_game_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

44)Table: division
CREATE TABLE `division` (
`SNO` int NOT NULL,
`NUMBER_OF_TERMS` int,
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `division_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `simple_calculation`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

45)Table: ellipse
CREATE TABLE `ellipse` (
`SNO` int NOT NULL,
`MAJOR_AXIS` float(200,15),

116
 `MINOR_AXIS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `ellipse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

46)Table: factorial
CREATE TABLE `factorial` (
`SNO` int NOT NULL,
`VALUE` int,
`ANSWER` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `factorial_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

47)Table: finding_armstrong_numbers_in_a_particlar_range
CREATE TABLE `finding_armstrong_numbers_in_a_particlar_range` (
`SNO` int NOT NULL,
`P_RANGE` varchar(100),
`ANSWER` varchar(100) DEFAULT NULL,
PRIMARY KEY (`SNO`),
CONSTRAINT `finding_armstrong_numbers_in_a_particlar_range_ibfk_1` FOREIGN KEY
(`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

48)Table: finding_neon_numbers_in_a_particlar_range
CREATE TABLE `finding_neon_numbers_in_a_particlar_range` (
`SNO` int NOT NULL,
`P_RANGE` varchar(100),
`ANSWER` varchar(100) DEFAULT NULL,
PRIMARY KEY (`SNO`),
CONSTRAINT `finding_neon_numbers_in_a_particlar_range_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

49)Table: finding_perfect_numbers_in_a_particlar_range
CREATE TABLE `finding_perfect_numbers_in_a_particlar_range` (
`SNO` int NOT NULL,
`P_RANGE` varchar(100),
`ANSWER` varchar(100) DEFAULT NULL,
PRIMARY KEY (`SNO`),
CONSTRAINT `finding_perfect_numbers_in_a_particlar_range_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `calculator` (`SNO`)

117
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

50)Table: finding_prime_number
CREATE TABLE `finding_prime_number` (
`SNO` int NOT NULL,
`NUMBER` int,
`ANSWER` enum('It is a prime number','It is not a prime number'),
PRIMARY KEY (`SNO`),
CONSTRAINT `finding_prime_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

51)Table: greatest_number
CREATE TABLE `greatest_number` (
`SNO` int NOT NULL,
`VALUE` varchar(100) DEFAULT NULL,
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `greatest_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

52)Table: heptagon
CREATE TABLE `heptagon` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `heptagon_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

53)Table: hexagon
CREATE TABLE `hexagon` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hexagon_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

54)Table: hyperbolic_cos
CREATE TABLE `hyperbolic_cos` (

118
 `SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_cos_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

55)Table: hyperbolic_cosec
CREATE TABLE `hyperbolic_cosec` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_cosec_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

56)Table: hyperbolic_cot
CREATE TABLE `hyperbolic_cot` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_cot_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

57)Table: hyperbolic_sec
CREATE TABLE `hyperbolic_sec` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_sec_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

58)Table: hyperbolic_sin
CREATE TABLE `hyperbolic_sin` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_sin_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES

119
`hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

59)Table: hyperbolic_tan
CREATE TABLE `hyperbolic_tan` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_tan_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

60)Table: hyperbolic_trigonometric_values
CREATE TABLE `hyperbolic_trigonometric_values` (
`SNO` int NOT NULL,
`HYPERBOLIC_SIN` enum('Selected'),
`HYPERBOLIC_COS` enum('Selected'),
`HYPERBOLIC_TAN` enum('Selected'),
`HYPERBOLIC_COSEC` enum('Selected'),
`HYPERBOLIC_SEC` enum('Selected'),
`HYPERBOLIC_COT` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `hyperbolic_trigonometric_values_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

61)Table: increasing_number_diamond_pattern
CREATE TABLE `increasing_number_diamond_pattern` (
`SNO` int NOT NULL,
`IND_NUMBER` int,
`IND_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `increasing_number_diamond_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `diamond_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

62)Table: increasing_number_right_aligned_triangle_pattern
CREATE TABLE `increasing_number_right_aligned_triangle_pattern` (
`SNO` int NOT NULL,
`INRT_INCREASE_RHS` enum('Selected'),
`INRT_DECREASE_RHS` enum('Selected'),
`INRT_INCREASE_LHS` enum('Selected'),
`INRT_DECREASE_LHS` enum('Selected'),
PRIMARY KEY (`SNO`),

120
 CONSTRAINT `increasing_number_right_aligned_triangle_pattern_ibfk_1` FOREIGN KEY
(`SNO`) REFERENCES `right_aligned_triagle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

63)Table: increasing_number_square_pattern
CREATE TABLE `increasing_number_square_pattern` (
`SNO` int NOT NULL,
`INS_NUMBER` int,
`INS_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `increasing_number_square_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `square_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

64)Table: increasing_number_trangle_pattern
CREATE TABLE `increasing_number_trangle_pattern` (
`SNO` int NOT NULL,
`INT_NORMAL` enum('Selected') DEFAULT NULL,
`INT_UPSIDEDOWN` enum('Selected') DEFAULT NULL,
PRIMARY KEY (`SNO`),
CONSTRAINT `increasing_number_trangle_pattern_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

65)Table: inrt_decrease_lhs
CREATE TABLE `inrt_decrease_lhs` (
`SNO` int NOT NULL,
`INRTDL_VALUE` int,
`INRTDL_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `inrt_decrease_lhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`increasing_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

66)Table: inrt_decrease_rhs
CREATE TABLE `inrt_decrease_rhs` (
`SNO` int NOT NULL,
`INRTDR_VALUE` int,
`INRTDR_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `inrt_decrease_rhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`increasing_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

121
67)Table: inrt_increase_lhs
CREATE TABLE `inrt_increase_lhs` (
`SNO` int NOT NULL,
`INRTIL_VALUE` int,
`INRTIL_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `inrt_increase_lhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`increasing_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

68)Table: inrt_increase_rhs
CREATE TABLE `inrt_increase_rhs` (
`SNO` int NOT NULL,
`INRTIR_VALUE` int,
`INRTIR_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `inrt_increase_rhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`increasing_number_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

69)Table: int_normal
CREATE TABLE `int_normal` (
`SNO` int NOT NULL,
`INTN_NUMBER` int,
`INTN_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `int_normal_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`increasing_number_trangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

70)Table: int_upsidedown
CREATE TABLE `int_upsidedown` (
`SNO` int NOT NULL,
`INTU_NUMBER` int,
`INTU_NUMBER_OF_LINES` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `int_upsidedown_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`increasing_number_trangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

71)Table: inverse_hyperbolic_cos
CREATE TABLE `inverse_hyperbolic_cos` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),

122
 PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_cos_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

72)Table: inverse_hyperbolic_cosec
CREATE TABLE `inverse_hyperbolic_cosec` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_cosec_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

73)Table: inverse_hyperbolic_cot
CREATE TABLE `inverse_hyperbolic_cot` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_cot_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

74)Table: inverse_hyperbolic_sec
CREATE TABLE `inverse_hyperbolic_sec` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_sec_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

75)Table: inverse_hyperbolic_sin
CREATE TABLE `inverse_hyperbolic_sin` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_sin_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

123
76)Table: inverse_hyperbolic_tan
CREATE TABLE `inverse_hyperbolic_tan` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_tan_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_hyperbolic_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

77)Table: inverse_hyperbolic_trigonometric_values
CREATE TABLE `inverse_hyperbolic_trigonometric_values` (
`SNO` int NOT NULL,
`INVERSE_HYPERBOLIC_SIN` enum('Selected'),
`INVERSE_HYPERBOLIC_COS` enum('Selected'),
`INVERSE_HYPERBOLIC_TAN` enum('Selected'),
`INVERSE_HYPERBOLIC_COSEC` enum('Selected'),
`INVERSE_HYPERBOLIC_SEC` enum('Selected'),
`INVERSE_HYPERBOLIC_COT` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_hyperbolic_trigonometric_values_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

78)Table: inverse_trigonometric_values
CREATE TABLE `inverse_trigonometric_values` (
`SNO` int NOT NULL,
`SIN_INVERSE` enum('Selected'),
`COS_INVERSE` enum('Selected'),
`TAN_INVERSE` enum('Selected'),
`COSEC_INVERSE` enum('Selected'),
`SEC_INVERSE` enum('Selected'),
`COT_INVERSE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `inverse_trigonometric_values_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

79)Table: kite
CREATE TABLE `kite` (
`SNO` int NOT NULL,
`DIAGONAL1` float(200,15),
`DIAGONAL2` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),

124
 CONSTRAINT `kite_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

80)Table: log
CREATE TABLE `log` (
`SNO` int NOT NULL,
`VALUE` float(200,15),
`BASE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `log_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

81)Table: multiplication
CREATE TABLE `multiplication` (
`SNO` int NOT NULL,
`NUMBER_OF_TERMS` int,
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `multiplication_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`simple_calculation` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

82)Table: neon_number
CREATE TABLE `neon_number` (
`SNO` int NOT NULL,
`VERIFING_A_NEON_NUMBER` enum('Selected'),
`FINDING_NEON_NUMBERS_IN_A_PARTICLAR_RANGE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `neon_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

83)Table: nonagon
CREATE TABLE `nonagon` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `nonagon_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

125
84)Table: octagon
CREATE TABLE `octagon` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `octagon_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

85)Table: odd_or_even
CREATE TABLE `odd_or_even` (
`SNO` int NOT NULL,
`VALUE` int,
`ANSWER` enum('Even numnber','Odd number'),
PRIMARY KEY (`SNO`),
CONSTRAINT `odd_or_even_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

86)Table: oval
CREATE TABLE `oval` (
`SNO` int NOT NULL,
`MAJOR_AXIS` float(200,15),
`MINOR_AXIS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `oval_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

87)Table: palindrome
CREATE TABLE `palindrome` (
`SNO` int NOT NULL,
`VALUE` char(200),
`ANSWER` enum('It is a Palindrome','It is not a Palindrome'),
PRIMARY KEY (`SNO`),
CONSTRAINT `palindrome_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

88)Table: parallelogram
CREATE TABLE `parallelogram` (
`SNO` int NOT NULL,
`BASE` float(200,15),
`HIGHT` float(200,15),

126
 `ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `parallelogram_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_of_2d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

89)Table: pattern
CREATE TABLE `pattern` (
`SNO` int NOT NULL,
`RIGHT_ALIGNED_TRIAGLE_PATTERN` enum('Selected'),
`TRIANGLE_PATTERN` enum('Selected'),
`DIAMOND_PATTERN` enum('Selected'),
`SQUARE_PATTERN` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

90)Table: pentagon
CREATE TABLE `pentagon` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `pentagon_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

91)Table: percentage
CREATE TABLE `percentage` (
`SNO` int NOT NULL,
`VALUE` float(200,15),
`MAX_VALUE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `percentage_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

92)Table: perfect_number
CREATE TABLE `perfect_number` (
`SNO` int NOT NULL,
`VERIFING_A_PERFECT_NUMBER` enum('Selected'),
`FINDING_PERFECT_NUMBERS_IN_A_PARTICLAR_RANGE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `perfect_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)

127
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

93)Table: polygon
CREATE TABLE `polygon` (
`SNO` int NOT NULL,
`LENGTH_OF_APOTHEM` float(200,15),
`PERIMETER` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `polygon_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

94)Table: power
CREATE TABLE `power` (
`SNO` int NOT NULL,
`NUMBER` float(200,15),
`POWER` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `power_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

95)Table: prime_number
CREATE TABLE `prime_number` (
`SNO` int NOT NULL,
`Finding_prime_number` enum('Selected'),
`Prime_numbers_in_a_particular_range` enum('Selected'),
`Sum_of_prime_numbers_in_a_particular_range` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `prime_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

96)Table: prime_numbers_in_a_particular_range
CREATE TABLE `prime_numbers_in_a_particular_range` (
`SNO` int NOT NULL,
`P_RANGE` varchar(100),
`ANSWER` varchar(100) DEFAULT NULL,
PRIMARY KEY (`SNO`),
CONSTRAINT `prime_numbers_in_a_particular_range_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

128
97)Table: rectangle
CREATE TABLE `rectangle` (
`SNO` int NOT NULL,
`LENGHT` float(200,15),
`BREADTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `rectangle_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

98)Table: rhombus
CREATE TABLE `rhombus` (
`SNO` int NOT NULL,
`DIAGONAL1` float(200,15),
`DIAGONAL2` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `rhombus_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

99)Table: right_aligned_triagle_pattern
CREATE TABLE `right_aligned_triagle_pattern` (
`SNO` int NOT NULL,
`CHARACTER_right_aligned_triangle_pattern` enum('Selected'),
`CONSTANT_number_right_aligned_triangle_pattern` enum('Selected'),
`INCREASING_number_right_aligned_triangle_pattern` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `right_aligned_triagle_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

100)Table: rt_decrease_lhs
CREATE TABLE `rt_decrease_lhs` (
`SNO` int NOT NULL,
`RTDL_CHARACTER` varchar(10),
`RTDL_NUMBER_OF_LINESS` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `rt_decrease_lhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`character_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

101)Table: rt_decrease_rhs
CREATE TABLE `rt_decrease_rhs` (

129
 `SNO` int NOT NULL,
`RTDR_CHARACTER` varchar(10),
`RTDR_NUMBER_OF_LINESS` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `rt_decrease_rhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`character_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

102)Table: rt_increase_lhs
CREATE TABLE `rt_increase_lhs` (
`SNO` int NOT NULL,
`RTIL_CHARACTER` varchar(10),
`RTIL_NUMBER_OF_LINESS` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `rt_increase_lhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`character_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

103)Table: rt_increase_rhs
CREATE TABLE `rt_increase_rhs` (
`SNO` int NOT NULL,
`RTIR_CHARACTER` varchar(10),
`RTIR_NUMBER_OF_LINESS` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `rt_increase_rhs_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`character_right_aligned_triangle_pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

104)Table: sec
CREATE TABLE `sec` (
`SNO` int NOT NULL,
`dEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `sec_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `trigonometric_values`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

105)Table: sec_inverse
CREATE TABLE `sec_inverse` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `sec_inverse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES

130
`inverse_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

106)Table: semi_circle
CREATE TABLE `semi_circle` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `semi_circle_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_of_2d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

107)Table: simple_calculation
CREATE TABLE `simple_calculation` (
`SNO` int NOT NULL,
`ADDITION` enum('Selected'),
`SUBTRACTION` enum('Selected'),
`MULTIPLICATION` enum('Selected'),
`DIVISION` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `simple_calculation_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

108)Table: sin
CREATE TABLE `sin` (
`SNO` int NOT NULL,
`dEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `sin_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `trigonometric_values`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

109)Table: sin_inverse
CREATE TABLE `sin_inverse` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `sin_inverse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

131
110)Table: square
CREATE TABLE `square` (
`SNO` int NOT NULL,
`SIDE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `square_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

111)Table: square_pattern
CREATE TABLE `square_pattern` (
`SNO` int NOT NULL,
`Character_square_pattern` enum('Selected'),
`CONSTANT_NUMBER_square_pattern` enum('Selected'),
`INCREASING_NUMBER_square_pattern` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `square_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `pattern` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

112)Table: square_root
CREATE TABLE `square_root` (
`SNO` int NOT NULL,
`NUMBER` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `square_root_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

113)Table: subtraction
CREATE TABLE `subtraction` (
`SNO` int NOT NULL,
`NUMBER_OF_TERMS` int,
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `subtraction_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `simple_calculation`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

114)Table: sum_of_armstrong_numbers_in_a_particlar_range
CREATE TABLE `sum_of_armstrong_numbers_in_a_particlar_range` (
`SNO` int NOT NULL,
`P_RANGE` varchar(100),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),

132
 CONSTRAINT `sum_of_armstrong_numbers_in_a_particlar_range_ibfk_1` FOREIGN KEY
(`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

115)Table: sum_of_prime_numbers_in_a_particular_range
CREATE TABLE `sum_of_prime_numbers_in_a_particular_range` (
`SNO` int NOT NULL,
`P_RANGE` varchar(100),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `sum_of_prime_numbers_in_a_particular_range_ibfk_1` FOREIGN KEY (`SNO`)
REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

116)Table: tables
CREATE TABLE `tables` (
`SNO` int NOT NULL,
`VALUE` int,
PRIMARY KEY (`SNO`),
CONSTRAINT `tables_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

117)Table: tan
CREATE TABLE `tan` (
`SNO` int NOT NULL,
`dEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tan_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `trigonometric_values`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

118)Table: tan_inverse
CREATE TABLE `tan_inverse` (
`SNO` int NOT NULL,
`DEGREE` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tan_inverse_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`inverse_trigonometric_values` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

119)1Table: the_computer_science_grade_11_gpt
CREATE TABLE `the_computer_science_grade_11_gpt` (

133
 `SNO` int NOT NULL,
`CALCULATOR` enum('Selected'),
`PALINDROME_IDENTIFIER` enum('Selected'),
`GREATEST_NUMBER` enum('Selected'),
`VOTE_ELIGIBILITY` enum('Selected'),
`FACTORIAL` enum('Selected'),
`EVEN_OR_ODD` enum('Selected'),
`TABLES` enum('Selected'),
`PATTERN` enum('Selected'),
`DICE_GAME` enum('Selected'),
`CLASS_10_PERCENTAGE_CALCULATOR` enum('Selected'),
`PRIME_NUMBER` enum('Selected'),
`ARMSTRONG_NUMBER` enum('Selected'),
`NEON_NUMBER` enum('Selected'),
`PERFECT_NUMBER` enum('Selected'),
PRIMARY KEY (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

120)Table: total_surface_area
CREATE TABLE `total_surface_area` (
`SNO` int NOT NULL,
`TSA_CUBE` enum('Selected'),
`TSA_CUBOID` enum('Selected') DEFAULT NULL,
`TSA_CYLINDER` enum('Selected'),
`TSA_CONE` enum('Selected'),
`TSA_PYRAMID` enum('Selected'),
`TSA_SPHERE` enum('Selected'),
`TSA_HEMISPHERE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `total_surface_area_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

121)Table: trapezium
CREATE TABLE `trapezium` (
`SNO` int NOT NULL,
`BASE1` float(200,15),
`BASE2` float(200,15),
`HIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `trapezium_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

134
122)Table: triangle
CREATE TABLE `triangle` (
`SNO` int NOT NULL,
`BASE` float(200,15),
`HIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `triangle_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `area_of_2d_shapes`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

123)Table: triangle_pattern
CREATE TABLE `triangle_pattern` (
`SNO` int NOT NULL,
`CHARATER_trangle_pattern` enum('Selected'),
`CONSTANT_number_trangle_pattern` enum('Selected'),
`INCREASING_number_trangle_pattern` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `triangle_pattern_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `pattern`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

124)Table: trigonometric_values
CREATE TABLE `trigonometric_values` (
`SNO` int NOT NULL,
`SIN` enum('Selected'),
`COS` enum('Selected'),
`TAN` enum('Selected'),
`COSEC` enum('Selected'),
`SEC` enum('Selected'),
`COT` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `trigonometric_values_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

125)Table: tsa_cone
CREATE TABLE `tsa_cone` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_cone_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `total_surface_area`
(`SNO`)

135
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

126)Table: tsa_cube
CREATE TABLE `tsa_cube` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_cube_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `total_surface_area`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

127)Table: tsa_cuboid
CREATE TABLE `tsa_cuboid` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`BREADTH` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_cuboid_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `total_surface_area`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

128)Table: tsa_cylinder
CREATE TABLE `tsa_cylinder` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_cylinder_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `total_surface_area`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

129)Table: tsa_hemisphere
CREATE TABLE `tsa_hemisphere` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_hemisphere_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`total_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

136
130)Table: tsa_pyramid
CREATE TABLE `tsa_pyramid` (
`SNO` int NOT NULL,
`BASE_LENGTH` float(200,15),
`BASE_WIDTH` float(200,15),
`PYRAMID_HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_pyramid_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`total_surface_area` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

131)Table: tsa_sphere
CREATE TABLE `tsa_sphere` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `tsa_sphere_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `total_surface_area`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

132)Table: verifing_a_armstrong_number
CREATE TABLE `verifing_a_armstrong_number` (
`SNO` int NOT NULL,
`NUMBER` int,
`ANSWER` enum('It is a armstrong number','It is not a armstrong number'),
PRIMARY KEY (`SNO`),
CONSTRAINT `verifing_a_armstrong_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

133)Table: verifing_a_neon_number
CREATE TABLE `verifing_a_neon_number` (
`SNO` int NOT NULL,
`NUMBER` int,
`ANSWER` enum('It is a neon number','It is not a neon number'),
PRIMARY KEY (`SNO`),
CONSTRAINT `verifing_a_neon_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

134)Table: verifing_a_perfect_number
CREATE TABLE `verifing_a_perfect_number` (
`SNO` int NOT NULL,

137
 `NUMBER` int,
`ANSWER` enum('It is a perfect number','It is not a perfect number'),
PRIMARY KEY (`SNO`),
CONSTRAINT `verifing_a_perfect_number_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`calculator` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

135)Table: vol_hemisphere
CREATE TABLE `vol_hemisphere` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `vol_hemisphere_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

136)Table: volcone
CREATE TABLE `volcone` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `volcone_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

137)Table: volcube
CREATE TABLE `volcube` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `volcube_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

138)Table: volcuboid
CREATE TABLE `volcuboid` (
`SNO` int NOT NULL,
`LENGTH` float(200,15),
`BREADTH` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),

138
 PRIMARY KEY (`SNO`),
CONSTRAINT `volcuboid_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

139)able: volcylinder
CREATE TABLE `volcylinder` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `volcylinder_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

140)Table: volpyramid
CREATE TABLE `volpyramid` (
`SNO` int NOT NULL,
`BASE_LENGTH` float(200,15),
`BASE_WIDTH` float(200,15),
`PYRAMID_HEIGHT` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `volpyramid_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

141)Table: volsphere
CREATE TABLE `volsphere` (
`SNO` int NOT NULL,
`RADIUS` float(200,15),
`ANSWER` float(200,15),
PRIMARY KEY (`SNO`),
CONSTRAINT `volsphere_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

142)Table: volume
CREATE TABLE `volume` (
`SNO` int NOT NULL,
`VOLCUBE` enum('Selected'),
`VOLCUBOID` enum('Selected'),
`VOLCYLINDER` enum('Selected'),
`VOLCONE` enum('Selected'),

139
 `VOLPYRAMID` enum('Selected'),
`VOLSPHERE` enum('Selected'),
`VOL_HEMISPHERE` enum('Selected'),
PRIMARY KEY (`SNO`),
CONSTRAINT `volume_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES
`area_or_volume_of_3d_shapes` (`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

143)Table: vote_eligibility
CREATE TABLE `vote_eligibility` (
`SNO` int NOT NULL,
`AGE` int,
`ANSWER` enum('Eligibile','not Eligibile'),
PRIMARY KEY (`SNO`),
CONSTRAINT `vote_eligibility_ibfk_1` FOREIGN KEY (`SNO`) REFERENCES `calculator`
(`SNO`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

140
 CONCLUSION
In conclusion, this investigation project successfully integrates a
comprehensive range of Python programming concepts into a user-
friendly, menu-driven application designed for Class 11 CBSE
students. By covering fundamental topics such as basic syntax,
control structures, functions, data structures, file handling, and error
handling, the program provides a valuable resource for students to
enhance their understanding and practical skills in Python
programming.
The program's structured approach allows students to explore each
topic interactively, reinforcing their learning through practical
examples and exercises. The modular design ensures that the content
is both accessible and expandable, making it a flexible tool for
ongoing education. The inclusion of error handling and debugging
techniques further prepares students to write robust and efficient
code.
By providing a platform that not only demonstrates theoretical
concepts but also offers practical applications and interactive
challenges, this project aims to bridge the gap between learning and
real-world programming. The user-friendly interface and
comprehensive coverage of topics ensure that students can navigate
the content with ease and gain confidence in their programming
abilities.
Overall, this investigation project serves as an effective educational
tool that aligns with the CBSE curriculum while fostering a deeper
appreciation for Python programming. It stands as a testament to the
importance of practical, hands-on learning in mastering
programming skills. Future enhancements and updates to the
program will continue to support students' growth and adaptability in
the ever-evolving field of computer science.

141
 BIBLIOGRAPHY

• COMPUTER SCIENCE WITH PYTHON CLASS XI

by SUMITA ARORA

• COMPUTER SCIENCE WITH PYTHON CLASS XII

by SUMITA ARORA

• Chatgpt- https://chatgpt.com/

*****

142