A Micro Project report on

FEE COLLECTION SYSTEM

Submitted to the CMR Institute of Technology in partial fulfilment of the requirement for
the award of the Laboratory of

PROBLEM SOLVING WITH C PROGRAMMING

Of I-B. Tech I-Semester in

FRESHMAN ENGINEERING DEPARTMENT

Submitted by

[Link] 24R01A66D
[Link] 24R01A66D6
[Link] 24R01A66D7
[Link] 24R01A66D8
[Link] sai 24R01A66D9
[Link] 24R01A66E0
[Link] 24R01A66K0
Under the Guidance Of
Mrs. G. Lakshmi Praveena
(Assistant professor)
H & S Department

CMR INSTITUTE OF TECHNOLOGY

(UGC AUTONOMUS)
(Approved by AICTE, Affiliated to JNTU, Kukatpally, Hyderabad)

2024-2025
Page 1 of 29
 CMR INSTITUTE OF TECHNOLOGY
(UGC AUTONOMUS)
(Approved by AICTE, Affiliated to JNTU, Kukatpally, Hyderabad)
Kandlakoya, Medchal Road, Hyderabad

2024-2025
CMR INSTITUTE OF TECHNOLOGY
(UGC AUTONOMUS)
(Approved by AICTE, Affiliated to JNTU, Kukatpally, Hyderabad, 501401)
Kandlakoya , Medchal Road, Hyderabad

CERTIFICATE

This is to certify that a Micro Project entitled with “FEE COLLECTION SYSTEM” is
being
Submitted By
[Link] 24R01A66D5
[Link] 24R01A66D6
[Link] 24R01A66D7
[Link] 24R01A66D8
[Link] sai 24R01A66D9
[Link] 24R01A66E0
[Link] 24R01A66K0
In partial fulfilment of the requirement for award of the ‘FEE COLLECTION SYSTEM’ of [Link] I-
Semester in Freshman Engineering towards a record of a bonafide work carried out under our guidance and
supervision.

Signature of Faculty Signature of HOD

[Link] praveena [Link] Krishna Reddy
( Asst. prof, CSE Dept) (Assoc. Prof, H&S Dept)

Page 2 of 29
 ACKNOWLEDGEMENT

We are extremely grateful to Dr . M. Janga Reddy, Director. Dr

.[Link] Rao, Principal and Dr .Radha Krishna Reddy,
Head of Department, Freshman Engineering Department,
CMR Institute of Technology for their inspiration and valuable
guidance during entire duration.

We are extremely thankful to our Mrs . [Link] praveena,

(Assistant professor, H&S Department) CMR Institute of
Technology for her constant guidance, encouragement and moral
support throughout the project. We express our thanks to all staff
members and friends for all the help and coordination extended in
bringing out this project successfully in time. Finally, we are very
much thankful to our parents and relatives who guided directly or
indirectly for successful completion of the project.

[Link] 24R01A66D5
[Link] 24R01A66D6
[Link] 24RO1A66D7
[Link] 24R01A66D8
[Link] sai 24R01A66D9
[Link] 24R01A66E0
[Link] 24R01A66K0

Page 3 of 29
 INDEX
[Link]. CONTENTS PAGE NO.
5
1. ABSTRACT
6-7
2. INTRODUCTION

8
3. SYSTEM
REQUIREMENTS

EXPLANATION OF THE 9-10

4. CONCEPTS USED IN PROGRAM

11-13
5. ALGORITHM

14-22
6. SOURCE CODE

22-24
7. OUTPUT

ADVANTAGES AND 25-28

8. DISADVANTAGES

29
9. CONCLUSION

Page 4 of 29
 Abstract

The Fee Collection System Program is a comprehensive and

user-friendly computer-based application designed to automate
the process of collecting and managing student fees and
payments. The program provides a centralized platform for
administrators to manage student records, fee structures, and
payment information, thereby streamlining the fee collection
process and improving efficiency. The program is designed using
a modular approach, with each module responsible for a
specific function. The program uses a database to store and
retrieve data, and provides a user-friendly interface for
administrators to interact with the system. The program
provides a centralized platform for administrators to manage
student records, fee structures, and payment information,
thereby streamlining the fee collection process and improving
efficiency.

Page 5 of 29
 Introduction
In today's digital age, manual fee collection systems are
becoming increasingly outdated and inefficient. Educational
institutions, in particular, require a reliable and organized
system to manage student fees and payments. To address this
need, we have developed a fee collection system program that
provides a simple, efficient, and secure way to manage student
fees and payments.

Background
The fee collection system program is designed to automate the
process of collecting and managing student fees and payments.
The program provides a user-friendly interface that allows
administrators to easily add, delete, and modify student
records, fee structures, and payment information. The program
also provides options to display student, fee, and payment
information, making it easy to track and manage data. Manual
fee collection systems are often time-consuming, prone to
errors, and difficult to manage. Educational institutions require a
reliable and organized system to manage student fees and
payments, including tracking payments, generating receipts, and
sending reminders. The fee collection system program is
designed to address these needs and provide a simple, efficient,
and secure way to manage student fees and payments.

Page 6 of 29
 Objective
The objective of the fee collection system program is to provide
a reliable, efficient, and secure way to manage student fees and
payments.

The program aims to:

1. Simplify the fee collection process
2. Reduce errors and discrepancies
3. Provide timely and accurate information to administrators
and students
4. Improve communication between administrators, students,
and parents
5. Enhance the overall efficiency and effectiveness of the fee
collection process

Page 7 of 29
 System Requirements:

Hardware Requirements:
1. Processor: Intel Core i3 or equivalent
2. RAM: 4 GB or more
3. Hard Disk: 500 GB or more
4. Display: 1024x768 pixels or higher
5. Keyboard and Mouse: Standard keyboard and mouse

Software Requirements:
1. Operating System: Windows 10 or Linux (Ubuntu or
equivalent)
2. Compiler: GCC (GNU Compiler Collection) or equivalent
3. Programming Language: C
4. Runtime Environment: C Runtime Environment (CRT)

Page 8 of 29
 Explanation of the concepts used in the fee
collection system program

Data Structures
- Arrays: Used to store student, fee, and payment information.
Arrays are a collection of elements of the same data type stored
in contiguous memory locations.
- Structures: Used to represent student, fee, and payment data.
Structures are a collection of variables of different data types
that can be stored together in memory.

Control Structures
- If-Else Statements: Used to make decisions based on
conditions. If-else statements are used to execute different
blocks of code based on whether a condition is true or false.
- Switch Statements: Used to handle multiple cases. Switch
statements are used to execute different blocks of code based
on the value of a variable.
- Loops: Used to repeat a block of code. Loops are used to
iterate over a block of code repeatedly until a condition is met.
Functions

Page 9 of 29
- User-Defined Functions: Used to perform specific tasks. User-
defined functions are blocks of code that can be called multiple
times from different parts of the program.
- Function Arguments: Used to pass data to functions. Function
arguments are variables that are passed to a function when it is
called.

Input/Output Operation
- scanf(): Used to read input from the user. scanf() is a function
that reads input from the standard input device (usually the
keyboard) and stores it in variables.
- printf(): Used to display output to the user. printf() is a function
that displays output to the standard output device (usually the
screen).

Memory Management
- Static Memory Allocation: Used to allocate memory for
variables. Static memory allocation is a technique where
memory is allocated for variables at compile-time.

Programming Paradigms
- Procedural Programming: Used to write the program.
Procedural programming is a paradigm where the program is
divided into procedures or functions that perform specific tasks.

Page 10 of 29
 Algorithm

Step 1: Initialize Variables

- Initialize arrays to store student, fee, and payment information
- Initialize counters for students, fees, and payments

Step 2: Display Menu

- Display a menu with options to add student, add fee, make
payment, display student information, display fee information,
display payment information, and exit

Step 3: Handle User Input

- Get user input for the chosen option
- Use a switch statement to handle different option.
Step 4: Add Student
- Get student ID, name, roll number, class, and year of study
from the user
- Store the student information in the student array
- Increment the student counter

Page 11 of 29
Step 5: Add Fee
- Get fee ID, fee type, fee amount, due date, and late fee from
the user
- Store the fee information in the fee array
- Increment the fee counter

Step 6: Make Payment

- Get student ID, fee ID, payment amount, payment date, and
payment mode from the user
- Store the payment information in the payment array
- Increment the payment counter
Step 7: Display Student Information
- Display the student ID, name, roll number, class, and year of
study for each student

Step 8: Display Fee Information

- Display the fee ID, fee type, fee amount, due date, and late fee
for each fee

Step 9: Display Payment Information

- Display the payment ID, student ID, fee ID, payment amount,
payment date, and payment mode for each payment

Page 12 of 29
Step 10: Exit
- Exit the program when the user chooses the exit option

Data Structures
- Arrays to store student, fee, and payment information
- Structures to represent student, fee, and payment data

Time Complexity
- O(1) for adding student, fee, and payment information
- O(n) for displaying student, fee, and payment information,
where n is the number of students, fees, or payments.

Page 13 of 29
 Source code

#include <stdio.h>
#include <string.h>

// Structure to store student information

struct Student {
int student_id;
char name[50];
char roll_number[20];
char class[10];
int year_of_study;
};

// Structure to store fee information

struct Fee {
int fee_id;
char fee_type[20];
float fee_amount;
char due_date[10];
float late_fee;
Page 14 of 29
};

// Structure to store payment information

struct Payment {
int payment_id;
int student_id;
int fee_id;
float payment_amount;
char payment_date[10];
char payment_mode[20];
};

// Function to add a new student

void add_student(struct Student students[], int *student_count)
{
printf("Enter student ID: ");
scanf("%d", &students[*student_count].student_id);
printf("Enter student name: ");
scanf("%s", students[*student_count].name);
printf("Enter roll number: ");
scanf("%s", students[*student_count].roll_number);
printf("Enter class: ");
Page 15 of 29
 scanf("%s", students[*student_count].class);
printf("Enter year of study: ");
scanf("%d", &students[*student_count].year_of_study);
(*student_count)++;
}

// Function to add a new fee

void add_fee(struct Fee fees[], int *fee_count)
{
printf("Enter fee ID: ");
scanf("%d", &fees[*fee_count].fee_id);
printf("Enter fee type: ");
scanf("%s", fees[*fee_count].fee_type);
printf("Enter fee amount: ");
scanf("%f", &fees[*fee_count].fee_amount);
printf("Enter due date: ");
scanf("%s", fees[*fee_count].due_date);
printf("Enter late fee: ");
scanf("%f", &fees[*fee_count].late_fee);
(*fee_count)++;
}

Page 16 of 29
// Function to make a payment
void make_payment(struct Payment payments[], int
*payment_count, struct Student students[], int student_count,
struct Fee fees[], int fee_count) {
int student_id, fee_id;
printf("Enter student ID: ");
scanf("%d", &student_id);
printf("Enter fee ID: ");
scanf("%d", &fee_id);
for (int i = 0; i < student_count; i++) {
if (students[i].student_id == student_id) {
for (int j = 0; j < fee_count; j++) {
if (fees[j].fee_id == fee_id) {
printf("Enter payment amount: ");
scanf("%f",
&payments[*payment_count].payment_amount);
printf("Enter payment date: ");
scanf("%s",
payments[*payment_count].payment_date);
printf("Enter payment mode: ");
scanf("%s",
payments[*payment_count].payment_mode);
Page 17 of 29
 payments[*payment_count].student_id =
student_id;
payments[*payment_count].fee_id = fee_id;
(*payment_count)++;
break;
}
}
break;
}
}
}

// Function to display all information

//display student details
void display_student(struct Student students[], int
student_count)
{
printf("Student Information:\n");
for (int i = 0; i < student_count; i++) {
printf("Student ID: %d\n", students[i].student_id);
printf("Name: %s\n", students[i].name);
printf("Roll Number: %s\n", students[i].roll_number);
Page 18 of 29
 printf("Class: %s\n", students[i].class);
printf("Year of Study: %d\n\n", students[i].year_of_study);
}
}
// Function to display fee information
void display_fee(struct Fee fees[], int fee_count) {
printf("Fee Information:\n");
for (int i = 0; i < fee_count; i++) {
printf("Fee ID: %d\n", fees[i].fee_id);
printf("Fee Type: %s\n", fees[i].fee_type);
printf("Fee Amount: %.2f\n", fees[i].fee_amount);
printf("Due Date: %s\n", fees[i].due_date);
printf("Late Fee: %.2f\n\n", fees[i].late_fee);
}
}
// display payment details.
void display_payment(struct Payment payments[], int
payment_count) {
printf("Payment Information:\n");
for (int i = 0; i < payment_count; i++) {
printf("Payment ID: %d\n", payments[i].payment_id);
printf("Student ID: %d\n", payments[i].student_id);
Page 19 of 29
 printf("Fee ID: %d\n", payments[i].fee_id);
printf("Payment Amount: %.2f\n",
payments[i].payment_amount);
printf("Payment Date: %s\n", payments[i].payment_date);
printf("Payment Mode: %s\n\n",
payments[i].payment_mode);
}
}

int main() {
struct Student students[100];
struct Fee fees[100];
struct Payment payments[100];
int student_count = 0, fee_count = 0, payment_count = 0;

printf("1. Add Student\n");

printf("2. Add Fee\n");
printf("3. Make Payment\n");
printf("4. Display Student Information\n");
printf("5. Exit\n\n");
int choice;
do {
Page 20 of 29
 printf("\nEnter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
add_student(students, &student_count);
break;
case 2:
add_fee(fees, &fee_count);
break;
case 3:
make_payment(payments, &payment_count, students,
student_count, fees, fee_count);
break;
case 4:
display_student(students, student_count);
display_fee(fees, fee_count);
display_payment(payments, payment_count);
break;
case 5:
printf("Thanks for using this code.... \n");
break;
}
Page 21 of 29
 } while (choice != 7);
return 0;
}

Sample output

$ 1. Add Student
$ 2. Add Fee
$ 3. Make Payment
$ 4. Display Student Information
$ 5. Exit
$
$
$ Enter your choice: 1
$ Enter student ID: 12
$ Enter student name: anupam
$ Enter roll number: 66zz
$ Enter class: csm
$ Enter year of study: 1
$
$ Enter your choice: 2
$ Enter fee ID: 21
Page 22 of 29
$ Enter fee type: hostel
$ Enter fee amount: 20000
$ Enter due date: 10
$ Enter late fee: 00
$
$ Enter your choice: 3
$ Enter student ID: 12
$ Enter fee ID: 21
$ Enter payment amount: 2000
$ Enter payment date: 03
$ Enter payment mode: Gpay
$
$ Enter your choice: 4
$ Student Information:
$ Student ID: 12
$ Name: anupam
$ Roll Number: 66zz
$ Class: csm
$ Year of Study: 1
$
$ Fee Information:

Page 23 of 29
$ Fee ID: 21
$ Fee Type: hostel
$ Fee Amount: 20000.00
$ Due Date: 10
$ Late Fee: 0.00
$
$ Payment Information:
$ Payment ID: 0
$ Student ID: 12
$ Fee ID: 21
$ Payment Amount: 2000.00
$ Payment Date: 03
$ Payment Mode: Gpay
$
$
$ Enter your choice: 5
$ Thanks for using this code....

Page 24 of 29
 Advantages

1. Easy to Use: The program has a simple and intuitive menu-

driven interface that makes it easy to use, even for those who
are not tech-savvy.

2. Efficient Data Management: The program uses arrays and

structures to store and manage data efficiently, making it easy
to add, delete, and modify records.

3. Fast Data Retrieval: The program allows for fast data

retrieval, making it easy to display student, fee, and payment
information.

4. Accurate Calculations: The program performs accurate

calculations for payment amounts and late fees, reducing the
risk of human error.

5. Secure Data Storage: The program stores data in a secure

and organized manner, making it easy to protect sensitive
information.

Page 25 of 29
6. Scalability: The program can be easily scaled up or down to
accommodate changing needs, making it a flexible solution for
fee collection.

7. Cost-Effective: The program is a cost-effective solution for fee

collection, eliminating the need for manual record-keeping and
reducing the risk of errors.

8. Improved Record-Keeping: The program provides a

centralized and organized system for record-keeping, making it
easy to track and manage student, fee, and payment
information.

9. Enhanced Transparency: The program provides a transparent

system for fee collection, making it easy for students and
administrators to track payments and fees.

10. Reduced Administrative Burden: The program reduces the

administrative burden associated with fee collection, freeing up
staff to focus on other important tasks.

Page 26 of 29
 Disadvantages

1. Limited User Access: The program does not have a user

authentication system, which means that anyone can access and
modify the data.

2. No Data Validation: The program does not validate user

input, which means that incorrect or invalid data can be entered
into the system.

3. No Error Handling: The program does not have error handling

mechanisms, which means that it may crash or produce
unexpected results if an error occurs.

4. Limited Scalability: The program uses arrays to store data,

which means that it may not be able to handle large amounts of
data.

5. No Data Encryption: The program does not encrypt data,

which means that sensitive information such as student names
and payment amounts may be vulnerable to unauthorized
access.

Page 27 of 29
6. No Audit Trail: The program does not maintain an audit trail,
which means that it may be difficult to track changes to the
data.

7. Limited Reporting Capabilities: The program does not have

built-in reporting capabilities, which means that administrators
may need to manually generate reports.

8. No Integration with Other Systems: The program does not

integrate with other systems, such as student information
systems or accounting software.

9. Limited User Interface: The program has a simple text-based

user interface, which may not be user-friendly for some users.

10. No Backup and Recovery Mechanisms: The program does

not have built-in backup and recovery mechanisms, which
means that data may be lost in the event of a system failure

Page 28 of 29
 Conclusion
The fee collection system program is a simple and efficient
solution for managing student fees and payments. The program
uses arrays and structures to store and manage data, making it
easy to add, delete, and modify records. The program also uses
user-defined functions to perform specific tasks, making the
code more organized and reusable.

The program provides a menu-driven interface that makes it

easy to use, even for those who are not tech-savvy. The program
also provides options to display student, fee, and payment
information, making it easy to track and manage data.

Overall, the fee collection system program is a useful tool for

managing student fees and payments. It is easy to use, efficient,
and provides a simple and organized way to manage data.

Page 29 of 29