PROJECT REPORT

On
“ Inventory Management System ”
[DSA Post-Lab]

Submitted By
Harsh Buwade
(CS23048)

Guided By:-
Mr. Ratnesh Choudhary

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

S. B. JAIN INSTITUTE OF TECHNOLOGY

MANAGEMENT AND RESEARCH, NAGPUR.
(An Autonomous Institute, Affiliated to RTMNU, Nagpur)

2024-2025

© S.B.J.I.T.M.R Nagpur 2024

1
 S.B. JAIN INSTITUTE OF TECHNOLOGY MANAGEMENT AND
RESEARCH, NAGPUR
(An Autonomous Institute, Affiliated to RTMNU, Nagpur)
DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING
SESSION 2024-2025

CERTIFICATE
This is to certify that the Mini Project titled “Inventory Management System” is a
bonafide work of Harsh Buwade carried out for the partial fulfillment of course work of

“Data Structure & Algorithm Lab”, 3 Semester, Bachelor of Technology in Computer

rd

Science & Engineering, S. B. Jain Institute of Technology, Management &

Research, Nagpur.

Mr.Ratnesh K. Choudhary Dr.Mrudula Nimbarte

Assistant Professor Head of Department
(Project Guide)

2
 INDEX

CERTIFICATE i

INDEX ii

LIST OF FIGURES iii

CHAPTER 1 INTRODUCTION 5

CHAPTER 2 METHODOLOGY 6-7

CHAPTER 3 TOOLS/PLATFORMS 8-9

CHAPTER 4 DESIGN & IMPLEMENTATION 10-18

4.1 ALGORITHM

4.2 FLOWCHART

4.3 SOURCE CODE

CHAPTER 5 RESULT & DISCUSSION 19-26

5.1 OUTPUT

5.2 DISCUSSION

5.3 APPLICATION

CHAPTER 6 CONCLUSION 27

REFERENCES

3
 LIST OF FIGURES

FIG. NO. TITLE OF FIGURE PAGE NO.

1 INTRODUCTION
5

2 METHODOLOGY
6- 7

3 TOOLS/PLATFORMS
8- 9

4 DESIGN & IMPLEMENTATION

10- 18

5 RESULT & DISCUSSION

19- 26

6 CONCLUSION
27

4
 CHAPTER 1

INTRODUCTION:
Introduction to the Inventory Management System Project:

The Inventory Management System is a C-based software application designed to

efficiently handle various aspects of inventory control for a business. This program
facilitates the management of a product inventory by providing functionalities to add
new items, remove existing items, update stock quantities, and display the current
inventory. Additionally, it includes calculations for order quantities, transportation
costs, and labor costs.

Key Features:

1. Add Item: Users can add new items to the inventory by specifying an ID,
name, stock quantity, and price. This function ensures that the inventory does
not exceed a predefined maximum capacity.
2. Remove Item: Allows users to remove items from the inventory based on
their unique ID. If the item is found, it is deleted and subsequent items are
shifted to maintain a contiguous list.
3. Update Stock: Users can modify the stock quantity of existing items, either
increasing or decreasing the stock as needed. The system checks for the item's
presence before making updates.
4. Display Inventory: Provides a summary of all items currently in the
inventory, including their ID, name, stock level, and price.
5. Calculate Order Quantity: Computes the required quantity of items to order
based on a specified reorder level. This helps in maintaining optimal stock
levels and preventing stockouts.
6. Calculate Transportation Cost: Calculates the cost of transporting items
based on distance, quantity, and rate per kilometer. This feature aids in
budgeting for logistics expenses.
7. Calculate Labor Cost: Computes the labor cost associated with handling a
given quantity of items, based on a specified labor rate per unit.

The system is built using a static array for inventory storage, avoiding the
complexities associated with dynamic memory management. This simplifies the
implementation while ensuring that the system can handle up to a maximum number
of items efficiently. The user interacts with the system through a text-based menu,
making it straightforward to perform inventory-related tasks.
5
 CHAPTER 2

METHODOLOGY
The development and implementation of the Inventory Management System (IMS) follow a
structured methodology that encompasses the design, coding, testing, and evaluation phases. This
approach ensures that the system effectively meets the needs of users and performs its intended
functions efficiently.

1. Requirements Analysis

Objective: Define the core functionalities and requirements of the IMS based on user needs and
business objectives.

• Tasks: Gather requirements for managing inventory, including adding/removing items,

updating stock levels, and calculating costs.
• Output: A clear set of specifications outlining the system's features and functionalities.

2. System Design

Objective: Create a design blueprint for the IMS that includes data structures, algorithms, and user
interface elements.

• Tasks:
o Data Structures: Design the Item structure to store item details such as ID, name,
stock, and price.
o Algorithms: Develop algorithms for inventory operations (e.g., adding/removing
items, updating stock) and cost calculations (e.g., transportation, labor).
o User Interface: Design a menu-driven interface for user interactions, allowing users
to choose operations and input data.
• Output: A detailed design document that specifies how the system will function and how
user interactions will be handled.

3. Implementation

Objective: Translate the design into executable code using the C programming language.

• Tasks:
o Coding: Write code to implement the functionalities defined in the design,
including memory management, user input handling, and operations on inventory.
o Integration: Ensure that all components work together seamlessly, such as linking
user inputs with appropriate inventory operations and calculations.
• Output: A fully functional IMS program written in C, capable of performing all specified
tasks.
6
4. Testing

Objective: Verify that the IMS operates correctly and meets all requirements through rigorous
testing.

• Tasks:
oUnit Testing: Test individual functions (e.g., adding/removing items, updating
stock) to ensure they work as expected.
o Integration Testing: Test the interaction between different components (e.g., how
the menu system handles various user inputs).
o System Testing: Conduct end-to-end testing to verify that the complete system
performs all required operations accurately.
• Output: A tested and validated IMS that is free of critical bugs and performs its intended
functions.

5. Evaluation and Enhancement

Objective: Assess the performance and usability of the IMS and identify areas for improvement.

• Tasks:
o
User Feedback: Collect feedback from users to identify any usability issues or
additional feature requests.
o Performance Analysis: Evaluate the system's performance, including memory
usage and response times.
o Enhancements: Implement improvements based on feedback and performance
analysis, such as adding advanced features or refining the user interface.
• Output: An optimized IMS that meets user needs more effectively and operates efficiently.

This methodology ensures a systematic approach to developing the IMS, from initial concept
through to a functional, user-tested system, while providing a clear path for future enhancements
and optimizations.

7
 CHAPTER 3

TOOLS/PLATFORMS

3.1 SOFTWARE REQUIREMENT:

Development Software Requirements

1. Integrated Development Environment (IDE):

Dev-C++: A lightweight IDE for C/C++ development. It includes a compiler and a debugger,
making it suitable for small to medium-sized projects.

Code::Blocks: Another popular C/C++ IDE that offers more features and is highly configurable.

Visual Studio Code: A versatile code editor with support for C/C++ through extensions.

2. Compiler:

GCC (GNU Compiler Collection): A widely-used compiler for C/C++. It can be used through
command-line interfaces or integrated into an IDE like Dev-C++ or Code::Blocks.

MinGW (Minimalist GNU for Windows): A distribution of GCC for Windows. It includes a set of
open-source programming tools.

3. Version Control System:

Git: Useful for tracking changes in your code and collaborating with others. Platforms like
GitHub or GitLab can be used to host repositories.

4. Libraries and Dependencies:

Standard C Library: This project mainly relies on the standard C library, which is included with the
compiler.

Additional libraries may be needed if you plan to expand the project with features like a graphical
user interface (GUI) or database connectivity.

Operating System

Windows 10/11: Suitable for running the development environment and tools mentioned.

-Linux: Offers a great environment for C/C++ development with built-in support for GCC.
8
- macOS: Compatible with most C/C++ development tools.

Additional Tools (Optional)

1. Database Management System (DBMS):

- If you plan to extend the project to include persistent storage of data, consider using a
lightweight database like SQLite.

2. Debugging Tools:

-GDB (GNU Debugger): Comes with GCC and helps debug C/C++ applications.

- IDEs like Dev-C++ and Code::Blocks have built-in debugging capabilities.

3. Build Automation Tools:

- Make: Automates the build process, useful for managing project dependencies and compiling
code.

4. Text Editors:

Notepad++ or Sublime Text: Lightweight text editors that can be used for editing code and
configuration files.

Recommendations for Setup

Installation: Ensure that all tools and libraries are properly installed and configured. This may
involve setting environment variables, especially for the compiler and tools like Git.

- Testing: Regularly test your code using built-in tools in your chosen IDE to ensure functionality.

- Backup and Version Control: Use Git for version control to manage changes and collaborate
effectively.

By setting up this software stack, you'll be well-equipped to develop and run the Cab Management
System, ensuring an efficient and streamlined development process.

9
 CHAPTER 4

DESIGN & IMPLEMENTATION

4.1 ALGORITHM

1. Initialize Inventory System

o Declare a static array inventory of type Item with a size of MAX_ITEMS.
o Initialize size to 0 to keep track of the number of items in the inventory.
2. Display Menu
o Print the menu options:
1. Add item
2. Remove item
3. Update stock
4. Display inventory
5. Calculate order quantity
6. Calculate transportation cost
7. Calculate labor cost
8. Exit
3. Process User Choice
o Continuously display the menu until the user chooses to exit.
4. Add Item
o Check if the inventory is full (size >= MAX_ITEMS).
▪ If full, print an error message and return.
o Prompt the user to enter item details (ID, name, stock, price).
o Add the new item to the inventory at the current size index.
o Increment the size by 1.
o Print a success message.
5. Remove Item
o Prompt the user to enter the ID of the item to remove.
o Search for the item with the given ID in the inventory.
▪ If found, remove the item by shifting subsequent items left and decrementing
the size by 1.
▪ Print a success message.
▪ If not found, print an error message.
6. Update Stock
o Prompt the user to enter the ID of the item to update and the quantity to add/remove.
o Search for the item with the given ID in the inventory.

10
 ▪ If found, update the item’s stock by adding the quantity.
▪ Print a success message.
▪ If not found, print an error message.
7. Display Inventory
o Check if the inventory is empty (size == 0).
▪ If empty, print a message indicating the inventory is empty.
o Otherwise, print the details of all items in the inventory (ID, name, stock, price).
8. Calculate Order Quantity
o Prompt the user to enter the ID of the item and the reorder level.
o Search for the item with the given ID in the inventory.
▪ If found, calculate the order quantity needed to reach the reorder level
(reorder level - current stock).
▪ Print the calculated order quantity.
▪ If not found, print an error message.
9. Calculate Transportation Cost
o Prompt the user to enter the distance, quantity, and transportation rate.
o Calculate the transportation cost using the formula: distance * quantity *
rate.
o Print the calculated transportation cost.
10. Calculate Labor Cost
o Prompt the user to enter the quantity and labor rate.
o Calculate the labor cost using the formula: quantity * laborRate.
o Print the calculated labor cost.
11. Exit
o Print a message indicating that the system is exiting.
12. Cleanup
o No dynamic memory management is required in this version, as the inventory is
handled using a static array.

11
4.2 FLOWCHART:

12
4.3 SOURCE CODE:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>

struct Driver {
char name[50];
char phoneNumber[15];
char carModel[50];
char carNumber[20];
char permitCertificate[30];
char drivingLicense[30];
bool available;
struct Driver* next;
};

struct Customer {
char name[50];
char phoneNumber[15];
char pickupPoint[100];
char dropPoint[100];
int otp;
bool cabBooked;
struct Driver* assignedDriver;
struct Customer* next;
};

float calculateFare(float distance) {

float farePerKm = 13.0;
return farePerKm * distance;
}

int generateOTP() {
srand(time(NULL));
return rand() % 9000 + 1000;
}

void addDriver(struct Driver** head) {

13
 struct Driver* newDriver = (struct Driver*)malloc(sizeof(struct Driver));

printf("\nEnter driver details:\n");

printf("Name: ");
scanf("%s", newDriver->name);
printf("Phone number: ");
scanf("%s", newDriver->phoneNumber);
printf("Car model: ");
scanf("%s", newDriver->carModel);
printf("Car number: ");
scanf("%s", newDriver->carNumber);
printf("Permit Certificate number: ");
scanf("%s", newDriver->permitCertificate);
printf("Driving License number: ");
scanf("%s", newDriver->drivingLicense);
newDriver->available = true;
newDriver->next = *head;
*head = newDriver;

printf("Driver registered successfully!\n");

}

void displayDrivers(struct Driver* head) {

struct Driver* temp = head;
printf("\nRegistered Drivers:\n");
while (temp != NULL) {
printf("Driver: %s, Phone: %s, Car: %s %s, Permit: %s, License: %s, Available: %s\n",
temp->name, temp->phoneNumber, temp->carModel, temp->carNumber, temp-
>permitCertificate, temp->drivingLicense,
temp->available ? "Yes" : "No");
temp = temp->next;
}
}

void addCustomer(struct Customer** head) {

struct Customer* newCustomer = (struct Customer*)malloc(sizeof(struct Customer));

printf("\nEnter customer details:\n");

printf("Name: ");
scanf("%s", newCustomer->name);
printf("Phone number: ");
14
 scanf("%s", newCustomer->phoneNumber);
printf("Pickup point: ");
scanf("%s", newCustomer->pickupPoint);
printf("Drop point: ");
scanf("%s", newCustomer->dropPoint);
newCustomer->cabBooked = false;
newCustomer->assignedDriver = NULL;
newCustomer->next = *head;
*head = newCustomer;

printf("Customer registered successfully!\n");

}

void displayCustomers(struct Customer* head) {

struct Customer* temp = head;
printf("\nRegistered Customers:\n");
while (temp != NULL) {
printf("Customer: %s, Phone: %s, Pickup: %s, Drop: %s, Cab booked: %s\n",
temp->name, temp->phoneNumber, temp->pickupPoint, temp->dropPoint,
temp->cabBooked ? "Yes" : "No");
temp = temp->next; }}

void bookCab(struct Driver* driverHead, struct Customer* customerHead) {

if (driverHead == NULL || customerHead == NULL) {
printf("No customers or drivers registered yet!\n");
return; }

printf("Select a customer:\n");
struct Customer* tempCustomer = customerHead;
int customerIndex = 1;

while (tempCustomer != NULL) {

if (!tempCustomer->cabBooked) {
printf("Customer %d: %s, Phone: %s\n", customerIndex, tempCustomer->name,
tempCustomer->phoneNumber);
}
tempCustomer = tempCustomer->next;
customerIndex++;
}

int customerChoice;
15
 printf("Enter customer number: ");
scanf("%d", &customerChoice);

tempCustomer = customerHead;
for (int i = 1; i < customerChoice && tempCustomer != NULL; i++) {
tempCustomer = tempCustomer->next;
}

if (tempCustomer != NULL && !tempCustomer->cabBooked) {

printf("\nAvailable Drivers:\n");
struct Driver* availableDriver = NULL;
struct Driver* tempDriver = driverHead;
int driverIndex = 1;

while (tempDriver != NULL) {

if (tempDriver->available) {
printf("Driver %d: %s, Phone: %s, Car: %s %s\n",
driverIndex, tempDriver->name, tempDriver->phoneNumber, tempDriver-
>carModel, tempDriver->carNumber);
availableDriver = tempDriver;
}
tempDriver = tempDriver->next;
driverIndex++;
}

if (availableDriver == NULL) {
printf("No available drivers.\n");
return;
}

int driverChoice;
printf("Select a driver: ");
scanf("%d", &driverChoice);

tempDriver = driverHead;
for (int i = 1; i < driverChoice && tempDriver != NULL; i++) {
tempDriver = tempDriver->next;
}

if (tempDriver != NULL && tempDriver->available) {

tempCustomer->otp = generateOTP();
16
 tempCustomer->cabBooked = true;
tempCustomer->assignedDriver = tempDriver;
tempDriver->available = false;
printf("Cab booked successfully for customer: %s with driver: %s. OTP: %d\n",
tempCustomer->name, tempDriver->name, tempCustomer->otp);
} else {
printf("Invalid choice or driver not available. Please try again.\n");
}
} else {
printf("Invalid choice or customer already has a cab booked.\n");
}
}

int main() {
struct Driver* driverHead = NULL;
struct Customer* customerHead = NULL;
int choice;

printf("Welcome to the Cab Management System\n");

while (true) {
printf("\nSelect Interface:\n");
printf("1. Driver Registration\n");
printf("2. Display Drivers\n");
printf("3. Customer Registration\n");
printf("4. Display Customers\n");
printf("5. Book a Cab\n");
printf("6. Calculate Fare\n");
printf("7. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
addDriver(&driverHead);
break;

case 2:
displayDrivers(driverHead);
break;

17
 case 3:
addCustomer(&customerHead);
break;

case 4:
displayCustomers(customerHead);
break;

case 5:
bookCab(driverHead, customerHead);
break;

case 6: {
float distance;
printf("\nEnter the distance in kilometers: ");
scanf("%f", &distance);
printf("Fare for the journey: Rs%.2f\n", calculateFare(distance));
break;
}

case 7:
printf("Exiting...\n");
return 0;

default:
printf("Invalid choice. Please try again.\n");
}
}

return 0;

18
 CHAPTER 5

RESULT & DISCUSSION

5.1 OUTPUT

19
20
21
5.2 RESULT:
The Inventory Management System code is designed to manage inventory efficiently through
various functionalities. Below are the results of its execution and the outcomes observed for each
of its key features:

1. Adding Items:
o Function: addItem(Item* inventory[], int* size)
o Result: The system successfully adds new items to the inventory. Each item is
assigned a unique ID, name, stock quantity, and price based on user input. If the
inventory reaches its maximum capacity (MAX_ITEMS), the system prevents further
additions and displays a relevant message.

2. Removing Items:
o Function: removeItem(Item* inventory[], int* size, int id)
o Result: The system can remove an item from the inventory if it exists. The item is
deleted, and the remaining items are shifted to fill the gap. If the item with the
specified ID is not found, the system notifies the user..

3. Updating Stock:
o Function: updateStock(Item* inventory[], int size, int id, int
quantity)
o Result: The system updates the stock of an item based on the provided quantity
(positive or negative). It adjusts the inventory to reflect changes in stock levels. If
the item with the given ID is not found, an error message is displayed.

4. Displaying Inventory:
o Function: displayInventory(Item* inventory[], int size)
o Result: The system displays a list of all items in the inventory, including their ID,
name, stock quantity, and price. If the inventory is empty, it informs the user.

5. Calculating Order Quantity:

o Function: calculateOrderQuantity(Item* item, int reorderLevel)
o Result: The system calculates how many units of an item need to be ordered to reach
a specified reorder level. If the current stock is below the reorder level, it returns the
required order quantity; otherwise, it returns zero.

6. Calculating Transportation Cost:

22
 o Function: calculateTransportationCost(int distance, int quantity,
double rate)
o Result: The system computes the total transportation cost based on distance,
quantity of items, and rate per kilometer per unit. The calculated cost is displayed to
the user.

7. Calculating Labor Cost:

o Function: calculateLaborCost(int quantity, double laborRate)
o Result: The system calculates the labor cost based on the quantity of items and the
labor rate per unit. The computed labor cost is shown to the user.

8. Calculating Monthly Rent:

o Function: calculateMonthlyRent(int numberOfItems, double rentPerItem)
o Result: The system calculates the total monthly rent based on the number of items
and rent per item. The total rent is displayed to the user.

9. Calculating Profit:
o Function: calculateProfit(double monthlyRent, double laborCost)
o Result: The system computes the profit by subtracting labor cost from monthly rent.
The resulting profit is displayed to the user.

10. Exit and Memory Management:

o Function: The program frees all allocated memory when exiting.
o Result: Upon termination, the program successfully frees up the memory used by
inventory items, ensuring no memory leaks.

23
5.3DISCUSSION:

The Inventory Management System demonstrates an effective approach to handling and managing
inventory through a set of well-defined functionalities. The system provides a user-friendly
interface to perform various operations, contributing to efficient inventory management. Below are
key points of discussion:

1. Efficiency:
o The use of an array of pointers to Item structures ensures that each item can be
dynamically allocated and managed efficiently. The operations for adding,
removing, and updating items are straightforward and provide quick responses to
user commands.

2. Scalability:
o The system supports a fixed number of items (MAX_ITEMS), which can be adjusted as
needed. For larger-scale applications, a more dynamic data structure (e.g., linked
lists or hash tables) might be considered to handle growing inventory sizes more
effectively.

3. User Input Validation:

o The current implementation assumes that user inputs are valid. In a real-world
scenario, additional input validation and error handling would be necessary to
manage incorrect or malicious inputs, ensuring robustness and reliability.

4. Memory Management:
o The program demonstrates proper memory management by allocating memory for
new items and freeing it before exit. This prevents memory leaks, which is crucial
for maintaining system stability over time.

5. Functionality:
o The system provides essential functionalities for inventory management, including
item addition, removal, stock updates, and cost calculations. However, it could be
enhanced by incorporating features such as searching for items by name or ID,
generating reports, or integrating with a database for persistent storage.

6. User Experience:
24
 o The menu-driven approach is intuitive, allowing users to easily navigate through
various options. However, the use of scanf for input could be replaced with more
robust input handling methods to improve user experience and avoid potential input-
related issues.

7. Extensibility:
o The current code serves as a foundational framework. Future enhancements could
include support for multiple inventories, advanced reporting features, or integration
with other business management tools.

In summary, the Inventory Management System code provides a solid basis for managing
inventory and performing related calculations. While it meets basic requirements effectively, there
are opportunities for further development and improvement to enhance functionality and user
experience.

5.4 APPLICATION

The Inventory Management System (IMS) code can be applied in various real-world scenarios
where effective inventory control and management are critical. Below are some key applications:

1. Retail Store:

• Stock Management: Retail stores can use the IMS to track inventory levels of products,
ensuring they have sufficient stock to meet customer demand. The system helps in adding
new products, updating stock quantities, and removing discontinued items.
• Order Planning: Retailers can calculate order quantities to restock items that fall below
reorder levels, helping to maintain optimal stock levels and reduce the risk of stockouts.

2. Warehouse Management

• Inventory Tracking: Warehouses can use the IMS to manage the inventory of goods stored.
It assists in tracking item quantities, managing stock movements, and handling storage
space effectively.
• Cost Calculation: The system can calculate transportation costs for moving goods between
locations, as well as labor costs associated with handling inventory, helping warehouses
manage operational expenses.

3. Manufacturing
25
 • Raw Material Management: Manufacturing companies can apply the IMS to manage raw
materials and components. It ensures that the necessary materials are available for
production while avoiding excess inventory.
• Production Planning: By calculating order quantities and managing stock levels,
manufacturers can plan production schedules more effectively, aligning production with
inventory needs.

4. E-commerce

• Online Inventory Management: E-commerce businesses can integrate the IMS to manage
inventory for online sales. It helps track product availability, update stock levels based on
sales, and calculate shipping and handling costs.
• Order Fulfillment: The system supports order fulfillment by managing inventory levels and
ensuring timely restocking of products that are running low.

5. Hospitality Industry

• Supply Management: Restaurants, hotels, and catering services can use the IMS to manage
their inventory of food, beverages, and other supplies. It ensures that inventory is kept at
optimal levels and helps in ordering supplies as needed.
• Cost Control: The system calculates costs associated with supplies and labor, aiding in
budgeting and cost control for hospitality operations.

6. Healthcare

• Medical Supplies Management: Hospitals and clinics can use the IMS to manage medical
supplies, pharmaceuticals, and equipment. It helps in tracking inventory levels, ensuring
that critical supplies are always available.
• Inventory Optimization: The system helps in optimizing inventory levels, reducing waste,
and ensuring that necessary items are reordered in a timely manner.

7. Education

• Campus Facilities: Educational institutions can use the IMS to manage inventory for
campus facilities, including textbooks, lab equipment, and office supplies. It assists in
tracking availability and managing stock levels.
• Resource Allocation: The system helps in planning and allocating resources efficiently,
ensuring that educational materials are available when needed.

26
 CHAPTER 6

CONCLUSION

The Inventory Management System (IMS) provides a robust solution for efficiently managing
inventory, crucial for businesses across various sectors. By offering functionalities such as item
addition, stock updates, and cost calculations, the IMS enhances operational efficiency, helps
maintain optimal stock levels, and facilitates accurate financial planning. Its versatility makes it
applicable to diverse fields, including retail, warehousing, manufacturing, and more.

Despite its effectiveness, the system's scalability and user experience could be further refined with
additional features and improvements. Overall, the IMS serves as a valuable tool for organizations
aiming to streamline inventory management processes, reduce costs, and improve overall
efficiency.

References:

1. https://github.com/imunir57/Inventory-management-using-C
2. www.Google.com
3. https://www.tutorialspoint.com/c-program-to-store-inventory-system-using-
structures
4. https://www.youtube.com/watch?v=DrS2SOBn4d0

27