TEAM GENERATOR

A
Mini Project Report

Submitted to

Jawaharlal Nehru Technological University, Hyderabad

In partial fulfillment of the requirements for the
award of the degree of
BACHELOR OF TECHNOLOGY
In
COMPUTER SCIENCE AND ENGINEERING
By
MANGALI MANJUNATH
(21VE1A0543)

Under the Guidance of

Dr. U.M. FERNANDES DIMLO
Professor & Head

SREYAS INSTITUTE OF ENGINEERING AND TECHNOLOGY

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
(Affiliated to JNTUH, Approved by A.I.C.T.E and Accredited by NAAC, New Delhi)
Bandlaguda, Beside Indu Aranya, Nagole, Hyderabad-500068, Ranga Reddy Dist.
2021-2025
I
 SREYAS INSTITUTE OF ENGINEERING AND TECHNOLOGY
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

CERTIFICATE
This is to certify that the Mini Project Report on “TEAM GENERATOR” submitted by
Mangali Manjunath bearing Hall ticket No. 21VE1A0543 in partial fulfillment of the
requirements for the award of the degree of Bachelor of Technology in COMPUTER
SCIENCE AND ENGINEERING from Jawaharlal Nehru Technological University,
Kukatpally, Hyderabad for the academic year 2024-25 is a record of bonafide work carried
out by him under our guidance and Supervision.

Project Coordinator Head of the Department

Dr. U.M. FERNANDES DIMLO Dr. U.M. FERNANDES DIMLO
Professor & Head Professor & Head

Internal Guide External Examiner

Dr. U.M. FERNANDES DIMLO
Professor & Head

II
SREYAS INSTITUTE OF ENGINEERING AND TECHNOLOGY
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

DECLARATION

I Mangali Manjunath bearing Hall ticket No. 21VE1A0543 hereby declare that the Mini
Project titled TEAM GENERATOR done by me under the guidance of Dr. U.M.
FERNANDES DIMLO, Professor &Head which is submitted in the partial fulfillment of
the requirement for the award of the B. Tech degree in Computer Science and Engineering
at Sreyas Institute of Engineering & Technology for Jawaharlal Nehru Technological
University, Hyderabad is my original work.

MANGALI MANJUNATH
(21VE1A0543)

III
 ACKNOWLEDGEMENT

The successful completion of any task would be incomplete without mention of the
people who made it possible through their guidance and encouragement crowns all the
efforts with success.
I take this opportunity to acknowledge with thanks and deep sense of gratitude to
Dr. U.M. Fernandes Dimlo, Professor & Head, Department of Computer Science for
his constant encouragement and valuable guidance during the Project work.
A Special vote of Thanks to Dr. U.M. Fernandes Dimlo, Head of the Department
and Co-Ordinator who has been a source of Continuous motivation and support. He had
taken time and effort to guide and correct me all through the span of this work.
I owe very much to the Department Faculty, Principal and the Management who
made me at Sreyas a stepping stone for my career. I treasure every moment I had spent in
the college.
Last but not the least, our heartiest gratitude to my parents and friends for their
continuous encouragement and blessings. Without their support this work would not have
been possible.

MANGALI MANJUNATH
(21VE1A0543)

IV
 ABSTRACT

In educational institutions, efficiently organizing students into effective study groups

or batches is crucial for academic success and faculty guidance. This project focuses
on automating the process of team formation and guide allocation based on student
academic records and faculty expertise.

Initially, student data, including names, roll numbers, semester-wise marks, and CGPA
(if applicable), are extracted from an Excel sheet and stored in a database. For students
with pending examinations, the number of backlogs is recorded for subsequent
handling.

Students who have achieved a CGPA through passing all their examinations are
grouped into batches, ensuring equal distribution based on academic performance.
Students with backlogs are assigned to separate groups.

The next phase involves allocating faculty guides to each batch. Guides are selected
based on their qualifications, including designation, experience (minimum 5 years), and
domain expertise. Faculty preferences for specific domains are considered to ensure
optimal mentorship alignment.

Finally, the total number of students is divided into batches of four students each, with
the batch count adjusted to accommodate any remaining students in a final batch of
appropriate size.

This project streamlines the team formation process, enhances academic collaboration,
and ensures effective mentorship, thereby improving overall learning outcomes in
educational settings.

V
 TABLE OF CONTENTS

S.NO TABLE OF CONTENTS PAGE NO.

1 INTRODUCTION 1-8
1.1 GENERAL 1
1.2 PROBLEM STATEMENT 1
1.3 OBJECTIVES 2
1.4 EXISTING SYSTEM 3
1.5 PROPOSED SYSTEM 5
2 LITERATURE SURVEY 9-12
3 REQUIREMENTS 13-14
3.1 GENERAL 13
3.2 HARDWARE REQUIREMENTS 13
3.3 SOFTWARE REQUIREMENTS 13
4 SYSTEM DESIGN 15-22
4.1 GENERAL 15
4.2 SYSTEM ARCHITECTURE 15
4.3 UML DISGN 15
4.3.1 USE-CASE DIAGRAM 17
4.3.2 CLASS DIAGRAM 19
4.3.3 ACTIVITY DIAGRAM 21

VI
5 TECHNOLOGY DESCRIPTION 23-28

5.1 WHAT IS PHP? 23

5.2 ADVANTAGES OF JAVA 24

5.3 LIBRARIES 26

5.4 DISADVANTAGES OF JAVA 27

6 IMPLEMENTATION 29-50

6.1 METHODOLOGY 29

6.2 SAMPLE CODE 33

7 TESTING 51-52

7.1 GENERAL 51

7.2 TYPES OF TESTING 51

7.3 TEST CASES 52

8 RESULTS 53-55

9 FUTURE SCOPE 56-57

10 CONCLUSION 58-58

11 REFERENCES 59-60

VII
 LIST OF FIGURES

Fig. No Name of Figure Page No

4.1 System Architecture Team Generator 15
4.2 Use Case Diagram for Team Generator 18
4.3 Class Diagram for Team Generator 20
4.4 Activity Diagram for Team Generator 22
7.1 Types of Testing 51
7.2 Testcases of System 52
8.1 Login page 53
8.2 Input type selection page 53
8.3 File uploading page 54
8.4 Student details input page 54
8.5 Team size input page 55
8.6 Final output page 55

VIII
 LIST OF SYMBOLS

S.NO. NOTATION NOTATION NAME DESCRIPTION

Class Represents a collection of
1 similar entities grouped
together.

2 Association Associations represent static

relationships between
classes.

3 Directed Association Roles represent the way the

two classes see each other.

4 Actor It aggregates several classes

into a single class

5 Use cases Interact ion between the

system and external
environment.

6 Decision box Represents decision making

process from a constraint

7 Initial State Initial state of the object

8 Final State Final state of the object

9 Activity State of the process

IX
 CHAPTER 1

INTRODUCTION

1.1 GENERAL
In academic institutions, grouping students effectively into study batches plays a vital
role in fostering collaborative learning environments and optimizing faculty support. The
manual processes traditionally used for forming study groups and assigning faculty
mentors often result in inefficiencies, inaccuracies, and inconsistencies. These issues can
lead to unbalanced academic performance within groups, misalignment between mentor
expertise and student needs, and an overall lack of equitable resource distribution.
The increasing size of student populations and the growing complexity of academic
requirements necessitate a systematic approach to these tasks. This project introduces an
automated solution to address these challenges by using data-driven methodologies to
create balanced study groups and allocate faculty guides based on their qualifications and
domain expertise.
The system is designed to streamline administrative workflows, reduce errors, and ensure
fairness in the distribution of students and faculty resources. By automating repetitive
tasks and incorporating intelligent algorithms, the proposed solution enables institutions
to focus on delivering high-quality education and mentorship.

1.2 PROBLEMS TATEMENT

Traditional methods of forming study groups and assigning mentors are inadequate in
modern academic settings, primarily due to their reliance on manual processes. These
methods are often subjective, time-intensive, and prone to errors. Key challenges include:
• Uneven Distribution of Students:
Manually forming groups can result in imbalances in academic performance
within batches, hindering collaboration and progress.
1
 • Mismatch of Faculty Expertise:
Faculty mentors may be assigned to groups without consideration of their domain
expertise or preferences, leading to suboptimal mentorship experiences.
• Administrative Overheads:
The manual effort required to gather data, analyze it, and assign groups and
mentors is significant, diverting resources from core academic functions.
• Lack of Adaptability:
Traditional methods struggle to accommodate dynamic changes such as updated
academic records, faculty availability, or varying student intake.
These issues can negatively impact the learning outcomes of students and the
effectiveness of faculty guidance. The proposed automated system addresses these
shortcomings by providing a standardized, efficient, and adaptive approach to forming
study groups and allocating mentors.

1.3 OBJECTIVES
The primary goal of the project is to enhance the efficiency and accuracy of group
formation and mentor allocation processes. The specific objectives include:
1. Automating Study Group Formation:
o Develop a system to analyze student data, including semester-wise marks,
CGPA, and backlogs, to create balanced study groups.
o Ensure fair distribution of students based on academic performance metrics.
2. Optimizing Faculty Guide Allocation:
o Match faculty mentors to student groups by evaluating their qualifications,
teaching experience, and domain expertise.
o Incorporate faculty preferences for specific domains or group types to
enhance mentorship quality.

2
 3. Enhancing Collaboration and Mentorship:
o Foster better academic collaboration by grouping students with
complementary skill sets and knowledge levels.
o Strengthen the mentor-student relationship by aligning faculty expertise
with the needs of the group.
4. Minimizing Administrative Efforts:
o Reduce the time and manual effort required for forming study groups and
assigning mentors.
o Provide a user-friendly interface for administrators to monitor and manage
the grouping and allocation processes efficiently.
5. Ensuring Scalability and Adaptability:
o Design the system to handle varying student intake sizes and dynamic
updates to academic records.
o Allow flexibility in adjusting group sizes and mentor assignments based on
institutional needs.

1.4 EXISTING SYSTEM

The current systems used for forming study groups and assigning mentors in
academic institutions are predominantly manual or, at best, partially automated, relying
on basic tools such as spreadsheets or predefined grouping templates. These systems
aim to organize students into study groups and allocate faculty mentors to provide
guidance and support. However, they suffer from several inefficiencies and limitations
that hinder their effectiveness in addressing the dynamic needs of educational
institutions.
1. Manual Group Formation Systems
Many institutions rely on manual processes where administrators or faculty
members review student academic records, sort them into groups, and assign mentors.

3
 While straightforward, this approach is time-intensive and prone to biases, errors, and
inefficiencies.
Limitations:
• Time-consuming and error-prone.
• Results in uneven academic groupings.
• Lacks scalability and adaptability for large student populations.
2. Learning Management Systems (LMS)
Platforms like Moodle, Blackboard, and Canvas offer basic tools for grouping
students within courses. These tools allow instructors to create groups manually or
randomly, assign activities, and facilitate collaboration.
Limitations:
• Lack of sophisticated algorithms for balancing academic performance.
• Limited integration with mentor allocation.
• Requires significant manual effort for setup and monitoring.
3. AI-Based Educational Platforms
Some institutions and startups are experimenting with AI-powered solutions for team
formation and mentor assignment. Examples include:
• Peachy Mondays (used in HR settings): Provides AI-driven team and mentor
matching based on compatibility scores, which could be adapted for academic
purposes.
• EdTech Tools with AI: Platforms like Coursera and Udemy use AI to recommend
courses and mentors, showcasing similar technologies that could be applied to team
formation in schools.
Limitations:
• Primarily focused on career and skill-based matching, not academic
performance.
• Limited customization for specific institutional requirements.

4
4. Skill and Performance-Based Grouping Systems
Some academic tools use predefined algorithms to sort students based on their
performance in specific subjects or courses. For example, tutoring platforms like
Varsity Tutors and Knewton group students based on their learning styles and
performance.
Limitations:
• Typically designed for individual or small group tutoring, not large-scale
academic institution needs.
• Focused on remedial education rather than balanced academic collaboration.
5. Mentor-Matching Systems in Online Education Platforms
Platforms like MentorCruise and Meet Your Mentor specialize in pairing students
with mentors. They use algorithms based on domain expertise, professional
experience, and student preferences.
Limitations:
• Lacks integration with student academic data for automated batch formation.
• More suitable for one-on-one mentorship rather than group scenarios.
6. Research Collaboration Tools
Systems like ResearchGate and Mendeley connect researchers based on shared
interests and expertise. While these are more research-oriented, their methodologies
for forming collaborations can inspire similar systems for student groups.
Limitations:
• Primarily for professional researchers, not students.
• No integration with academic performance metrics or backlogs.

1.5 PROPOSED SYSTEM

This project is an automated solution designed to streamline the process of organizing
students into effective study groups and assigning faculty guides in academic

5
institutions. By leveraging automation and data-driven algorithms, the system enhances
efficiency, fairness, and academic collaboration. The project primarily focuses on
ensuring balanced group formations and optimal mentor assignments, aligning with the
students' academic needs and the mentors' expertise.
Key Features and Functionalities
1. Data Extraction and Storage:
• Input: Student data, including names, roll numbers, semester-wise marks,
CGPA (if applicable), and backlog status.
• Source: Data is extracted from an Excel sheet and stored in a structured
database for further processing.
• Handling Special Cases: Students with pending examinations are flagged,
and the number of backlogs is recorded for differentiated grouping.
2. Group Formation:
• Students with completed CGPA (all exams cleared) are grouped into balanced
batches based on academic performance, ensuring fairness.
• Students with backlogs are assigned to separate groups for targeted guidance
and support.
• Groups are formed with a maximum of four students per batch, with remaining
students adjusted into the final batch to maintain equitable group sizes.
3. Faculty Guide Allocation:
• Faculty mentors are selected based on:
o Qualifications: Designation and expertise.
o Experience: A minimum of 5 years of teaching or related experience.
o Domain Expertise: Alignment of faculty expertise with the group's
academic focus.
o Preferences: Consideration of faculty preferences for specific domains
or group types.
6
 • Each group is assigned one faculty guide to ensure personalized mentorship
and effective guidance.
4. System Objectives:
• Minimize administrative workload by automating repetitive tasks.
• Ensure fair and balanced academic distribution within groups.
• Align mentor expertise with student group requirements for better learning
outcomes.
• Adapt dynamically to changes in student or faculty data, enabling scalability.

Technology Stack
1. Frontend:
o Framework:HTML for creating a user-friendly interface for administrators.
o Features: Interfaces for uploading data, viewing groups, and monitoring mentor
assignments.
2. Backend:
o Framework: PHP for processing data and managing the grouping logic.
o Tools: General Logic for analyzing academic records and forming groups based
on performance metrics.
3. Database:
o MySQL for storing student and faculty data.
o Includes tables for students, groups and faculty.
4. Integration Tools:
o Excel Parsing: Libraries such as PHPSpreadsheet for extracting and
validating data from Excel sheets.

7
Advantages
1. Efficiency:
o Automates repetitive tasks, reducing the time required for batch formation and
mentor allocation.
o Improves accuracy by eliminating human errors in data handling and analysis.
2. Fairness:
o Ensures equitable group distribution based on academic performance.
o Provides targeted support to students with backlogs.
3. Enhanced Mentorship:
o Matches faculty expertise with group requirements, improving mentorship
quality.
o Facilitates faculty preferences, leading to more engaged and effective guides.
4. Scalability:
o Adapts to varying class sizes and institutional needs, from small courses to large
student bodies.
o Handles dynamic updates to student or faculty data without disrupting the
system.
Future Scope
1. Machine Learning Integration:
o Use machine learning algorithms to predict optimal group compositions based on
compatibility and performance trends.
2. Mobile Application:
o Develop a mobile app for students and faculty to view group assignments,
schedules, and updates in real-time.
3. Enhanced Metrics:
o Include non-academic parameters, such as extracurricular activities or skills, for
holistic group formation.
4. Real-Time Feedback:
o Allow faculty and students to provide feedback on group dynamics and
mentorship effectiveness for continuous system improvement.

8
 CHAPTER 2
LITERATURE SURVEY
1. A New Approach to Collaborative Group Formation
--This paper implements a tool, referred to as the Automated Group Decomposition
Program (AGDP), which divides a class of students into groups, using the k-means
algorithm, for the purpose of collaborative learning, and then heterogenizes the groups
based on a factor called the degree of heterogeneity (DOH). The tool takes as input
two sets of scores and the students‟ roll numbers and outputs the required groups. The
first score set scored students on communication skills, fluency in using computers
and group work attitude. This score set was used to generate the homogeneous groups.
The second score set scored students on their knowledge of the subject and was used
to generate the heterogeneous groups. The tool can be used to generate homogeneous
clusters, heterogeneous clusters and a mixture of both. This tool can not only be used
by teachers but also by instructors with minimal computer experience wishing to form
groups to maximize learning. Keywords collaborative learning, k-means, constraint
satisfaction, degree of homogeneity, group learning, homogeneous groups,
heterogeneous groups.

2. Collaborative Group Formation Using Genetic Algorithms

--Collaborative learning is a process in which two or more individuals interact in order
to learn or attempt to learn something. The success of the process depends heavily on
the way in which the individuals are engaged in a community, i.e. where the process
takes place. Individuals in the community are grouped into small clusters that i) posses
homogeneous properties and ii) emphasize the diversity inside the group, allowing
flourishing of diverse points of view. In this work we focus on the formation of groups
of individuals. More specifically, we apply genetic algorithms in the formation process
in order to deal with the high level of complexity. We developed a prototype to evaluate
9
 the approach and the results are discussed. Keywords. Genetic algorithms,
Collaborative learning

3. A Method for Group Formation Using Genetic Algorithm

— Due to the increasing of complexity in software projects, group work is becoming
more important in order to ensure quality software products can be delivered on time.
Thus, in universities, group work is seen as a good preparation for students to enter
industry because by working in group, it can reduce the individual workload, improve
the ability to manage a project and enhance the problem solving skills. However, due
to lack of programming skills especially in Java programming language, most of the
students’ software project cannot be delivered successfully. To solve this problem,
systematic group formation is one of the initial factors that should be considered to
ensure that every group consists of quality individuals who are good in programming.
This paper presents a method for group formation using genetic algorithm, where the
members for each group will be generated based on the students’ programming skill.
Keywords-group formation; genetic algorithm; programming skill.

4. Grouping in Collaborative E-Learning Environment

— Collaborative learning is an online classroom can take the form of discussion
among the whole class or within smaller groups. Moodle (Modular ObjectOriented
Dynamic Learning Environment) is a free and open source e-learning software
platform, also known as a Learning Management System, or Virtual Learning
Environment (VLE). As a web-based tool, Moodle offers the potential to deliver
courses which include a huge variety of information sources – links to websites,
images, and multimedia – which are difficult to deliver in a traditional teaching
environment. The chat activity module in moodle allows participants to have a real-
time synchronous discussion in a moodle course. A teacher can organize users into
groups within the course or within particular activities. This paper aims in efficient

10
 group formation of learners in a collaborative learning environment so that every
individual in the group is benefitted. As a testing platform tenth standard Tamil text
book is incorporated in to moodle. In this paper K-NN clustering algorithm is used to
improve the group performance. This algorithm achieves good performance in terms
of balancing the knowledge level among all the students. . Key Words— KNN,
Collaborative environment, moodle, elearning, group formation.

5. A ‘Mixed’ Approach to Smart Group Formation

--The most important aspect in collaborative learning is group formation. Over the
years, researchers have proposed a variety of algorithms for collaborative group
formation. Researchers have identified learner’s characteristics for this purpose like
learning style, subject knowledge, preferred time slot, and domain expertise. Most of
the generated groups were heterogeneous in nature. This study uses two parameters,
the personal style of the learner and a performance indicator for collaborative group
formation. Similar personal styles within a group were thought to facilitate group
work, whereas a diverse degree of knowledge was thought to enhance the quality of
learning. This ‘mixed’ approach was initially used to form homogeneous groups using
K-means clustering. Heterogeneity was introduced within these groups through
Agenda-driven search. An Automated Group Decomposition Program was written in
Java platform using the developed model ,which was used to generate groups of
students doing post-graduate workin Computer Science for their project work. T-test
and survey results indicate that the proposed method is more effective for group
formation than traditional methods. Keywords: Agenda Driven Search, Collaborative
Learning, Group Formation, K-Means Algorithm, Personal Style, Performance
Indicator.

11
6. A Genetic Algorithm-based Group Formation:
— Group formation to assign students with academic advisors based on student
demography can be exhaustive as various possibilities and combinations can be
formed. Hence, this paper proposed a genetic algorithm-based approach to automate
group formation based on student demography to assign students to their academic
advisors. The genetic algorithm (GA) will optimize the group formation of students
with a balanced number of nationalities, races, and genders. Also, this paper examines
the user acceptance of the proposed genetic algorithm-based application to automate
group formation using the Unified Theory of Acceptance and Use of Technology
(UTAUT) framework. The survey aims to study the impact of independent and
moderating variables on dependent variables. The result proved that all the
independent variables, Performance Expectancy (PE), Effort Expectancy (EE), Social
Influence (SI), and Facilitating Condition (FC), have a positive impact on the
dependent variable, Behavioral Intention (BI). In contrast, the moderating variable
Experience (EX) and Voluntariness of Use (VU) have a negative impact on Behavioral
Intention (BI). Thus, this paper concludes that the proposed application can increase
the performance and efficiency of group formation and automatically assign students
to academic advisors. However, respondents are reluctant and not ready to use the
system. Thus, training and workshops can be conducted to introduce and train the
users to utilize the system. Future works can be done where the application of the
proposed genetic algorithm-based system can be further expanded to different
academic purposes such as team formation for group assignment and team member
selection for competition.

12
 CHAPTER 3
REQUIREMENTS

3.1 GENERAL
These are the requirements for doing the project.
They are:
1. Hardware Requirements
2. Software Requirements

3.2 HARDWARE REQUIREMENTS

The hardware requirements may serve as the basis for a contract for the
implementation of the system and should therefore be a complete and consistent
specification of the whole system. They are used by software engineers as the starting
point for the system design. It should be what the system does and not how it should be
implemented.
Minimum hardware requirements are very dependent on the particular software being
developed by a given Enthought Python / Canopy / VS Code user. Applications that need
to store large arrays/objects in memory will require more RAM, whereas applications
that need to perform numerous calculations or tasks more quickly will require a
faster processor.
• Processor : minimum intel i3
• Ram : 1 gb and above
• Hard disk : minimum 20gb

3.3 SOFTWARE REQUIREMENTS

The software requirements document is the specification of the system. It should
include both a definition and a specification of requirements. It is a set of what the system

13
should do rather than how it should do it. The software requirements provide a basis for
creating the software requirements specification. It is useful in estimating cost, planning
team activities, performing tasks and tracking the teams and tracking the team’s progress
throughout the development activity.
The functional requirements or the overall description documents include the product
perspective and features, operating system and operating environment, graphics
requirements, design constraints and user documentation.
The appropriation of requirements and implementation constraints gives the general
overview of the project in regards to what the areas of strength and deficit are and how
to tackle them.
• Windows OS (windows 7,10,11) Or Linux
• HTML, CSS, Java Script, PHP
• PHP Wamp Server for Windows(Apache)
• MySQL (for Database)

14
 CHAPTER 4
SYSTEM DESIGN
4.1 GENERAL
The system design for the project, Automated Study Group Formation and Mentor
Allocation, involves a structured architecture to ensure the seamless operation of data
processing, group formation, and mentor assignment. Below is an overview of the system
design, broken down into its major components:

4.2 SYSTEM ARCHITECTURE

USER
INPUT

Figure 4.1: Architecture Diagram

4.3 UML DIAGRAMS

Unified Modeling Language (UML) is a general purpose modeling language. The
main aim of UML is to define a standard way to visualize the way a system has been
designed. It is quite similar to blueprints used in other fields of engineering.
UML is not a programming language; it is rather a visual language.Use UML diagrams

15
to portray the behavior and structure of a system, UML helps software engineers,
businessmen and system architects with modeling, design and analysis.
It’s been managed by OMG ever since. International Organization for Standardization
(ISO) published UML as an approved standard in 2005. UML has been revised over the
years and is reviewed periodically.
UML combines best techniques from data modeling (entity relationship diagrams),
business modeling (work flows), object modeling, and component modeling. It can be
used with all processes, throughout the software development life cycle, and across
different implementation technologies.
UML has synthesized the notations of the Booch method, the Object-modeling technique
(OMT) and Object-oriented software engineering (OOSE) by fusing them into a single,
common and widely usable modeling language. UML aims to be a standard modeling
language which can model concurrent and distributed systems.
The Unified Modeling Language (UML) is used to specify, visualize, modify, construct
and document the artifacts of an object-oriented software intensive system under
development. UML offers a standard way to visualize a system's architectural blueprints,
including elements such as: ▪ Actors ▪ Business processes ▪ (logical) Components ▪
Activities ▪ Programming Language Statements ▪ Database Schemes ▪
Reusable software components.
➢ Complex applications need collaboration and planning from multiple teams and
hence require a clear and concise way to communicate amongst them.
➢ Businessmen do not understand code. So UML becomes essential to communicate
with non-programmer's essential requirements, functionalities and processes of
the system.
➢ A lot of time is saved down the line when teams are able to visualize processes,
user interactions and static structure of the system.
➢ UML is linked with object oriented design and analysis. UML makes the use of

16
 elements and forms associations between them to form diagrams. Diagrams in
UML can be broadly classified as:
The Primary goals in the design of the UML are as follows
➢ Provide users a ready-to-use, expressive visual modeling Language so that they
can develop and exchange meaningful models.
➢ Provide extendibility and specialization mechanisms to extend the core concepts.
➢ Be independent of particular programming languages and development processes.
➢ Provide a formal basis for understanding the modeling language.
➢ Encourage the growth of the OO tools market.
➢ Support higher level development concepts such as collaborations, frameworks,
patterns and components.
➢ Integrate best practices.

4.3.1 USE-CASE DIAGRAM

A Use Case is a kind of behavioral classifier that represents a declaration of an offered
behavior.
Each use case specifies some behavior, possibly including variants that the subject can
perform in collaboration with one or more actors. Use cases define the offered behavior
of the subject without reference to its internal structure.
These behaviors, involving interactions between the actor and the subject, may result in
changes to the state of the subject and communications with its environment. A use case
can include possible variations of its basic behavior, including exceptional .
The primary components of a use case diagram include:
❖ Actor
An actor is an external entity that interacts with the system. Actors can be people,
other systems, or even hardware devices. Actors are represented as stick figures or

17
 simple icons. They are placed outside the system boundary, typically on the left or
top of the diagram.

❖ Use Case
A use case represents a specific functionality or action that the system can perform
in response to an actor's request. Use cases are represented as ovals within the system
boundary. The name of the use case is written inside the oval.

❖ Association Relationship
An association relationship is a line connecting an actor to a use case. It represents
the interaction or communication between an actor and a use case. The arrowhead
indicates the direction of the interaction, typically pointing from the actor to the use
case.

Figure 4.2: Use-Case-Diagram

18
4.3.2 CLASS DIAGRAM
A class diagram in Unified Modeling Language (UML) is a type of structural diagram
that represents the static structure of a system by depicting the classes, their attributes,
methods, and the relationships between them. Class diagrams are fundamental in object-
oriented design and provide a blueprint for the software's architecture.
Here are the key components and notations used in a class diagram:
❖ Class
A class represents a blueprint for creating objects. It defines the properties (attributes)
and behaviors (methods) of objects belonging to that class.Classes are depicted as
rectangles with three compartments: the top compartment contains the class name,
the middle compartment lists the class attributes, and the bottom compartment lists
the class methods.
❖ Attributes
Attributes are the data members or properties of a class, representing the state of
objects. Attributes are shown in the middle compartment of the class rectangle and
are typically listed as a name followed by a colon and the data type (e.g., name:
String).
❖ Methods
Methods represent the operations or behaviors that objects of a class can perform.
Methods are listed in the bottom compartment of the class rectangle and include the
methodname, parameters, and the return type (e.g., calculateCost(parameters):
ReturnType).
❖ Visibility Notations
Visibility notations indicate the access level of attributes and methods. The common
notations are:
+ (public): Accessible from anywhere.
- (private): Accessible only within the class.

19
 # (protected): Accessible within the class and its subclasses.
~ (package or default): Accessible within the package.
❖ Associations
Associations represent relationships between classes, showing how they are
connected. Associations are typically represented as a solid line connecting two
classes. They may have multiplicity notations at both ends to indicate how many
objects of each class can participate in the relationship (e.g., 1..*).
Aggregations and Compositions: Aggregation and composition are special types of
associations that represent whole-part relationships. Aggregation is denoted by a
hollow diamond at the diamond end, while composition is represented by a filled
diamond. Aggregation implies a weaker relationship, where parts can exist
independently, while composition implies a stronger relationship, where parts are
dependent on the whole.

Figure 4.3: Class diagram

20
4.3.3 ACTIVITY DIAGRAM
An activity diagram portrays the control flow from a start point to a finish point showing
the various decision paths that exist while the activity is being executed.
The diagram might start with an initial activity such as "User approaches the door." This
activity triggers the system to detect the presence of the user's Bluetooth-enabled device,
initiating the authentication process.
Next, the diagram could depict a decision point where the system determines whether
the detected device is authorized. If the device is recognized as authorized, the diagram
would proceed to the activity "Unlock the door." Conversely, if the device is not
authorized, the diagram might show alternative paths such as prompting the user for
additional authentication credentials or denying access.
The key components and notations used in an activity diagram:
❖ Initial Node
An initial node, represented as a solid black circle, indicates the starting point of the
activity diagram. It marks where the process or activity begins.
❖ Activity/Action
An activity or action represents a specific task or operation that takes place within
the system or a process. Activities are shown as rectangles with rounded corners. The
name of the activity is placed inside the rectangle.
❖ Control Flow Arrow
Control flow arrows, represented as solid arrows, show the flow of control from one
activity to another. They indicate the order in which activities are executed.
❖ Decision Node
A decision node is represented as a diamond shape and is used to model a decision
point or branching in the process. It has multiple outgoing control flow arrows, each
labeled with a condition or guard, representing the possible paths the process can take
based on condition.

21
❖ Merge Node
A merge node, also represented as a diamond shape, is used to show the merging of
multiple control flows back into a single flow.
❖ Fork Node
A fork node, represented as a black bar, is used to model the parallel execution of
multiple activities or branches. It represents a point where control flow splits into
multiple concurrent paths.
❖ Join Node
A join node, represented as a black bar, is used to show the convergence of multiple
control flows, indicating that multiple paths are coming together into a single flow.
❖ Final Node
A final node, represented as a solid circle with a border, indicates the end point of the
activity diagram. It marks where the process or activity concludes.

Figure 4.4: Activity diagram

22
 CHAPTER 5

TECHNOLOGY DESCRIPTION

5.1 WHAT IS PHP ?

PHP (Hypertext Preprocessor) is a widely-used, open-source scripting language
designed primarily for web development. It is especially suited for creating dynamic and
interactive websites. Initially, PHP was developed by Rasmus Lerdorf in 1993 as a set
of Common Gateway Interface (CGI) binaries to track visitors to his online resume.
Over time, it evolved into a powerful language capable of handling a wide range of web
development tasks.

PHP is embedded within HTML code, allowing it to interact seamlessly with web pages.
It can be used to generate dynamic page content, handle forms, manage sessions, and
interact with databases, making it ideal for server-side scripting. The language is
commonly used in conjunction with databases like MySQL to create data-driven
websites, such as content management systems (CMS), e-commerce platforms, and
social networking sites.

PHP is executed on the server side, meaning the code is processed on the web server
before the result is sent to the user's browser. This makes it different from client-side
languages like JavaScript, which run on the user's device. PHP is compatible with
various operating systems (Windows, Linux, macOS) and web servers (Apache, Nginx),
ensuring cross-platform support.

The language supports object-oriented programming (OOP), offering advanced features

such as classes, inheritance, and polymorphism. PHP also provides powerful tools for

23
managing data and files, sending emails, and handling security features like data
sanitization and encryption.

PHP is highly customizable and extensible, with a rich ecosystem of libraries and
frameworks (such as Laravel, Symfony, and CodeIgniter) that simplify development and
speed up the creation of complex applications. The language's popularity is due to its
ease of use, large community, and robust support for web development needs.

In summary, PHP is a versatile, efficient, and easy-to-learn scripting language that

powers a significant portion of the web, making it a foundational tool for web developers
and businesses seeking dynamic, data-driven applications.

5.2 ADVANTAGES OF PHP

• Open Source and Free: PHP is free to use, which makes it a cost-effective
solution for web development. Being open-source, it also has a large community
that contributes to its improvement.
• Platform Independence: PHP is platform-independent, meaning it can run on
various operating systems like Windows, Linux, macOS, and others without
modification.
• Easy to Learn: PHP has a simple and easy-to-understand syntax, making it
accessible for beginners and allowing developers to quickly pick it up.
• Large Community Support: PHP has a vast community of developers who
provide constant updates, documentation, and support, making it easier to solve
problems and find solutions.
• Integration with Databases: PHP works seamlessly with databases, especially
MySQL, which is commonly used in web applications. It also supports other
databases like PostgreSQL, SQLite, and Oracle.
• Extensive Documentation: PHP has comprehensive documentation, making it

24
 easy for developers to find detailed information, tutorials, and examples on any
topic.
• Built-in Functions: PHP offers a wide variety of built-in functions that help
developers quickly perform tasks like handling forms, sending emails, and
working with file systems.
• Supports Object-Oriented Programming (OOP): PHP supports OOP concepts,
allowing developers to write reusable, modular code that is easier to maintain and
scale.
• Security Features: PHP provides a range of features for securing web
applications, including encryption, data sanitization, and authentication
mechanisms to prevent SQL injection and other security threats.
• Cross-browser Compatibility: PHP works with all major web browsers, making
it ideal for developing cross-browser compatible websites and applications.
• Flexible and Scalable: PHP is highly flexible and scalable, making it suitable for
building small projects as well as large, complex applications.
• High Performance: PHP scripts are executed quickly, as they are processed on
the server-side, resulting in faster page loads compared to client-side scripting.
• Easy Integration with Other Technologies: PHP integrates well with various
technologies, such as HTML, JavaScript, CSS, and XML, allowing for
comprehensive web development.
• Rich Frameworks and Libraries: PHP has many powerful frameworks (like
Laravel, Symfony, and Zend) and libraries that streamline the development
process and reduce coding time.
• Wide Hosting Support: PHP is supported by most web hosting providers, with
many offering specialized PHP hosting solutions. This makes deploying PHP-
based applications easier and more accessible.

25
5.3 LIBRARIES
1. PhpSpreadsheet Library:
• Overview: PhpSpreadsheet is an open-source PHP library designed to read, write,
and modify Excel and other spreadsheet formats. It is a successor to the older
PHPExcel library, which has been deprecated. PhpSpreadsheet provides improved
functionality, better performance, and support for newer Excel formats (e.g., .xlsx).
• Supported Formats: PhpSpreadsheet supports a wide range of spreadsheet formats,
including:
o Excel (XLS and XLSX)
o OpenDocument Format (ODS)
o CSV (Comma-Separated Values)
o HTML
o PDF (via an additional library)
o And other file formats.
2. Key Features of PhpSpreadsheet:
• Reading Files: PhpSpreadsheet can read data from Excel and CSV files, making it
easy to import data into PHP applications. It can also read the metadata of
spreadsheets (like sheet names, row/column counts, etc.).
• Writing Files: PhpSpreadsheet enables creating or modifying Excel files from
scratch. You can write data into specific cells, format the content, set cell styles, and
even add images or charts.
• Formatting: The library supports various formatting options, such as:
o Font styles (bold, italics, colors)
o Number formatting (currency, percentage, date)
o Border and background colors
o Alignment and text wrapping

26
• Formulas: PhpSpreadsheet can insert formulas into cells, and the formulas are
automatically recalculated when the spreadsheet is opened in Excel or other
compatible tools.
• Sheet Management: You can add, remove, or rename sheets, and you can also work
with multiple sheets in the same spreadsheet file.
• Cell Manipulation: The library allows setting and getting cell values, as well as
modifying properties such as data type, alignment, and cell colors.
• Data Validation: PhpSpreadsheet supports data validation, such as dropdown lists
or input restrictions, for specific cells.
Advantages of PhpSpreadsheet:
• Cross-Platform Compatibility: Since it is a PHP library, PhpSpreadsheet can be used
on any platform (Windows, Linux, macOS) with PHP installed.
• Rich Functionality: It provides comprehensive tools to create and manipulate
spreadsheet files, including advanced features like charts, images, and conditional
formatting.
• Easy to Use: The API is easy to use and provides simple methods to interact with
spreadsheets.
• Active Development and Support: PhpSpreadsheet is actively maintained and
updated by the community, making it a reliable choice for developers.

5.4 DISADVANTAGES
• Vulnerabilities: PHP has a history of security vulnerabilities, particularly in older
versions. Common issues include SQL injection, cross-site scripting (XSS), and
cross-site request forgery (CSRF). While these issues can be mitigated with
proper coding practices and frameworks, insecure code or poor configuration can
expose applications to attacks.

27
• Lack of Built-in Security Measures: Compared to some modern programming
languages, PHP does not offer a comprehensive set of built-in security features,
requiring developers to implement security measures manually.
• Function Naming: PHP has many functions with inconsistent naming
conventions (e.g., snake_case vs. camelCase), making it harder for developers to
predict how functions are named and find the correct one.
• Inconsistent Function Behavior: Some functions in PHP behave inconsistently,
with differences in parameters and return values, which can create confusion and
increase the learning curve.
• Performance Issues: PHP is not known for the best performance when handling
large-scale, resource-intensive applications. While it works well for small to
medium-sized projects, its performance can degrade as applications grow larger
and more complex.
• Not Object-Oriented by Nature: While PHP supports object-oriented
programming (OOP), its support for OOP features was historically weak, and
many older PHP codebases still use procedural programming. This can lead to
poor code maintainability and scalability in large applications.
• Lack of Built-in Advanced Features: PHP is often seen as a simple language,
and while this is an advantage for basic web applications, it becomes a limitation
for building complex systems with advanced features (e.g., real-time apps, high-
performance applications).
• Framework Reliance: PHP applications often rely on external frameworks (such
as Laravel or Symfony) to handle complex features. This means that PHP
developers may have to depend heavily on third-party libraries and frameworks,
increasing the learning curve and the complexity of maintaining the application.

28
 CHAPTER 6

IMPLEMENTATION
6.1 METHODOLOGY
The implementation methodology for Team Generator can be divided into several
phases, each focusing on specific tasks to achieve the goal of efficient student group
formation and faculty guide allocation. Below is a detailed step-by-step methodology:

1. Data Extraction and Preprocessing

Objective: Extract student data from an Excel sheet, validate it, and store it in a
database for processing.
Tasks:
• Extract Student Data:
o Extract essential student data from an Excel sheet, including names, roll
numbers, semester-wise marks, CGPA, and backlogs (if applicable).
o Use libraries such as PhpSpreadsheet (in PHP) to handle the extraction of
data from the Excel file.
• Data Validation:
o Ensure data integrity by checking for missing or incomplete entries (e.g.,
missing CGPA or semester marks).
o For students with pending examinations, track the number of backlogs in a
separate column.
• Store Data in Database:
o Store the processed student data in a relational database (e.g., MySQL or
PostgreSQL).
o Ensure the database tables are structured to handle student details, semester
marks, and backlog status.

29
2. Batch Formation Based on Academic Performance
Objective: Group students into batches based on their academic performance
(CGPA) and backlog status.
Tasks:
• Retrieve Student Data:
o Query the database to retrieve the student data (including CGPA and backlog
status).
• Group Students Without Backlogs:
o Sort students based on their CGPA in descending order (top performers
first).
o Divide students into equal-sized batches, typically 4 students per batch.
o Example: The top 4 students with the highest CGPA will form the first batch,
the next 4 students form the second batch, and so on.
• Group Students With Backlogs:
o Separate students with backlogs into distinct groups.
o Ensure that these groups also have an equal number of students.
o If the number of students doesn’t perfectly divide into batches of 4, the last
batch will have the remaining students (e.g., if 13 students are left after
forming full batches, the last batch will have 5 students).
• Handle Unequal Batch Sizes:
o Adjust the batch sizes if there are any remaining students who don’t fit into
the standard batch size of 4.
3. Handling Edge Cases
Objective: Address any exceptions or issues that may arise during the batch
formation process.
Tasks:

30
 • Unequal Batch Size:
o If a batch cannot be formed with exactly 4 students (e.g., fewer than 4
students are remaining), adjust the batch size for the last batch to fit the
remaining students.
• Handling Students with Special Cases:
o If there are students who are on the borderline (e.g., with backlogs but
performing well academically), place them in batches according to the
overall academic performance, balancing the groups in terms of both CGPA
and backlog status.
4. Finalizing Batch Assignments
Objective: Ensure the final batch structure is balanced and correctly formed.
Tasks:
• Review Batch Formation:
o Review the final batches to ensure that the students are distributed evenly
across the batches.
o Ensure that each batch has approximately the same CGPA distribution,
maintaining an equal academic challenge in each batch.
• Confirm Backlog Distribution:
o Ensure that students with backlogs are equally distributed across batches, so
that no batch is overloaded with students having backlogs.
• Final Batch Sizes:
o Confirm that the batch sizes are as balanced as possible (each batch ideally
has 4 students, with slight adjustments for any remaining students).
5. Testing and Validation
Objective: Ensure the system works as expected.
Tasks:
• Test with Sample Data:
31
 o Simulate the entire process with test data to verify that students are correctly
grouped into batches based on their CGPA and backlog status.
• Batch Formation Validation:
o Verify that students are placed in appropriate batches according to the sorted
CGPA order and the backlog count.
o Check that edge cases, such as having fewer than 4 students remaining, are
handled properly.
• Handle Any Errors:
o Identify and fix any issues with batch formation, such as mismatched number
of students, or any data inconsistency.
6. Deployment and Integration
Objective: Deploy the solution to a live environment.
Tasks:
• Integrate with Existing System:
o If the institution already has a database or system in place, integrate the batch
formation logic with the existing system. Ensure seamless data transfer and
retrieval.
• Deployment:
o Deploy the solution to a web server that supports PHP and a database (e.g.,
MySQL or PostgreSQL).
o Ensure that the system is properly configured to handle file uploads (for
student data) and display the results on a web interface.
• Monitor Performance:
o Monitor the performance of the system, especially during batch formation for
large sets of student data, and optimize as needed.
7. Documentation and Reporting
Objective: Provide clear documentation on the implementation process.
32
 Tasks:
• Document System Design:
o Document the overall system design, including:
▪ Database schemas for storing student data, including CGPA, backlog
status, and semester marks.
▪ Algorithms used for batch formation, including how students are grouped
by CGPA and backlog status.
• Generate Reports:
o Provide detailed reports on the number of students in each batch, the
distribution of academic performance across batches, and how students with
backlogs are placed.
• User Documentation:
o Provide user documentation to guide administrators through the process of
uploading student data, initiating batch formation, and viewing results.

6.2 SAMPLE CODE

Login.html
<html>
<head>
<link rel="stylesheet" href="style.css" />
</head>
<body>
<form action="input.html" method="post">
<table>
<tr>
<td colspan="2" align="center">
<h1><u>Login</u></h1>
33
 </td>
</tr>
<tr>
<td>
<label for="username">Username: </label>
</td>
<td>
<input type="text" name="username" id="username" />
</td>
</tr>
<tr>
<td>
<label for="pass">Password: </label>
</td>
<td>
<input type="text" name="pass" id="pass" />
</td>
</tr>

<tr>
<td colspan="2" align="center">
<input type="submit" value="Login" /><br />
</td>
</tr>
</table>
</form>
</body>

34
</html>
Input.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Input Type Selection</title>
<link rel="stylesheet" href="style.css" />
</head>
<body>
<form action="input.php" method="post" name="myform" id="myform">
<table>
<tr>
<td><label for="iptype">Input type:</label></td>
<td>
<select name="iptype" id="iptype" required>
<option value="">Select your choice</option>
<option value="Excel file">Excel file</option>
<option value="keyboard">Using Keyboard</option>
</select>
</td>
</tr>
<tr>
<td colspan="2" align="center">
<input
type="submit"
value="Submit"

35
 onclick="return validateForm()"
/>
</td>
</tr>
</table>
</form>
<script type="text/javascript">
function validateForm() {
const it = document.getElementById("iptype").value;
if (it !== "") {
return true;
} else {
alert("Please choose a valid option");
return false;
}
}
</script>
</body>
</html>
Excelinput.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>File Upload Form</title>
<link rel="stylesheet" href="style.css" />
</head>

36
 <body>
<form action="readfile.php" method="post">
<table>
<tr>
<td><label for="xfile">Choose the file:</label></td>
<td><input type="file" name="xfile" id="xfile" required /></td>
</tr>
<tr>
<td colspan="2" align="center">
<input type="submit" value="Submit" />
</td>
</tr>
</table>
</form>
</body>
</html>
Teamsizeinput.html
<html>
<head>
<link rel="stylesheet" href="style.css" />
</head>
<body>
<form action="teamsizeinput.php" method="post">
<table>
<tr>
<td>
<label for="nt">No. of Teams:</label>

37
 </td>
<td>
<input type="number" name="nt" id="nt" />
</td>
</tr>
<tr>
<td colspan="2" align="center">(or)</td>
</tr>
<tr>
<td>
<label for="size">Size of the team:</label>
</td>
<td>
<input type="number" name="size" id="size" />
</td>
</tr>
<tr>
<td colspan="2" align="center">
<input type="submit" value="Submit" onclick="return f1()" /><br />
Note: if you enter both size and no. of teams fields the algorithm
prefers the No. of teams field details
</td>
</tr>
</table>
</form>
<script>
function f1() {

38
 const size = document.getElementById("size").value;
const nt = document.getElementById("nt").value;
if (size === "" && nt === "") {
alert(
"Please enter valid details either Size of the team or No. of Teams."
);
return false;
}
return true;
}
</script>
</body>
</html>
Input.php
<?php
// Check if form is submitted and iptype is set
if(isset($_POST['iptype'])) {
$it = filter_input(INPUT_POST, 'iptype', FILTER_SANITIZE_STRING);
if ($it === "Excel file") {
header("Location: excelinput.html");
exit();
} else if ($it === "keyboard") {
header("Location: keyboard.html");
exit();
} else {
echo "Please provide valid details.";
}

39
} else {
echo "No input type selected.";
}
?>
Readfile.php
<?php
require 'vendor/autoload.php';
use PhpOffice\PhpSpreadsheet\IOFactory;
$con = new mysqli("localhost", "root", "", "anil");
if ($con->connect_error) {
die("Connection failed: " . $con->connect_error);
}
// Truncate the table to start fresh
$con->query("TRUNCATE student");
$x = $_POST['xfile'];
$i = 0;
try {
$spsheet = IOFactory::load($x);
$spsheet = $spsheet->getActiveSheet();
foreach ($spsheet->getRowIterator() as $row) {
$cellIterator = $row->getCellIterator();
$cellIterator->setIterateOnlyExistingCells(false);
$data = [];
foreach ($cellIterator as $cell) {
$data[] = $cell->getValue();
}
// Skip the first three rows, if necessary

40
 if ($i > 3) {
$con->query("INSERT INTO student (id, cgpa, backlogs) VALUES ('$data[1]',
'$data[2]', '$data[4]')");
}
$i++;
}
// Check for duplicates
$duplicateQuery = "
SELECT id, COUNT(*) as count
FROM student
GROUP BY id
HAVING count > 1;";
$result = $con->query($duplicateQuery);
if ($result->num_rows > 0) {
$dup = "";
while ($row = $result->fetch_assoc()) {
$dup .= $row['id'] . ", ";
}
// Remove the trailing comma and space
$dup = rtrim($dup, ", ");
// Show alert and redirect
echo "<script>
alert('$dup above IDs are repeated');
window.location.href = 'excelinput.html';
</script>";
exit;
} else {

41
 header("Location: teamsizeinput.html");
exit;
}
} catch (\PhpOffice\PhpSpreadsheet\Reader\Exception $e) {
echo 'Error loading file: ', $e->getMessage();
}
$con->close();
?>
Teamsizeinput.php
<?php
require 'vendor/autoload.php'; // Include PhpSpreadsheet
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
$con = new mysqli("localhost", "root", "", "anil");
if ($con->connect_error) {
die("Connection failed: " . $con->connect_error);
}
$no = $con->query("SELECT COUNT(id) AS count FROM student")-
>fetch_assoc()['count'];
$acs = $con->query("SELECT COUNT(id) AS count FROM student WHERE
cgpa>0")->fetch_assoc()['count'];
$ncs = $con->query("SELECT COUNT(id) AS count FROM student WHERE
cgpa=0")->fetch_assoc()['count'];
$size = isset($_POST['size']) ? (int)$_POST['size'] : null;
$nt = isset($_POST['nt']) ? (int)$_POST['nt'] : null;
if ($nt == null) {
$nt = floor($no / $size);

42
}
if ($no < $nt) {
echo "<script>
alert('Students are not enough to make requested team size');
window.location.href = 'teamsizeinput.html';
</script>";
exit;
}
$res = $con->query("SELECT id, cgpa FROM student WHERE cgpa > 0 ORDER BY
cgpa DESC");
$res1 = $con->query("SELECT id, backlogs FROM student WHERE cgpa = 0 ORDER
BY backlogs DESC");
$id = array();
$cgpa = array();
$id1 = array();
$backlogs = array();

while ($row = $res->fetch_assoc()) {

$id[] = $row['id'];
$cgpa[] = $row['cgpa'];
}
while ($row = $res1->fetch_assoc()) {
$id1[] = $row['id'];
$backlogs[] = $row['backlogs'];
}
$k = 0;
$teams = array();

43
$tot = array();
$ts = floor($acs / $nt);
$rem = $acs % $nt;
for ($i = 0; $i < $ts; $i++) {
$f = 0;
for ($j = 0; $j < $nt; $j++) {
if ($i % 2 == 0) {
$teams[$j][$i] = $id[$k];
$tot[$j][$i] = $cgpa[$k];
$k++;
} else {
if ($f == 0) {
$k = $k + $nt - 1;
$f = 1;
}
$teams[$j][$i] = $id[$k];
$tot[$j][$i] = $cgpa[$k];
$k--;
}
}
if ($i % 2 != 0) {
$k = $k + $nt + 1;
}
}
$remain = array();
$remtot = array();
for ($i = 0; $i < $rem; $i++) {

44
 $remain[] = $id[$k];
$remtot[] = $cgpa[$k];
$k = $k + 1;
}
$k = 0;
$ts1 = floor($ncs / $nt);
$rem1 = $ncs % $nt;
for ($i = $ts; $i < $ts + $ts1; $i++) {
$f = 0;
for ($j = 0; $j < $nt; $j++) {
if ($i % 2 == 0) {
$teams[$j][$i] = $id1[$k];
$tot[$j][$i] = $backlogs[$k];
$k++;
} else {
if ($f == 0) {
$k = $k + $nt - 1;
$f = 1;
}
$teams[$j][$i] = $id1[$k];
$tot[$j][$i] = $backlogs[$k];
$k--;
}
}
if ($i % 2 != 0) {
$k = $k + $nt + 1;
}

45
}
for ($i = 0; $i < $rem1; $i++) {
$remain[] = $id1[$k];
$remtot[] = $backlogs[$k];
$k = $k + 1;
}
$remain = array_reverse($remain);
$remtot = array_reverse($remtot);
$k = 0;
$i = $ts + $ts1;
if (sizeof($remain) >= $nt) {
for ($j = 0; $j < $nt; $j++) {
$teams[$j][$i] = $remain[$k];
$tot[$j][$i] = $remtot[$k];
$k++;
}
$i++;
}
$m = $nt - (sizeof($remain) - $k);
for ($j = $nt - 1; $j > $m - 1; $j--) {
$teams[$j][$i] = $remain[$k];
$tot[$j][$i] = $remtot[$k];
$k++;
}
// Display the teams
echo '<html>
<head>

46
<style>
/* Reset default styles */
body {
font-family: Arial, sans-serif;
display: flex;
flex-direction: column;
align-items: center;
background-color: black; /* Light background color */
margin: 0;
padding: 20px; /* Padding for body */
}
/* Team cards styles */
.team-card {
background-color: white; /* Card background color */
border-radius: 8px; /* Rounded corners */
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1); /* Subtle shadow */
padding: 20px; /* Inner padding */
margin: 10px; /* Space between cards */
width: 300px; /* Fixed width for each card */
transition: transform 0.3s; /* Transition for hover effect */
}
.team-card:hover {
transform: translateY(-5px); /* Lift card on hover */
}
/* Team title styles */
.team-card h2 {
text-align: center; /* Center the title */

47
 color: #007bff; /* Primary blue color for the title */
}
/* List styles */
.team-card ul {
list-style-type: none; /* Remove default list styles */
padding: 0; /* Remove padding */
}
.team-card li {
padding: 5px 0; /* Space between list items */
border-bottom: 1px solid #ddd; /* Bottom border for separation */
}
.team-card li:last-child {
border-bottom: none; /* Remove border for the last item */
}
/* Download button styles */
.download-btn {
background-color: #007bff; /* Primary blue color */
border: none; /* Remove default border */
border-radius: 5px; /* Rounded corners */
padding: 10px 20px; /* Padding for the button */
color: white; /* Text color */
font-size: 16px; /* Font size */
cursor: pointer; /* Pointer cursor */
margin-top: 20px; /* Space above the button */
transition: background-color 0.3s, transform 0.2s; /* Transition effects */
outline: none; /* Remove focus outline */
}

48
 .download-btn:hover {
background-color: #0056b3; /* Darker blue on hover */
transform: translateY(-2px); /* Slight lift on hover */
}
.download-btn a {
text-decoration: none; /* Remove underline */
color: white; /* Text color */
}
</style>
</head>
<body>';
for ($i = 0; $i < $nt; $i++) {
echo '<div class="team-card">';
echo "<h2>Team " . ($i + 1) . "</h2>";
echo '<ul>';
for ($j = 0; $j < sizeof($teams[$i]); $j++) {
echo "<li>Student ID: " . $teams[$i][$j] . "</li>";
}
echo '</ul>';
echo '</div>';
}
// Create a new Spreadsheet
$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();
// Set the headers
$sheet->setCellValue('A1', 'Team Number');
$sheet->setCellValue('B1', 'Student ID');

49
$sheet->setCellValue('C1', 'CGPA / Backlogs');
// Fill the spreadsheet with data
$row = 2; // Starting row for data
for ($i = 0; $i < $nt; $i++) {
$sheet->setCellValue('A' . $row, 'Team ' . ($i + 1));
for ($j = 0; $j < sizeof($teams[$i]); $j++) {
$sheet->setCellValue('B' . $row, $teams[$i][$j]);
$sheet->setCellValue('C' . $row, isset($tot[$i][$j]) ? $tot[$i][$j] : '');
$row++;
}
}
// Write the file
$writer = new Xlsx($spreadsheet);
$filename = 'teams.xlsx';
$writer->save($filename);
// Provide download link
echo "<button class='download-btn'><a href='$filename'>Save Teams Excel
File</a></button>";

echo '</body></html>';
$con->close();
?>

50
 CHAPTER 7

TESTING
7.1 GENERAL
The purpose of testing is to discover errors. Testing is the process of trying to discover
every conceivable fault or weakness in a work product. It provides a way to check the
functionality of components, sub assemblies, assemblies and/or a finished product. It is
the process of exercising software with the intent of ensuring that the Software system
meets its requirements and user expectations and does not fail in an unacceptable manner.
There are various types of tests. Each test type addresses a specific testing requirement.

Testing for a Multilevel Data Concealing Technique that integrates Steganography and
Visual Cryptography is crucial to ensure its functionality, security, and reliability. The
testing process involves several stages, including unit testing, integration testing, and
security testing.

7.2 TYPES OF TESTING

Figure 7.1 Types of Testing

51
7.3 TEST CASES

Table 7.2 Test cases

52
 CHAPTER 8

RESULTS

Figure 8.1 Login Page

Figure 8.2 Input type selection page

53
 Figure 8.3 File uploading page

Figure 8.4 Student details input page

54
Figure 8.5 Team size input page

Figure 8.6 Final output page

55
 CHAPTER 9

FUTURE SCOPE
9.1 FUTURE SCOPE
The future scope of this project lies in its potential to evolve and enhance the student
grouping and mentoring process within educational institutions. As the education system
becomes increasingly data-driven, automating processes like student team formation and
faculty guide allocation can significantly improve operational efficiency, academic
outcomes, and faculty-student interactions.
One potential future development is the integration of machine learning and predictive
analytics to optimize the batch formation process further. By analyzing historical data,
such as student performance, learning styles, and engagement levels, the system could
predict the most effective group compositions, ensuring balanced and productive study
groups. This would enhance collaborative learning and better align students with mentors
who suit their learning needs.
Additionally, real-time data processing could be incorporated to handle dynamic
academic environments. For example, if a student’s academic performance or status
changes mid-semester (e.g., a backlog is cleared or a new exam score is added), the
system could automatically reassign the student to a new batch or group. This would
ensure that the student always remains in an optimal learning group, adjusting based on
their academic progression.
The project can also expand to include cross-institutional collaboration. Institutions
can share data on best practices for batch formation, allowing for shared insights into
what batch compositions work best across various disciplines. Moreover, adding a
feedback mechanism where both students and faculty provide input on the batch
formation process and mentorship would allow continuous improvement of the system.

56
Another key aspect of future development is scalability. As educational institutions
expand, the system should be able to accommodate a larger pool of students and faculty,
making it suitable for large universities or multi-campus organizations. This scalability
can be achieved through cloud computing and efficient database management systems.
Ultimately, this project has the potential to revolutionize the way educational institutions
approach student collaboration, batch creation, and mentorship, improving academic
performance and fostering a more engaging, personalized learning experience.

57
 CHAPTER 10

CONCLUSION
In conclusion, this project effectively addresses the critical challenge of organizing
students into optimized study groups or batches within educational institutions. By
automating the process of team formation based on student academic records and faculty
expertise, the project streamlines administrative tasks, fosters academic collaboration,
and ensures that students are placed in well-balanced, high-performing groups. The use
of student data, including marks, CGPA, and backlogs, allows for an efficient grouping
mechanism that enhances the quality of education and mentorship.

The project significantly reduces the manual effort involved in batch creation and ensures
that students are placed in batches where their academic performance is balanced, leading
to better peer interactions and collaborative learning. By separating students with
backlogs into dedicated groups, the system ensures that they receive the necessary
support to improve their performance, while students without backlogs are grouped
together for a more advanced academic experience.

Additionally, the automated faculty guide allocation based on domain expertise further
strengthens the mentorship system, ensuring that students receive guidance from
qualified and experienced mentors aligned with their academic needs. This enhances the
overall educational experience by promoting effective learning and fostering strong
mentor-mentee relationships.

58
 CHAPTER 11

REFERENCES
1. Jain, S., & Verma, H. (2014). Automation of Student Team Formation System: A Case
Study. International Journal of Computer Applications, 97(10), 1-5.
This paper discusses the automation of student team formation based on academic
performance and course preferences.
2. Hassan, M. A., & Dey, A. (2019). A Data-Driven Approach to Assigning Students to
Learning Groups Based on Performance and Interests. Journal of Educational
Technology & Society, 22(1), 68-79.
Explores data-driven methods for forming student groups in a way that promotes better
learning outcomes.
3. Almalki, M., & Othman, M. (2018). Student-Teacher Matching Algorithm for Course
Selection Using Genetic Algorithm. Computers in Human Behavior, 82, 150-160.
Discusses the use of algorithms for student-teacher matching based on academic needs
and domain expertise.
4. Williams, S., & Stevens, R. (2017). Enhancing Collaborative Learning through Group
Formation: A Review of the Literature. Educational Research Review, 15, 121-135.
This review highlights the importance of strategic group formation for collaborative
learning in educational environments.
5. Salama, M., & Badran, M. (2015). A Hybrid Model for Grouping Students in
Educational Systems. Proceedings of the International Conference on Computing,
Communication, and Control Technologies, 30-35.
Describes hybrid models that combine different criteria for grouping students to
achieve balanced teams.
6. Kumar, R., & Soni, A. (2016). Data Management Techniques for Efficient Faculty
and Student Allocations in Higher Education. International Journal of Database

59
 Management Systems, 8(4), 18-29.
Provides insights into data management systems for optimizing student and faculty
allocation in academic institutions.
7. Baker, R. S. J. D., & Inventado, P. S. (2014). Educational Data Mining and Learning
Analytics. In Learning Analytics (pp. 61-75). Springer, New York, NY.
An essential reference for understanding how educational data mining and analytics
can be applied to automate processes like student grouping and performance analysis.
8. Liu, M., & McCauley, R. (2020). Faculty Allocation and Student Grouping in Online
Learning Systems: A Review of Strategies and Techniques. Online Learning Journal,
24(3), 10-25.
This article explores various strategies for faculty and student group assignments in
online learning environments.
9. Khan, I., & Khan, F. (2017). Predictive Analytics in Educational Systems: A Review.
International Journal of Educational Research, 85, 43-56.
Reviews the use of predictive analytics in education, including how performance data
can influence group formation and mentorship.
10.Dastbaz, M., & Lishchuk, V. (2019). Using Learning Management Systems to
Facilitate Grouping and Collaboration: A Case Study Approach. Journal of
Educational Technology Development and Exchange, 12(2), 40-51.

60