‭ rogram Name - B.

Tech Computer Science‬

P
‭Engineering‬
‭Academic Year - 2024-2025‬
‭Admission Batch- 2024-25‬
‭Semester - I‬

‭ .‬
S ‭Course‬ ‭Course‬
‭No.‬ ‭Type‬ ‭Code‬ ‭Course Name‬ ‭L‬ ‭T‬ ‭p‬ ‭Credits‬
‭CSE-3-101-‬ ‭Fundamental of Computer‬
‭1‬ ‭DCC‬ ‭T‬ ‭System‬ ‭3‬ ‭0‬ ‭0‬ ‭3‬
‭CSE-3-102-‬
‭2‬ ‭DCC‬ ‭T‬ ‭Digital Logic Design‬ ‭2‬ ‭0‬ ‭0‬ ‭2‬
‭CSE-3-103-‬
‭3‬ ‭DCC‬ ‭T‬ ‭Computer Programming in C‬ ‭3‬ ‭0‬ ‭0‬ ‭3‬
‭CSE-3-104-‬ ‭Computer Programming in C‬
‭4‬ ‭DCC‬ ‭P‬ ‭(Lab)‬ ‭0‬ ‭0‬ ‭4‬ ‭2‬

‭Program Name - B. Tech Computer Science Engineering‬

‭Academic Year - 2024-2025‬
‭Admission Batch- 2024-25‬
‭Semester - II‬

‭Course‬ ‭Course‬
‭S. No.‬ ‭Type‬ ‭Code‬ ‭Course Name‬ ‭L‬ ‭T‬ ‭p‬ ‭Credits‬
‭CSE-3-201-‬
‭DCC‬
‭1‬ ‭T‬ ‭Data Structures and Algorithms‬ ‭3‬ ‭0‬ ‭0‬ ‭3‬
‭CSE-3-202-‬ ‭Data Structures and Algorithms‬
‭DCC‬
‭2‬ ‭P‬ ‭(Lab)‬ ‭0‬ ‭4‬ ‭0‬ ‭2‬
‭CSE-3-203-‬ ‭Computer Architecture and‬
‭DCC‬
‭3‬ ‭T‬ ‭Organization‬ ‭2‬ ‭0‬ ‭0‬ ‭2‬
‭CSE-3-204-‬
‭DCC‬
‭4‬ ‭T‬ ‭OOPs Using C++‬ ‭2‬ ‭0‬ ‭0‬ ‭2‬
‭CSE-3-205-‬
‭DCC‬
‭5‬ ‭P‬ ‭OOPs Using C++ (Lab)‬ ‭0‬ ‭2‬ ‭0‬ ‭1‬
 [Link]. in Computer Science Engineering
CREDIT SCHEME (AY 2024 – 2025 BATCH)

Semester I

S. Hours/week Total
Course Course Name
No. Course code T P S Credits
Type
1 CSE-3-101-T Fundamental of Computer System 3 0 0 3

2 CSE-3-102-T Digital Logic Design 2 0 0 2

DCC
3 CSE-3-103-T Computer Programming in C 3 0 0 3

CSE-3-104-P 0 4 0 2
Computer Programming in C Lab

4. AEC 2

5. MDC 4

OEC &
4
OTHERS

Total 20

Semester II

Course Hours/week Total

S. No. Course Code Course Name
Type T P S Credits

1 CSE-3-201-T Data Structures and Algorithms 3 0 0 3

CSE-3-202-P Data Structures and Algorithms Lab 0 4 0 2

2 DCC CSE-3-203-T Computer Architecture and Organization 2 0 0 2

3 CSE-3-204-T OOPs Using C++ 2 0 0 2

CSE-3-205-P OOPs Using C++ Lab 0 2 0 1

4 AEC 2

5 MDC 4

OEC &
6 4
OTHERS

Total 20
Course Title: Data Structure and Algorithm
Type of Course: DCC Level of Course: 4.5 Delivery Sub Type of the course: Theory
Course code: CSE-3-201-T No. of credits: 3 T-P-S: 3-0-0 Learning hours: 45
Pre-requisite and Co-requisite of Course: A basic understanding of C/C++ Programming language.
Department: Computer Science Engineering
Syllabus:
Course objectives:
● To provide the knowledge of basic data structures and their implementations.
● To understand the importance of data structures in the context of writing efficient programs.
● To develop skills to apply appropriate data structures in problem solving.
● To develop skills of analyzing the efficiency of algorithm.

Course content
Module Topic T P S
/ Unit
1 Introduction: Basic Terminology, Algorithm, Efficiency of an Algorithm, Time and 12
Space Complexity, Abstract Data Types (ADT)
Arrays: Definition, Single and Multidimensional Arrays, Representation of Arrays:
Row Major Order and Column Major Order, Address calculation, Application of arrays,
Sparse Matrices and their representations.
Linked lists: Singly Linked List, Doubly Linked List, Circular Linked List, Operations:
Insertion, Deletion, Traversal. Polynomial Representation and Addition, Generalized
Linked List.
2 Stacks: Abstract Data Type, Primitive Stack operations: Push & Pop, Array and 10
Linked Implementation of Stack in C, Applications of stack: Prefix and Postfix
Expressions, Evaluation of postfix expression, Recursion: Principles of recursion,
Tower of Hanoi Problem, Tail recursion, Removal of recursion.
Queue: Create, Add, Delete, Full and Empty, Circular queues, Array and linked
implementation of queues in C, Dequeue and Priority Queue.
3 Trees: Basic terminology, Binary Trees, Binary Tree Representation: Array 12
Representation and Dynamic Representation, Complete Binary Tree, Algebraic
Expressions, Extended Binary Trees Traversal algorithms: In order, Preorder and Post
order
Search Trees: Binary Search Trees (BST), Insertion and Deletion in BST, AVL trees.

4 Graphs: Basic terminology, Sequential and linked Representations of Graphs: 11

Adjacency Matrices, Adjacency List, Adjacency Multi list, Graph Traversal: Depth
First Search and Breadth First Search, Connected Components, Spanning tree.

Sorting concept, order, stability, Selection sorts (straight, heap), insertion sort (Straight
Insertion, Shell sort), Exchange Sort (Bubble, quicksort), Merge sort (only 2-way
merge sort).

Searching – List search, sequential search, binary search, hashing concepts, hashing
methods (Direct, subtraction, modulo-division, mid square, folding, pseudorandom
hashing), collision resolution (by open addressing: linear probe, quadratic probe,
pseudorandom collision resolution, linked list collision resolution), Bucket hashing.

Scheme of End Semester Examination Total: 100 marks

As per Regulation 2A
Recommended Books and References:
● E. Horowitz & Sahni,Fundamental Data Structure, Galgotia Book Source, 1983.
 ● Tannenbaum, Data Structure Using C, Pearson Education, 2003.
● Kruz, Data Structure and Programming Design, 1987.
● N. Wirth, Algorithms +Data Structure = Program, Prentice Hall of India, 1979.
● Goodrich & Tamassia, Data Structures and Algorithms in C++, 2nd Edition, John Wiley & Sons,
2011.
Learning outcomes: Upon Completing the Course, Students will able to:
● Implement abstract data types using arrays and linked list.
● Apply the different linear data structures like stack and queue to various computing problems.
● Apply graph and tree structure and understand various operations on graphs and trees and their
applicability.
● Analyze the various sorting and searching algorithms.
● Understand the hashing technique and hash functions
Hyperlinks of suggested e-resources on the web:
[Link]
[Link]
[Link]
[Link]

Pedagogical approach
-Powerpoint Presentation
-Group Discussion
-Assignment
-Quiz(Online and Offline)
Additional information (if any)
Course Title: Data Structures and Algorithms Lab
Type of Course: DCC Level of Course: 4.5 Delivery Sub Type of the course: Practical
Course code: CSE-3-202-P No. of credits: 2 T-P-S: 0-4-0 Learning hours: 60
Pre-requisite and Co-requisite of Course: Computer Programming Knowledge (C/C++)
Department: Computer Science Engineering
Syllabus:
Module 1: Introduction to Data Types and Arrays
Module 2: Efficiency of Algorithms - Time and Space Complexity
Module 3: Sorting Algorithms
Module 4: Linked Lists
Module 5: Stacks
Module 6: Queues
Module 7: Hash Tables
Module 8: Trees
Module 9: Graphs
Course objectives
● Understand and apply fundamental data structures and algorithms.
● Implement static and dynamic representations of data structures.
● Analyze the time and space complexity of algorithms.
● Develop proficiency in tree and graph algorithms for problem-solving.
● Use advanced data structures for specialized applications.
● Enhance problem-solving skills through efficient algorithm design.
Course content
Module Topic T P S
/ Unit
1 ● Write a program for basic array operations like insertion, deletion, updating, 2
traversal on Array.
● Write a program to create a 2D array using pointers and perform matrix
operations (addition, transpose).

2 ● Implement recursive vs. iterative solutions for problems like Fibonacci series, 4
factorial calculation, and analyze their time/space complexity.
● Write programs to compare linear vs. binary search and measure their time
complexity in terms of input size.
● For linear search, binary search, and bubble sort, write test cases that illustrate
best, worst, and average cases, and compare the results.

3 ● Write a program to implement insertion sort. 6

● Write a program to implement selection sort.
● Write a program to implement merge sort.
● Write a program to implement quick sort with randomized pivot selection.
● Write a program to implement heap sort.
● Write a program to implement radix and/or shell sort.

4 ● Write programs to create a singly linked list with nodes containing integer data, 8
with functions for insertions, deletions, updating, traversal.
● Write programs to create a doubly linked list with nodes containing integer data,
with functions for insertions, deletions, updating, traversal.
● Write a program to reverse a singly linked list using pointers.
● Write a program to merge two sorted linked lists into a single sorted linked list.
 5 ● Write a program to implement a stack using a static array and perform basic stack 8
operations like push, pop, etc.
● Write a program to implement a stack using a dynamic linked list and perform
basic stack operations like push, pop, etc.
● Write a program to evaluate an expression written in postfix notation (Reverse
Polish Notation, RPN) using a stack.
● Write a program to evaluate an expression written in prefix notation (Polish
Notation) using a stack.
● Write a program to convert an infix expression to postfix notation (e.g., A + B *
C to A B C * +).
● Write a program to convert an infix expression to prefix notation.
6 ● Write a program to implement a basic queue using an array, and perform basic 8
operations like enqueue, dequeue, etc.
● Write a program to implement a basic queue using a linked list, and perform
basic operations like enqueue, dequeue, etc.
● Write a program to implement a circular queue and perform basic operations like
enqueue, dequeue, etc.
● Write a program to simulate a simple task scheduler using a priority queue, where
each task has an ID and duration.
7 ● Write a program to implement a simple hash table using an array and hash 6
function to map keys to indices. Write functions to insert and search for elements
in the hash table using modulo-based hashing.
● Write a program to handle collisions in a hash table using linear probing.
● Write a program to use a hash table to count the frequency of each element in an
array of integers.
8 ● Write a program to create a binary tree and implement basic operations like, 10
insert, delete, search.
● Write a program to perform pre-order, in-order, and post-order traversal on a
binary tree and print the elements in each traversal order.
● Write a program to implement a binary search tree (BST) with functions for
insertion, deletion, and searching.
● Write a program to implement an AVL tree with functions to perform insertion,
deletion, and rotations (single and double rotations).
9 ● Write a program to represent a graph using an adjacency matrix or adjacency list. 8
● Write a program to implement breadth-first search (BFS) on a graph and print the
order of visited nodes.
● Write a program to implement depth-first search (DFS) on a graph and print the
order of visited nodes.
Scheme of End Semester Examination Total: 100 marks
As per Regulation 2A (30% CA + 70% EoSE)
Recommended Books and References:
● E. Horowitz & Sahni, Fundamental Data Structure, Galgotia Book Source, 1983.
● Tannenbaum, Data Structure Using C, Pearson Education, 2003.
● Kruz, Data Structure and Programming Design, 1987.
● N. Wirth, Algorithms +Data Structure = Program, Prentice Hall of India, 1979.
● Data Structures through C, Yashawant Kanetkar, BPB Publications, 4th Ed., 2022.
●
Learning outcomes: Upon Completing the Course, Students will able to:
● Demonstrate proficiency in implementing core data structures (e.g., linked lists, stacks, queues,
hash tables, trees, graphs) in C++/C.
● Apply appropriate algorithms for sorting, searching, and traversing data structures.
● Analyze and compare algorithm efficiency using time and space complexity.
● Utilize advanced data structures like heaps, AVL trees, and B+ trees in problem-solving.
● Implement graph algorithms (BFS, DFS, shortest path) for practical applications.
● Develop optimized solutions using best-case, worst-case, and average-case complexity analysis.
● Use the appropriate data structures in context of a solution to a given problem.
Hyperlinks of suggested e-Resources:
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]

Pedagogical approach
Practical Demonstration: Installation of IDE or use of online editors/compilers, writing, compiling, executing and
debugging a program.
Hands-on Practice: Emphasis on writing and executing programs during lab sessions.
Problem-Solving: Practicals designed to develop problem-solving skills.
Peer Learning: Encouraging collaboration and peer-to-peer learning for complex tasks.
Projects: A Small project to integrate and apply all concepts learned.
Additional information (if any)
Course Title: Computer Architecture and Organization
Type of Course: DCC Level of Course: 4.5 Delivery Sub Type of the course: Theory
Course Code: CSE-3-203-T No. of credits: 2 T-P-S: 2-0-0 Learning hours: 30
Pre-requisite and Co-requisite of Course: Basics of Digital Logic Design, Fundamentals of Computer Syste
Department: Computer Science Engineering
Syllabus:
Course objectives: This course will expose students to the basic architecture of processing unit, memory unit and
input/output organization in a computer system.
Course content
Module Topic T P S
/Unit
1 Basic functional blocks of a computer: CPU, memory, input-output subsystems, control 4
unit. Bus organization and design. Instruction set architecture of a CPU - registers,
instruction execution cycle. Addressing Modes.
2 Data representation: Unsigned and signed number representation, fixed and floating point 8
representations, character representation. Computer arithmetic: shift-and-add, Booth
multiplier, carry save multiplier, Division floating point arithmetic.

3 CPU control unit design: hardwired and micro-programmed design approaches. 8

Introduction to RISC and CISC processors.
Performance enhancement techniques: Basic concepts of pipelining, throughput and
speedup, pipeline hazards.

4 Memory system design: Memory organization, semiconductor memory technologies, 6

cache memory, associative memory, cache size vs block size, mapping functions,
replacement algorithms, write policy, Virtual memory.
5 Peripheral devices and their characteristics: Input-output subsystems, I/O transfers - 4
program controlled, interrupt driven and DMA.

Scheme of End Semester Examination Total: 100 marks

As per regulation 2A
Recommended Books and References:
Textbooks:
1: M. Moris Mano (2006), Computer System Architecture, 3rd edition, Pearson/PHI, India.
2: Carl Hamacher, Zvonks Vranesic, SafeaZaky (2002), Computer Organization, 5th edition, McGraw Hill,
New Delhi, India

Reference Books:
RB1: William Stallings (2010), Computer Organization and Architecture- designing for
performance, 8th edition, Prentice Hall, New Jersy.
RB2: Anrew S. Tanenbaum (2006), Structured Computer Organization, 5th edition, Pearson Education Inc,
RB3: John P. Hayes (1998), Computer Architecture and Organization, 3rd edition, Tata McGrawHill
RB4: David A Patterson, John L. Hennessy (2017), Computer Architecture: A Quantitative Approach , 6th
Edition, Morgan Kaufmann
Learning outcomes
● Basic operations internally going on inside the computer system.
● Input, Output and memory transactions.
● Basic knowledge about microprocessor functioning
Hyperlinks of suggested e-Resources:
1. Basic Computer Architecture
2. Computer Organization and Architecture Tutorial - GeeksforGeeks
Pedagogical approach :
● Lecture-based teaching for theoretical concepts.
● Problem-solving sessions to apply algorithms.
● Use of visualization tools like VisuAlgo.
● Hands-on coding assignments.
● Flipped classroom for discussions and exercises.
● Group activities for collaborative learning.
● Gamification through competitive coding challenges.
● Case studies on real-world algorithm applications.
Additional information (if any)
Course Title: Object-Oriented Programming (OOPs) using C++
Type of Course: DCC Level of Course: 4.5 Delivery Sub Type of the course: Theory
Course Code: CSE-3-204-T No. of credits: 2 T-P-S: 2-0-0 Learning hours: 30
Pre-requisites of Course:
1. Fundamental knowledge of programming concepts and logic building.
2. Basic understanding of data types, control structures, and algorithms.
3. Familiarity with at least one programming language (e.g., C or Python).
Co-requisites of Course:
4. Concurrent enrollment in a course on Data Structures (if applicable).
5. Exposure to basic concepts of software development and debugging tools.
Department: Computer Science Engineering
Syllabus:
Course objectives
1. To impart a clear understanding of object-oriented and procedural programming concepts.
2. To develop the ability to differentiate between functions, classes, and objects.
3. To foster proficiency in function and operator overloading techniques.
4. To equip students with skills for designing applications using dynamic memory management.
5. To introduce and enhance competence in generic programming and exception handling for robust
software development.
Course content
Module Topic T P S
/Unit
1 Introduction to Object Oriented Programming Paradigm: 6
Principles of Object-Oriented Programming (OOP), Software
Evaluation, A Look at Procedure Oriented Programming, OOP
Paradigm, Basic Concepts of OOP, Benefits of OPP, Application of
OOP. Introduction to C++ Program structure: A simple C++ Program,
More C++ statements, Structure of C++ Program. Tokens, Expression
and controls Structures, Tokens, Keywords, Identifiers and Constants,
C++ data types, Variables: Declaration, Dynamic initialization of
variables, Reference variables, Operators in C++: Scope resolution
operator, Member deferencing Operators, Memory Management
Operators, Manipulators, Type cast operators, Expressions and
Control Structures.
Introduction: Difference between Structure and Class. Basic Variables
and data types, Operators and Control Structure, Arrays and Pointers.
Function declaration and definition, function prototype, Difference
between OOP and POP. Dynamic Memory Allocation( new and
delete).
2 Class and Objects: 6
Introduction The main () function, Function Prototyping, Call by
reference, Return by reference, specifying a Class, defining member
Functions, C++ Program with Class.
Encapsulation, Nesting of Member functions, Private member
functions, Memory Allocation for Objects, Static Data members,
Static Member Functions, Arrays within a Class, Arrays of Objects,
Objects as Function Arguments, Friendly Functions, Returning
Objects. Constructors, Parameterized Constructors, Multiple
Constructors in a class, Copy constructor, Destructors, Inline function.
3 Object Oriented Programming: Inheritance 4
Introduction, Base and Derived Classes, protected members,
Relationship between Base and Derived Classes, Types of inheritance,
Constructors and Destructors in Derived classes, public, private and
protected inheritance
4 Object Oriented Programming: Polymorphism 6
Introduction, Operator Overloading, Function Overloading, Static
Binding, Dynamic Binding, Invoking Base-Class Function from
 Derived-Class, Aiming Derived Class Pointers at Base Class Pointers,
Derived Class Member-Function calls via Base-Class Pointers, Virtual
Functions, Abstract Class and Pure Virtual Functions, Virtual
Destructors.
5 Templates & Exception Handling 5
Introduction, Function Templates, Overloading Function Templates,
Class Templates, Nontype Parameters and Default Types for Class
Templates.
Exception Handling overview, Example Handling an Attempt to
Divide by Zero, Rethrowing Exception, Exception Specification,
Processing Unexpected Exceptions, Stacking unwinding, Contractors
and Destructors with Exception Handling, Exception and Inheritance.
6 Files and Stream 3
C++ Stream Classes, Unformatted I/O Operations, Formatted I/O
operations, Data Hierarchy, Files and Stream, Operations like creating,
reading from a file and writing on Sequential File and Random Files.
Scheme of End Semester Examination Total: 100 marks
As per Regulation 2A (End Term Examination 70 Continuous Evaluation : 30)
Recommended Books and References:
1. "Object-Oriented Programming with C++" by E. Balagurusamy, Tata McGraw-Hill (TMH).
2. "Object-Oriented Programming in Microsoft C++" by Robert Lafore, Galgotia Publications.
3. "The C++ Programming Language" by Bjarne Stroustrup, 4th Edition, Addison-Wesley
4. "C++ How to Program" by Paul Deitel and Harvey Deitel, 10th Edition, Pearson,
5. "Thinking in C++" by Bruce Eckel, 2nd Edition, Pearson Education,
6. "Programming: Principles and Practice Using C++" by Bjarne Stroustrup, 2nd Edition, Addison-Wesley.
7. "Effective C++: 55 Specific Ways to Improve Your Programs and Designs" by Scott Meyers, 3rd Edition,
Addison-Wesley.
Learning outcomes:
By the end of this course, students will be able to:
1. Understand and apply the principles of object-oriented and procedural programming to solve real-world
problems.
2. Differentiate between and effectively use functions, classes, and objects in programming.
3. Demonstrate proficiency in function overloading and operator overloading to enhance program
functionality.
4. Design and implement efficient applications using dynamic memory management techniques.
5. Develop robust programs by incorporating generic programming and handling exceptions effectively.
6. Create modular, reusable, and maintainable code using object-oriented programming concepts.
Hyperlinks of suggested e-Resources:
1. NPTEL Course on Object-Oriented Programming [Link]
2. SWAYAM Course on Programming in C++
[Link]
3. Official C++ Documentation
[Link]
4. The Standard Template Library (STL) Guide
[Link]
5. TutorialsPoint: C++ Programming Tutorial
[Link]
6. Microsoft Learn: Object-Oriented Programming in C++
[Link]
7. EdX Course: Introduction to C++
[Link]
8. Coursera: Object-Oriented Programming in C++ Specialization
[Link]
Pedagogical approach:
● Lecture-based Teaching: Deliver theoretical content through structured lectures, introducing fundamental
concepts and building a strong knowledge base.
● Problem-solving Sessions: Facilitate active learning by engaging students in hands-on exercises, applying
algorithms to solve practical problems and reinforcing key concepts.
● Hands-on Coding Assignments: Provide coding assignments that challenge students to implement algorithms,
encouraging experimentation and refining their coding skills.
● Flipped Classroom: Encourage self-learning by having students review course material independently before
class. Classroom time is dedicated to collaborative discussions, exercises, and application of concepts.
● Group Activities: Foster collaborative learning through group projects and discussions, allowing students to
tackle complex problems together and share insights.
● Gamification: Incorporate competitive coding challenges, hackathons, and gamified tasks to make learning
more engaging and motivate students to enhance their problem-solving abilities.
● Case Studies: Use real-world case studies to demonstrate how algorithms are applied in various industries,
helping students understand the practical relevance of theoretical concepts.

Additional information (if any)

● Students will be encouraged to participate in online coding platforms such as LeetCode, HackerRank, and
Codeforces to develop their problem-solving skills and participate in competitive coding.
● Continuous Assessment: Assess student progress through regular quizzes, assignments, and peer evaluations
to promote consistent learning and active participation.
● Access to virtual coding environments and debugging tools to support real-time coding practice.
● Mentorship and Support: Offer weekly office hours to provide individualized guidance, resolve doubts, and
foster deeper understanding.

Project for Home Use:

Capstone Project: Assign a practical project that allows students to design and implement a real-world
application using the concepts learned in the course. The project could involve building a personalized to-do
list application with dynamic memory management or a simple budgeting tool using object-oriented
principles.
Continuous Evaluation: The final project will be a key component of continuous evaluation. Students will be
assessed based on their project development progress throughout the course.
Course Title: Object Oriented Programming (OOPs) using C++ Lab
Type of Course: DCC Level of Course: 4.5 Delivery Sub Type of the course: Practical
Course Code: CSE-3-205-P No. of credits: 1 T-P-S: 0-2-0 Learning hours: 30
Pre-requisite and Co-requisite of Course: Basics of Computer Programming
Department: Computer Science Engineering
Syllabus:
Course objectives
1. Design and implementation of C++ Applications.
2. Applications of object-oriented programming principles.
Course content
Module Topic T P S
/Unit
1 Installation and setting up the development environment. 2
2 WAP on Dynamic Memory Allocation (new and delete keywords). 2
3 Design a class to represent a Student with attributes like name, roll number, and 2
marks. Implement member functions to set and get these attributes.
4 Design a BankAccount class with attributes like account number, balance, and 2
interest rate. Implement methods for deposit, withdrawal, and calculating interest.
5 Create a base class Shape with attributes like color and area. Derive classes Circle, 2
Rectangle, and Triangle from the Shape class, each with its specific attributes and
methods to calculate area and perimeter.
6 Overload the + and - operators for a class representing complex numbers. 4
7 Write constructor and destructor for program no 4. 4
8 Modify Program No. 5 to include the creation of virtual functions 2
calculateArea() and calculatePerimeter() in a base class Shape.
9 Write a program to demonstrate exception handling using try-catch blocks. 2
10 Create a program to read and write data to a file using C++ file streams. 2
Project To design and implement a console-based quiz system using C++ that 6
incorporates multiple-choice questions, score calculation, and a leaderboard. The
project must utilize Object-Oriented Programming (OOP) concepts, including file
handling and exception handling.
Scheme of End Semester Examination Total: 100 marks
As per Regulation 2A
Recommended Books and References:
1. Programming with C++ (Schaum S Outline Series) by John R. Hubbard.
2. Object Oriented Programming with C++ by E Balagurusamy, McGraw Hill Education.
3. Object-Oriented Programming in Microsoft C++ by Robert Lafore, Waite group
Learning outcomes
Enhancement of Programming Skills.
● Understanding Object Oriented Programming.
Hyperlinks of suggested e-Resources:
1. [Link]
2. [Link]
3. [Link]
Pedagogical approach:
● Lecture-based teaching for theoretical concepts.
● Problem-solving sessions to apply algorithms.
● Hands-on coding assignments.
● Flipped classroom for discussions and exercises.
● Group activities for collaborative learning.
● Gamification through competitive coding challenges.
● Case studies on real-world algorithm applications.
Additional information (if any)