WOXSEN UNIVERSITY HYDERABAD
PROJECT-BASED LEARNING ASSESSMENT FOR END SEMESTER,
MAY 2025
Project-Based Learning (PBL) Evaluation Sets for Data Structures & Algorithms course.
Guidelines Comment: Each set of questions is aligned with Woxsen's PBE policy and
course (DSA) CLOs.
Project-Based Learning Evaluation Set 1
Course: Data Structures & Algorithms
Code: 24TU03MJM0
Credits: 4 (L:3, T:1, P:0)
Evaluation Type: End Sem (Project-Based Assessment)
Team Structure: 4 members per team
Project Duration: 2 weeks
Project Output: Implementation (code) + Technical Report + Zoom Viva Presentation
Set 1
1(a) Project Title: "Inventory Management System Using Linked Lists and Queues"
1(b) Project Objective
To design and implement an inventory management application that allows adding,
deleting, and managing product stocks using linked lists and queues, showcasing
dynamic data structure usage.
(c) Syllabus Integration
CLO Description Mapped to Project
Component
CLO1 Select appropriate data Use of linked lists for
structures for dynamic inventory items, queues for
collections order processing
CLO2 Assess and implement Integrate merge sort for
sorting algorithms for reorder operations
inventory sorting
CLO3 Design modular programs Class hierarchy for
using data structures product, inventory, and
order management
(d) Scenario Overview
A retail store needs a system to add new products, remove sold-out items, manage
order queues, and sort inventory based on stock levels or product ID. The team will
develop a console or GUI-based application to handle these operations.
(e) Team Roles
Role Responsibility
System Architect Design a class structure for inventory and
order management
Backend Developer Implements linked list and queue
operations, sorting algorithms
Frontend Developer Creates a basic console or GUI interface
for user interaction
QA Tester & Reporting Develops test cases, documents issues,
and writes the final technical report
(f) Expected Features
• Dynamic insertion and deletion of products using linked lists
• Order processing using queue data structure
• Sorting inventory by quantity or ID using merge sort
• Search for products using binary search on sorted lists
• Exception handling for invalid operations (e.g., removing non-existent items)
(g) Written Report Structure (Group Report)
Cover Page: Title, members' names, roles
Executive Summary: 150–200 words
Project Overview: Background, problem statement
Implementation Details: Code snippets + module descriptions
Reflection: 150–200 words/member
(h) Zoom Presentation Guidelines
Duration: 12–15 minutes
1-minute introduction
System design explanation (UML)
Code walkthrough
Demo of key functionalities
Team reflection
(i) Submission Format
• Proposal Document (PDF) + DOCX
• Final Report (PDF) + DOCX
• Source Code files (.py/.java/.cpp as applicable)
• Evidence of meetings (Screenshots, recordings, logbook)
(j) Evaluation Rubric
Component Weightage Criteria
Project Proposal 10% Problem relevance,
innovation, scope
Progress Review 20% Milestone tracking,
feedback incorporation
Final Submission 30% Design, code functionality,
and correctness
Presentation/Viva 30% Technical clarity,
communication, and demo
quality
Peer/Self Review 10% Reflections, contributions,
and fairness
(k) Grading Guidelines
Excellent (90–100%): Exceptional project, design, implementation, and teamwork
Good (70–89%): Solid project with minor issues and good collaboration
Average (50–69%): Functional but with significant flaws and fair collaboration
Below Average (<50%): Incomplete, non-functional, or poor collaboration
Project-Based Learning Evaluation Set 2
Course: Data Structures & Algorithms
Code: 24TU03MJM0
Credits: 4 (L:3, T:1, P:0)
Evaluation Type: End Sem (Project-Based Assessment)
Team Structure: 4 members per team
Project Duration: 2 weeks
Project Output: Implementation (code) + Technical Report + Zoom Viva Presentation
Set 2
2(a) Project Title: "Text Search Engine Using Tries and Pattern Matching
Algorithms"
2(b) Project Objective
To build a simple text search engine that indexes a collection of documents using trie
data structure and implements pattern matching (e.g., KMP) for fast query responses.
(c) Syllabus Integration
CLO Description Mapped to Project
Component
CLO1 Select data structures for Use of tries for storing
efficient indexing dictionary and document
keywords
CLO2 Implement and compare Integrate KMP and brute-
pattern matching force search to compare
algorithms performance
CLO3 Design modular search Classes for document
application using processing, indexing, and
datastructures search interface
(d) Scenario Overview
A small digital library needs a search utility to allow users to input a keyword and quickly
retrieve document names and positions where the keyword appears. The application will
build an index from provided text files and support real-time queries.
(e) Team Roles
Role Responsibility
System Architect Designs data flow for indexing and search
operations
Algorithm Specialist Implements trie structure and pattern
matching algorithms (KMP, naive)
Backend Developer Handles file I/O, indexing, and query
handling
QA Tester & Reporting Tests search accuracy and speed, writes
the technical report
(f) Expected Features
• Build a trie-based index from a collection of text files
• Support insertion of new documents and deletion of outdated ones
• Implement KMP algorithm for efficient pattern matching
• Compare search times between KMP and brute-force approaches
• Handle edge cases such as empty queries and missing documents
(g) Written Report Structure (Group Report)
Cover Page: Title, members' names, roles
Executive Summary: 150–200 words
Project Overview: Background, problem statement
Implementation Details: Code snippets + module descriptions
Reflection: 150–200 words/member
References: Books, websites, official documentation
(h) Zoom Presentation Guidelines
Duration: 12–15 minutes
1-minute introduction
System design explanation (UML)
Code walkthrough
Demo of key functionalities
Team reflection
(i) Submission Format
• Proposal Document (PDF) + DOCX
• Final Report (PDF) + DOCX
• Source Code files (.py/.java/.cpp as applicable)
• Evidence of meetings (Screenshots, recordings, logbook)
(j) Evaluation Rubric
Component Weightage Criteria
Project Proposal 10% Problem relevance,
innovation, scope
Progress Review 20% Milestone tracking,
feedback incorporation
Final Submission 30% Design, code functionality,
and correctness
Presentation/Viva 30% Technical clarity,
communication, and demo
quality
Peer/Self Review 10% Reflections, contributions,
and fairness
Project-Based Learning Evaluation Set 3
Course: Data Structures & Algorithms
Code: 24TU03MJM0
Credits: 4 (L:3, T:1, P:0)
Evaluation Type: End Sem (Project-Based Assessment)
Team Structure: 4 members per team
Project Duration: 2 weeks
Project Output: Implementation (code) + Technical Report + Zoom Viva Presentation
Set 3
3(a) Project Title: "Route Planning System Using Graphs and Shortest Path
Algorithms"
3(b) Project Objective
To develop a route planning application that models a network of cities/locations as a
graph and computes the shortest path using Dijkstra's or BFS/DFS for unweighted
graphs.
(c) Syllabus Integration
CLO Description Mapped to Project
Component
CLO1 Select appropriate data Use adjacency list for
structure for graph sparse graph modeling
representation
CLO2 Implement and analyze Integrate Dijkstra's
shortest path algorithms algorithm and BFS for
pathfinding
CLO3 Design a modular graph- Classes for graph
based application representation,
pathfinding, and user
interaction
(d) Scenario Overview
A logistics company wants a desktop application where users can add cities (nodes) and
roads (edges), then query for the shortest route between two cities. The application
should visualize or display the path and distance.
(e) Team Roles
Role Responsibility
System Architect Designs the graph data structure and
overall software modules
Algorithm Specialist Implements Dijkstra's and BFS algorithms
for pathfinding
Frontend Developer Creates a console or basic GUI for adding
nodes/edges and querying routes
QA Tester & Reporting Validates path correctness, measures
performance, and writes the final report
(f) Expected Features
• Represent a network of cities as a weighted/unweighted graph
• Add, remove, and update nodes and edges dynamically
• Compute shortest path using Dijkstra's algorithm for weighted graph
• Implement BFS for unweighted pathfinding
• Display path and total distance in user-friendly format
(g) Written Report Structure (Group Report)
Cover Page: Title, members' names, roles
Executive Summary: 150–200 words
Project Overview: Background, problem statement
System Design: UML class diagram + explanation
Implementation Details: Code snippets + module descriptions
Reflection: 150–200 words/member
References: Books, websites, official documentation
(h) Zoom Presentation Guidelines
Duration: 12–15 minutes
1-minute introduction
System design explanation (UML)
Code walkthrough
Demo of key functionalities
Team reflection
(i) Submission Format
• Proposal Document (PDF) + DOCX
• Final Report (PDF) + DOCX
• Source Code files (.py/.java/.cpp as applicable)
• Evidence of meetings (Screenshots, recordings, logbook)
(j) Evaluation Rubric
Component Weightage Criteria
Project Proposal 10% Problem relevance,
innovation, scope
Progress Review 20% Milestone tracking,
feedback incorporation
Final Submission 30% Design, code functionality,
and correctness
Presentation/Viva 30% Technical clarity,
communication, and demo
quality
Peer/Self Review 10% Reflections, contributions,
and fairness
Project-Based Learning Evaluation Set 4
Course: Data Structures & Algorithms
Code: 24TU03MJM0
Credits: 4 (L:3, T:1, P:0)
Evaluation Type: End Sem (Project-Based Assessment)
Team Structure: 4 members per team
Project Duration: 2 weeks
Project Output: Implementation (code) + Technical Report + Zoom Viva Presentation
Set 4
(a) Project Title: Smart Parking System Using Stacks and Queues
(b) Project Objective
To simulate a smart parking lot system using stacks for vehicle parking and queues for
waiting vehicles, demonstrating linear data structure operations and algorithmic design.
(c) Syllabus Integration
CLO Description Mapped to Project Component
Implement stack and queue- Stack for parking slots, queue for vehicles in
CLO1
based operations waiting
Develop modular programs with Class-based architecture for vehicle, parking
CLO3
data abstraction slot, and queue management
Apply algorithms in real-world Use of recursion and searching within the stack
CLO4
contexts for vehicle retrieval
(d) Scenario Overview
A parking lot has limited slots (stack structure: LIFO), and vehicles arrive randomly.
When full, arriving vehicles are placed in a waiting queue. If a vehicle leaves from the
middle, others must be moved (recursion or temporary stacks). Implement a simulation
to track entries, exits, and waiting list updates.
(e) Team Roles
Role Responsibility
Designs the architecture (classes: Vehicle, ParkingLot,
System Architect
WaitingQueue)
Backend Developer Implements stack, queue, and recursive search logic
Frontend Developer Develops a CLI for simulating arrival/departure of vehicles
QA &
Writes test cases and documents vehicle logs, designs the report
Documentation
(f) Expected Features
• Add/Remove vehicles from parking lot using a stack
• Maintain a queue of waiting vehicles
• Vehicle lookup and retrieval with appropriate shifting (recursion or temporary
storage)
• Reports on parking usage and waiting time
• Handling edge cases (e.g., vehicle not found)
Project-Based Learning Evaluation Set 5
Course: Data Structures & Algorithms
Code: 24TU03MJM0
Credits: 4 (L:3, T:1, P:0)
Evaluation Type: End Sem (Project-Based Assessment)
Team Structure: 4 members per team
Project Duration: 2 weeks
Project Output: Implementation (code) + Technical Report + Zoom Viva Presentation
Set 5
(a) Project Title: File Organizer Using Trees and Hash Tables
(b) Project Objective
To build a system that simulates file organization using tree structures for folder
hierarchy and hash tables for quick file access by filename.
(c) Syllabus Integration
CLO Description Mapped to Project Component
Apply non-linear data structures like
CLO1 Use trees to simulate folder hierarchy
trees
Implement hashing techniques for Hash tables with linear and quadratic
CLO2
fast retrieval probing for file access
Integrate searching and sorting in Use binary search for finding files in sorted
CLO3
real scenarios lists per folder
(d) Scenario Overview
A simplified OS file system with directories (modeled as tree nodes) and files (with hash-
based quick lookup). Each folder can contain files and subfolders. The team builds this
with options to insert, delete, search, and organize files.
(e) Team Roles
Role Responsibility
Tree Architect Designs tree structure for folder and subfolder relationships
Hashing Developer Implements hash table with probing and rehashing for file storage
Interface Builder CLI or GUI simulation of folder navigation and file operations
Report Lead Handles report, testing evidence, and logs
(f) Expected Features
• Create/Delete folders (tree node management)
• Add/Delete/Rename files within folders
• File retrieval using hashing
• Rehashing when collision exceeds threshold
• Visualization of folder structure (tree traversal demo)
Project-Based Learning Evaluation Set 5
Course: Data Structures & Algorithms
Code: 24TU03MJM0
Credits: 4 (L:3, T:1, P:0)
Evaluation Type: End Sem (Project-Based Assessment)
Team Structure: 4 members per team
Project Duration: 2 weeks
Project Output: Implementation (code) + Technical Report + Zoom Viva Presentation
Set 6
(a) Project Title:
"Student Academic Records System Using AVL Trees and Hashing"
(b) Project Objective
To develop an application that stores and manages student academic records using AVL
trees for sorted access and hash tables for efficient direct retrieval.
(c) Syllabus Integration
CLO Description Mapped to Project Component
Use balanced trees for sorted data
CLO1 AVL tree for student ID-based ordering
management
Apply hash tables for quick key-based Hashing with open addressing to
CLO2
access retrieve student details
Design scalable systems using dynamic Modular design with rehashing, dynamic
CLO3
data structures insertions
(d) Scenario Overview
An academic office wants to maintain student records that can be searched by roll
number or name. AVL trees are used to keep records sorted by roll number, while
hashing provides constant-time access using names.
(e) Team Roles
Role Responsibility
Tree Architect Implements AVL tree operations for ordered access
Hashing Developer Builds hash table with probing and extendible hashing
Integration Lead Combines both structures in a working application
Documentation Head Maintains test logs, edge case handling, and final report
(f) Expected Features
• Insert/Delete/Search student record
• Hash-based retrieval by name
• AVL tree traversal for sorted listing
• Collision handling and rehashing
• GPA sorting and top-performer queries
