Table of Contents

Task No. Name of the Project

TASK 1 Retirement Calculator

TASK 2 Pizza Party

TASK 3 Mini Basket

TASK 4 Smart Tax Calculator

TASK 5 Paint Calculator

TASK 6 Self-Checkout System

TASK 7 Currency Conversion

TASK 8 Password Validation

TASK 9 Legal Driving Age

TASK 10 Blood Alcohol Calculator

TASK 11 Multi-state Sales Tax Calculator

TASK 12 Numbers to Names

TASK 13 Comparing Numbers

TASK 14 Troubleshooting Car Issues

TASK 15 Anagram Checker

TASK 16 Password Strength Indicator

TASK 17 Months to Pay Off a Credit Card

TASK 18 Validating Inputs

TASK 19 Handling Bad Input

TASK 20 Karvonen Heart Rate

TASK 21 Guess the Number Game

TASK 22 Magic 8 Ball

TASK 23 Employee List Removal

TASK 24 Picking a Winner

TASK 25 Computing Statistics

TASK 26 Password Generator

TASK 27 Filtering Values

TASK 28 Sorting Records

P a g e 2 | 116
TASK 29 Filtering Records

TASK 30 Name Sorter

TASK 31 Parsing a Data File

TASK 32 Website Generator

TASK 33 Product Search

TASK 34 Word Finder

TASK 35 Word Frequency Finder

TASK 36 Who’s in Space?

TASK 37 Grabbing the Weather

TASK 38 Flickr Photo Search

TASK 39 Movie Recommendations

TASK 40 Pushing Notes to Firebase

TASK 41 Creating Your Own Time Service

TASK 42 Todo List

TASK 43 URL Shortener

TASK 44 Text Sharing

TASK 45 Tracking Inventory

TASK 46 Trivia App

TASK 47 OCR Digital Decoder

TASK 48 Time Converter

TASK 49 Address Line Splitter

TASK 50 Word Reverser

TASK 51 Score Validator

TASK 52 Contact Book

TASK 53 ChatMate

TASK 54 Cook Master

TASK 55 DriveEase

TASK 56 FInTrack

TASK 57 Room Reserve

TASK 58 Smart File Organizer

P a g e 3 | 116
TASK 59 ExpensePro

TASK 60 Comment Extractor

TASK 61 Eating with Friends

TASK 62 Check Lists

TASK 63 Weather Tracker

TASK 64 Receipt Master

TASK 65 Veggie Cheeser

TASK 66 Musical Chairs

TASK 67 Compatibility Checker

TASK 68 Array-to-Map Converter

TASK 69 RPN Pocket Calculator

TASK 70 Forget No Ship

TASK 71 Weather Data Logger

TASK 72 Smart Parking System

TASK 73 Bus Route Optimization

TASK 74 IoT-based home Energy Monitor

TASK 75 E-Waste Collection Scheduler

TASK 76 Fitness Activity Tracker

TASK 77 Vehicle Maintenance Reminder

TASK 78 Virtual Classroom Attendance Manager

TASK 79 AI-Powered Resume Analyzer

TASK 80 Virtual ATM System

TASK 81 E-Voting

TASK 82 Music Playlist Manager

TASK 83 Task Alert System

TASK 84 Employee Performance Management

TASK 85 Online Exam Proctoring System

TASK 86 Smart Agriculture System

TASK 87 Automated Code Reviewer

TASK 88 AI-Powered Personal Finance Advisor

P a g e 4 | 116
TASK 89 Travel Itinerary Planner

TASK 90 E-Learning Platform

TASK 91 Smart Home Automation System

TASK 92 Energy Consumption Tracker

TASK 93 Virtual Event Management

TASK 94 Online Auction System

TASK 95 Tic-Tac-Toe Game

TASK 96 Weather-based Plant Care System

TASK 97 Crime Record Management System

TASK 98 Parcel Track

TASK 99 Course Registration System

TASK 100 Skill Match

P a g e 5 | 116
 Task 1: Retirement Calculator

Design and implement a project that determines how many years remain until a user can retire
and the exact year of retirement. The program should prompt the user for their current age
and the desired retirement age, then compute and display the output and display as below:
 The number of years left until retirement.
 The calendar year in which retirement will occur, based on the system’s current year.
If the user is already past the desired retirement age, the program should notify them that
they are eligible to retire.

Example Output
What is your current age? 25
At what age would you like to retire? 65
You have 40 years left until you can retire.
It's 2015, so you can retire in 2055.

Constraints
 Convert inputs to numeric values before performing calculations.
 The current year must be dynamically obtained from the system clock, not hard-coded.
 Ensure the program handles invalid inputs gracefully (e.g., negative ages, non-numeric
input).

Challenges
 If the retirement age is less than or equal to the current age, display a message like “You
can already retire!”.
 Allow users to choose an early retirement age (before standard retirement) and calculate
the financial impact (e.g., reduced benefits).
 Add an option to input expected lifespan and notify the user how many years they might
enjoy post-retirement.
 If the user wants to retire at different ages (e.g., 60, 65, 70), compute and display retirement
years for each option.
 Disallow negative or unrealistic ages (e.g., greater than 120).
 Ensure retirement age is greater than the current age unless handled by challenge #1.
 Instead of just the year, fetch the exact date & time from the system and calculate the
retirement date with month/day precision.

P a g e 6 | 116
 Task 2: Pizza Party

Design and implement a project that simulates sharing pizzas at a party. The program will
prompt the user to enter the number of people, the number of pizzas available, and the number
of slices per pizza. It will then calculate how many slices each person gets and determine if
there are any leftover slices, ensuring that division is handled as whole numbers instead of
decimals. To make the solution more robust, the program will validate inputs so that only
numeric values are accepted, and it will display the output with proper pluralization (e.g., “1
piece” vs. “2 pieces”). Additionally, the project will include an enhanced version where the
program asks for the number of people and the number of slices each person wants, and then
calculates the minimum number of pizzas required. This project emphasizes problem-solving,
user input validation, correct grammatical output, and handling real-life scenarios involving
division and remainders.

Example Output
Case 1: Exact Division
How many people? 8
How many pizzas do you have? 2
How many slices per pizza? 8

8 people with 2 pizzas (16 slices)

Each person gets 2 pieces of pizza.
There are 0 leftover pieces.

Case 2: With Leftovers

How many people? 5
How many pizzas do you have? 2
How many slices per pizza? 8

5 people with 2 pizzas (16 slices)

Each person gets 3 pieces of pizza.
There is 1 leftover piece.

Case 3: Variant – Calculating Required Pizzas

How many people? 10
How many slices does each person want? 3
How many slices per pizza? 8

You need to order 4 pizzas.

Constraints

 1 <= number_of_people <= 1000

 1 <= number_of_pizzas <= 500
 1 <= slices_per_pizza <= 20
 Input must be numeric; invalid inputs should be rejected with a message prompting
the user to re-enter values.
Challenges
 Input Validation – Ensuring the user only enters numeric values and handling invalid inputs
gracefully.

P a g e 7 | 116
 Pluralization Handling – Correctly formatting the output to display singular (“1 piece”) or
plural (“2 pieces”) forms where appropriate.
 Leftover Calculation – Accurately computing and displaying the number of leftover slices
when division isn’t exact.
 Pizza Requirement Variant – Extending the program to calculate how many pizzas need to
be purchased based on the number of people and desired slices per person.

P a g e 8 | 116
 Task 3: Mini Basket

This project involves developing a console-based grocery shopping application in Java that
demonstrates the practical use of Object-Oriented Programming (TASK) concepts. The
application simulates the core features of an online grocery store, allowing customers to
browse products, add items to a cart, and generate a final bill at checkout. It applies TASK
principles such as abstraction, encapsulation, inheritance, and polymorphism by designing
classes for products, customers, carts, and billing systems. The system includes a product
management module with a base Product class and subclasses like Vegetable, Fruit, and
DairyProduct, a cart module to manage selected items, and a billing module to compute totals
and display the final bill. Through encapsulation of product details, inheritance of product
categories, polymorphism in displaying product details, and abstraction for billing operations,
this project helps students connect theoretical TASK concepts with practical implementation in
a real-world scenario.

Example Output
What is your current age? 25
At what age would you like to retire? 65
You have 40 years left until you can retire.
It's 2015, so you can retire in 2055.

Constraints
 Convert inputs to numeric values before performing calculations.
 The current year must be dynamically obtained from the system clock, not hard-coded.
 Ensure the program handles invalid inputs gracefully (e.g., negative ages, non-numeric
input).

Challenges
 If the retirement age is less than or equal to the current age, display a message like “You
can already retire!”.
 Allow users to choose an early retirement age (before standard retirement) and calculate
the financial impact (e.g., reduced benefits).
 Add an option to input expected lifespan and notify the user how many years they might
enjoy post-retirement.
 If the user wants to retire at different ages (e.g., 60, 65, 70), compute and display retirement
years for each option.
 Disallow negative or unrealistic ages (e.g., greater than 120).
 Ensure retirement age is greater than the current age unless handled by challenge #1.
 Instead of just the year, fetch the exact date & time from the system and calculate the
retirement date with month/day precision.

P a g e 9 | 116
 Task 4: Smart Tax Calculator

Design and implement a console-based income tax calculator in Java that helps individuals
compute their tax liability under the new tax regime of India, which follows a slab-based
system. The program should collect details such as the taxpayer’s name, PAN number, annual
income, and applicable deductions, and then calculate the total tax payable according to the
defined slab rates (e.g., 0–3L: no tax, 3–6L: 5%, 6–9L: 10%, etc.). The application should apply
Object-Oriented Programming (TASK) principles by organizing the solution into classes such
as TaxPayer, IncomeDetails, and TaxCalculator. Key features include taxpayer management
with attributes like name, PAN, and income, encapsulation to secure sensitive details with
private fields and controlled access, inheritance and polymorphism to extend functionality for
different taxpayer categories (e.g., Salaried or Business), and abstraction through generalized
tax operations. This project not only simplifies tax computation but also gives students hands-
on experience in applying Java concepts to solve real-world financial problems.

Example Output
Case 1: Salaried Employee with Income in Taxable Slab
Welcome to the Smart Tax Calculator

Enter your name: Rahul Sharma

Enter your PAN number: ABCDE1234F
Enter your annual income: 750000
Enter deductions (if any): 50000

Taxpayer: Rahul Sharma (PAN: ABCDE1234F)

Annual Income: Rs. 750000
Deductions: Rs. 50000
Taxable Income: Rs. 700000
Total Tax Payable: Rs. 35,000

Case 2: Low-Income, No Tax Liability

Welcome to the Smart Tax Calculator

Enter your name: Priya Singh

Enter your PAN number: PQRSX5678K
Enter your annual income: 280000
Enter deductions (if any): 0

Taxpayer: Priya Singh (PAN: PQRSX5678K)

Annual Income: Rs. 280000
Deductions: Rs. 0
Taxable Income: Rs. 280000
Total Tax Payable: Rs. 0
(No Tax – Income within exemption limit)
Constraints
 The program must be console-based and implemented in Java without external
frameworks or databases.
 Only numeric input should be accepted for income and deductions; non-numeric
values must be handled gracefully.
 Sensitive fields such as income and PAN must be secured using encapsulation (private
P a g e 10 | 116
 fields with getters and setters).
 Tax calculations must strictly follow the slab rates under the new regime.
 Support for multiple taxpayer categories (Salaried, Business) should be possible
through inheritance. input).

Challenges

 Input Validation: Ensure proper handling of invalid PAN formats, negative income
values, or unrealistic deductions.
 Slab-Based Calculation: Accurately implement tax slabs with progressive calculation
logic.
 Encapsulation: Protect sensitive taxpayer details while allowing controlled access.
 Inheritance and Polymorphism: Extend functionality for different taxpayer types with
overridden calculation methods.
 Abstraction: Define general methods or interfaces for tax operations to support
modularity and reusability.
 Scalability: Enable future extensions for new tax regimes, surcharges, or cess without
redesigning the core structure.
 User Experience: Provide clear, user-friendly prompts and neatly formatted tax
reports.

P a g e 11 | 116
 Task 5: Paint Calculator

Design a project that calculates the number of paint gallons required to cover the ceiling of a
room. The user will provide the room’s length and width in feet, and the program will compute
the ceiling’s area. Since 1 gallon covers 350 square feet, the program should determine the
total gallons needed, rounding up to the nearest whole gallon because paint cannot be
purchased in fractions. The program should display the total gallons required along with the
calculated square footage.

Example Output
Case 1:
Length of the room (ft): 12
Width of the room (ft): 15

You will need to purchase 1 gallons of paint to cover 180 square feet.

Case 2: Length of the room (ft): 20

Width of the room (ft): 18

You will need to purchase 2 gallons of paint to cover 360 square feet.
Constraints
 Use a constant to hold the paint coverage rate (350 sq ft per gallon).
 Ensure that gallons required are always rounded up to the nearest whole number.
 Inputs must be positive numeric values (no negative or zero dimensions).

Challenges

 Input Validation: Ensure that the program only accepts valid numeric inputs for length
and width. Prevent users from entering negative numbers, zero, or non-numeric values.
 Support for Different Room Shapes: Extend the program to handle circular rooms
(using radius and area formula πr²). Add support for L-shaped rooms by splitting them
into two rectangles and summing their areas.
 Unit Flexibility: Allow inputs in different units (feet, meters, inches) and perform
appropriate conversions before calculating paint requirements.
 Multiple Surfaces Support: Extend functionality to calculate paint for multiple ceilings
or walls in one session, e.g., living room + kitchen combined.

P a g e 12 | 116
 Task 6: Self-Checkout System

Design a project to build a simple self-checkout system that helps users calculate their total
bill accurately while handling multiple inputs and currency precision. The program should
prompt the user to enter the price and quantity of items, calculate the subtotal, apply a fixed
tax rate of 5.5%, and then display a detailed bill showing each line item, the subtotal, the tax
amount, and the final total. Since working with currency can introduce tricky precision issues,
the program must ensure correct numeric conversions and proper formatting of values with
two decimal places to represent dollars and cents.

Example Output
Enter the price of item 1: 25
Enter the quantity of item 1: 2
Enter the price of item 2: 10
Enter the quantity of item 2: 1
Enter the price of item 3: 4
Enter the quantity of item 3: 1

Subtotal: $64.00
Tax: $3.52
Total: $67.52
Constraints
 Keep input, processing, and output parts of the program separate.
 Collect all inputs first, then perform mathematical operations, then display the
formatted results.
 Explicitly convert all inputs into numeric data types before performing calculations.
 Ensure monetary values are displayed with two decimal places for precision.

Challenges
 Input Validation: Revise the program to ensure that both prices and quantities are
entered as numeric values. Prevent invalid or negative values from being processed.
 Support for Indeterminate Number of Items: Allow users to enter any number of
items instead of limiting to three. Compute subtotal, tax, and total only when the user
indicates no more items are left to enter.
 Currency Handling Improvements: Ensure the program properly handles floating-
point precision issues in monetary calculations. Optionally, implement currency
formatting to display amounts according to locale settings (e.g., $, ₹, €).
 Feature Extensions: Add support for discounts (e.g., coupon codes or bulk purchase
discounts). Enable saving receipts as a text file or PDF. Build a mobile-friendly version
of the system for use in small shops or as a shopping assistant tool.

P a g e 13 | 116
 Task 7: Currency Conversion

Currency exchange often requires precise calculations to avoid rounding errors, especially
when dealing with small units like cents. In this project, you will create a program that converts
euros to U.S. dollars based on the current exchange rate. The user will be prompted to enter
the amount in euros they want to exchange and the current exchange rate of the euro. The
program should then calculate the equivalent amount in U.S. dollars using the formula:

Where:
Amount_to: Amount in U.S. dollars
Amount_from: Amount in euros
Rate_from: Current exchange rate of euros
Rate_to: Current exchange rate of U.S. dollars
The result should be displayed clearly, ensuring correct rounding to the nearest cent.

Example Output
How many euros are you exchanging? 81
What is the exchange rate? 137.51
81 euros at an exchange rate of 137.51 is
111.38 U.S. dollars.

Constraints
 Fractions of a cent must always be rounded up to the next penny.
 Use a single output statement to display the result in a clear and readable format.
 Ensure that all inputs are numeric values before performing calculations.

Challenges
 Input Validation: Revise the program to ensure that both the euro amount and
exchange rate are numeric and positive. Prevent invalid or zero values from being
processed.
 Dictionary of Conversion Rates: Instead of directly asking for exchange rates, build a
dictionary (lookup table) of common currencies. Prompt the user to choose the source
and target currencies (e.g., EUR → USD, GBP → USD).
 Integration with Real-Time Data: Connect the program to an external API to fetch live
exchange rates automatically instead of manual input.
 Extended Features: Allow conversions between multiple currencies (not just euros to
USD). Implement a mobile-friendly interface so users can quickly perform conversions
on the go.
 Add support for batch conversions (e.g., converting multiple amounts at once).

P a g e 14 | 116
 Task 8: Password Validation
Passwords are a critical part of authentication systems, and validating them correctly is
essential for security. In this project, you will create a simple program that validates user login
credentials. The program should prompt the user for both a username and a password. It will
then compare the entered password with a known stored password. If the password matches,
the program should display “Welcome!”. If it does not match, the program should display “I
don’t know you.”. The system must be case-sensitive, ensuring that even small differences in
input (e.g., uppercase vs lowercase letters) are correctly handled.

Example Output
What is the password? 12345
I don't know you.
What is the password? abc$123
Welcome!
Constraints
 Use an if/else statement to validate credentials.
 Ensure that the program is case-sensitive when comparing passwords.
 Keep the program simple, handling only one known username-password pair in its
basic version.

Challenges
 Password Privacy: Investigate ways to prevent the password from being displayed on
the screen in plain text while the user is typing (e.g., using masked input).
 Multiple Users Support: Create a map of usernames and passwords and validate
credentials by ensuring both username and password combinations match correctly.
 Password Encryption: Store hashed passwords instead of plain-text passwords for
security. Use a library such as Bcrypt to encode passwords before storage. When
validating, encrypt the user-entered password with Bcrypt and compare it with the
stored hash.
 Extended Security Features: Implement account lockout after multiple failed login
attempts. Add password strength checks (minimum length, special characters, etc.)
before allowing registration.

P a g e 15 | 116
 Task 9: Legal Driving Age
Design a project to determine whether a person is legally old enough to drive by comparing
their age with a defined threshold. The program will prompt the user to enter their age and
then check it against the legal driving age of 16. If the entered age is 16 or older, the program
will display a message stating that the user is old enough to legally drive. If the age is below
16, it will display a message indicating that the user is not old enough. This project highlights
the use of conditional logic and input handling, ensuring that numeric values are properly
evaluated to provide accurate feedback. In advanced versions, it can also incorporate country-
specific driving ages and robust input validation.

Example Output
What is your age? 15
You are not old enough to legally drive.
What is your age? 35
You are old enough to legally drive.
Constraints
 Use a single output statement to display the result.
 Implement the logic using a ternary operator.
 If the programming language does not support a ternary operator, use a regular if/else
statement while still maintaining a single output statement.
 Ensure that age input is numeric and positive.

Challenges
 Input Validation: Handle invalid inputs such as negative numbers or non-numeric data.
Display an error message prompting the user to enter a valid age.
 International Driving Ages: Instead of hardcoding the driving age, create a lookup table
of legal driving ages for multiple countries. Prompt the user for their age and display
in which countries they are legally allowed to drive.
 Extended Features: Allow the user to input their country and check if they meet that
country’s legal driving age. Include support for different types of licenses, such as
learner’s permits versus full licenses, depending on the country.

P a g e 16 | 116
 Task 10: Blood Alcohol Calculator

Determining whether it is safe and legal to drive often requires calculating blood alcohol
content (BAC) based on multiple factors. This project will create a program that prompts the
user for their weight, gender, number of drinks, alcohol by volume of each drink, and hours
since their last drink. Using the formula:

Where:
A: Total alcohol consumed, in ounces (oz)
W: Body weight in pounds
r: Alcohol distribution ratio (0.73 for men, 0.66 for women)
H: Number of hours since the last drink
The program will calculate the BAC and display whether it is legal to drive, based on a standard
threshold of 0.08. The program emphasizes the use of complex calculations, conditional logic,
and input validation to provide accurate feedback.

Example Output
Your BAC is 0.08
It is not legal for you to drive.
Your BAC is 0.05
It is legal for you to drive.
Constraints
 Ensure that all inputs are numeric values.
 Prevent the user from entering invalid or non-numeric data.
 BAC should be displayed with two decimal places for clarity.

Challenges
 Unit Flexibility: Extend the program to accept metric units (kilograms for weight,
milliliters for drink volume) and perform appropriate conversions to calculate BAC.
 State-Specific Legal Limits: Create a lookup table of legal BAC limits by state.
 Prompt the user for their state and display a message indicating whether it is legal for
them to drive based on their calculated BAC.
 Incremental BAC Tracking: Develop the program as a mobile-friendly application that
allows users to record each drink as it is consumed. Update the BAC dynamically each
time a new drink is entered, giving real-time feedback on legality.
 Extended Features: Warn the user if their BAC approaches or exceeds dangerous levels.
Provide recommendations for safe driving or alternative transportation based on BAC.

P a g e 17 | 116
 Task 11: Multi-state Sales Tax Calculator
Design a project that will create a sales tax calculator that handles multiple states and, for
some states, multiple counties. The program prompts the user for the order amount and the
state where the order will be shipped.
For Wisconsin residents, the program should additionally prompt for the county of residence:
 Eau Claire County → add 0.5% additional tax
 Dunn County → add 0.4% additional tax
Illinois residents must be charged 8% sales tax with no additional county-level tax. All other
states are not charged tax.
The program should display both the tax amount and the total order amount for Wisconsin
and Illinois residents, but for all other states, display only the total. This project demonstrates
nested decision-making, proper rounding of monetary values, and clean handling of multiple
input conditions.

Example Output
What is the order amount? 10
What state do you live in? Wisconsin
What county do you live in? Eau Claire
The tax is $0.50.
The total is $10.50.
What is the order amount? 10
What state do you live in? Illinois
The tax is $0.80.
The total is $10.80.

Constraints
 Ensure that all monetary values are rounded to the nearest cent.
 Use a single output statement at the end of the program to display results.
 Input for state and county should be properly normalized to handle different cases
(upper, lower, mixed).

Challenges
 Extended State/County Support: Add support for additional states and counties in your
region. Ensure the program can handle state abbreviations and full names
interchangeably.
 Flexible Input Handling: Allow users to enter the state abbreviation or full state name
in upper, lower, or mixed case.
 Data-Driven Implementation: Use data structures such as maps/dictionaries to store
tax rates and county surcharges. Avoid deeply nested if/else statements by using
lookup tables and conditional logic based on the stored data.
 Extended Features: Display a detailed receipt with order amount, tax, and total for all
states. Allow future tax rate updates without changing the main program logic.
Optionally, add user-friendly formatting for monetary values, like currency symbols and
consistent decimal places.

P a g e 18 | 116
 Task 12: Numbers to Names

Many programs display information to users in a friendly, textual form while using numerical
or coded values internally. In this project, you will write a program that converts a number
from 1 to 12 into the corresponding calendar month. The program should prompt the user to
enter a number and then display the month name: 1 corresponds to January, 2 to February,
and so on up to 12 for December. For any number outside this range, the program should
display a clear error message. This project demonstrates the use of mapping numeric values
to textual data, conditional logic, and user-friendly output.

Example Output
Please enter the number of the month: 3
The name of the month is March.
Please enter the number of the month: 15
Error: Please enter a number between 1 and 12.

Constraints
 Use a switch/case statement to map numbers to month names.
 Use a single output statement for displaying the result.
 Ensure that the program properly handles invalid inputs outside the 1–12 range.

Challenges
 Data-Driven Approach: Replace the switch/case statement with a map or dictionary
that stores the mapping of numbers to month names. This allows easier maintenance
and scalability, especially for future extensions.
 Multi-Language Support: Prompt the user to select a language at the beginning of the
program (e.g., English, Spanish, French). Display the month name in the selected
language using a nested dictionary or data structure.
 Input Validation Enhancements: Ensure the user enters a numeric value and handle
non-numeric input gracefully.
 Extended Features: Support abbreviated month names (e.g., Jan, Feb) in addition to full
names. Allow the user to enter multiple numbers in a single run and display all
corresponding months.

P a g e 19 | 116
 Task 13: Comparing Numbers

Comparing values is a common task in programming, but sometimes you need to process
multiple inputs and apply additional rules. In this project, you will write a program that prompts
the user to enter three numbers. The program should first check that all three numbers are
different. If any numbers are repeated, the program should exit. If all numbers are unique, the
program should identify and display the largest number. This project emphasizes manual
algorithm design, conditional logic, and input validation without relying on built-in functions
for comparison.

Example Output
Enter the first number: 1
Enter the second number: 51
Enter the third number: 2
The largest number is 51.
Enter the first number: 10
Enter the second number: 10
Enter the third number: 5
Error: Numbers must be unique.

Constraints
 Write the algorithm manually to determine the largest number.
 Do not use built-in functions such as [Link]() or [Link]().
 Ensure that numbers are unique before comparing them.

Challenges
 Duplicate Prevention: Track all previously entered numbers and prevent the user from
entering a number that has already been entered.
 Extended Input: Modify the program to ask for ten numbers instead of three. Further
extend the program to accept an unlimited number of inputs, ending input when the
user signals completion.
 Enhanced Validation: Ensure all inputs are numeric and handle invalid entries
gracefully. Optionally, allow decimal numbers and adapt the comparison logic
accordingly.
 Additional Features: Display a sorted list of all entered numbers in addition to the
largest number. Highlight the smallest number as well. Integrate the program into a
mobile or web app for interactive number comparisons.

P a g e 20 | 116
 Task 14: Troubleshooting Car Issues

Expert systems are a type of artificial intelligence that use a knowledge base and a set of rules
to solve problems in the same way a human expert might. In this project, you will create a
program that guides a user through troubleshooting common car issues. Using a decision tree,
the program will ask relevant questions based on previous answers and provide step-by-step
guidance for diagnosing and resolving the problem. The goal is to demonstrate conditional
logic, nested decision-making, and interactive problem solving, while only asking questions
relevant to the situation.

Example Output
Is the car silent when you turn the key? y
Are the battery terminals corroded? n
The battery cables may be damaged.
Replace cables and try again.
Is the car silent when you turn the key? y
Are the battery terminals corroded? y
Clean terminals and try starting again.
Does the engine start and then die? y
Does your car have fuel injection? n
Check to ensure the choke is opening and closing.

Constraints
 Ask only relevant questions based on previous answers.
 Do not ask all possible inputs at once.
 Provide clear, actionable recommendations based on the user’s responses.

P a g e 21 | 116
Challenges
 Rules Engines and Inference: Explore rules engines or inference engines available for
your programming language. Implement the troubleshooting logic using a rule-based
approach instead of nested if/else statements for more complex scenarios.
 Decision Tree Extension: Expand the decision tree to cover more car problems, such as
electrical issues, fuel system problems, or engine overheating. Include additional
branches to provide detailed troubleshooting guidance.
 Interactive and User-Friendly Design: Allow the program to guide users step-by-step,
showing only questions relevant to the current branch of the decision tree. Include a
loop or restart option so users can troubleshoot multiple issues without restarting the
program.

P a g e 22 | 116
 Task 15: Anagram Checker

An anagram is a word or phrase formed by rearranging the letters of another word or phrase,
using all the original letters exactly once. The goal of this project is to create a program that
compares two given strings and determines whether they are anagrams of each other. The
program should prompt the user to enter two strings and then output whether the strings are
anagrams. To keep the solution clean and maintainable, the logic for checking anagrams must
be separated into a dedicated function.

Example Output
Enter two strings and I'll tell you if they are anagrams:
Enter the first string: note
Enter the second string: tone
"note" and "tone" are anagrams.

Constraints
 Implement the program using a function called isAnagram, which takes in two words
as its arguments and returns true or false.
 Both words must be checked to ensure they are the same length before proceeding
with further logic.
 The function should be invoked from the main program, keeping input/output logic
separate from the core checking logic.

Challenges
 Complete the program without relying on built-in language features for sorting or
comparison.
 Instead, use fundamental programming constructs such as loops, conditional
statements, and arrays or frequency counts to build a custom algorithm.
 Ensure the solution is efficient even for longer words, while keeping the code simple
and easy to understand.

P a g e 23 | 116
 Task 16: Password Strength Indicator

Password security is one of the most important aspects of protecting user data in applications.
Weak or predictable passwords increase the risk of unauthorized access, while strong
passwords add a layer of safety. The goal of this project is to create a program that evaluates
the strength of a given password based on specific rules. The program should classify the
password into categories such as very weak, weak, strong, or very strong, depending on its
composition and length. Functions will be used to encapsulate the validation logic, making the
program modular and easier to maintain.

Example Output
The password '12345' is a very weak password.
The password 'abcdef' is a weak password.
The password 'abc123xyz' is a strong password.
The password '1337h@xor!' is a very strong password.

Constraints
 Implement a passwordValidator function that takes the password as its argument and
returns a value (e.g., numeric code or category type) that can be evaluated to determine
password strength.
 The function should not directly return strings, as this makes it easier to adapt the
program for multiple languages in the future.
 Use a single output statement in the main program to display the password strength
result.

Challenges
 Extend the program by creating a GUI or web-based application that provides real-
time feedback as the user types a password.
 Enhance the system to display both graphical and textual indicators of password
strength.
 Ensure the password evaluation is efficient and flexible enough to integrate additional
rules (e.g., checking dictionary words or enforcing mixed-case usage).

P a g e 24 | 116
 Task 17: Months to Pay Off a Credit Card

Paying off credit card debt often takes longer than most people expect due to high interest
rates and the way payments are applied. Calculating the exact number of months required to
pay off a balance involves a complex formula, which can make programs difficult to read and
maintain. To address this, the task is to write a program that determines how many months it
will take to pay off a credit card balance given the balance, the Annual Percentage Rate (APR),
and the monthly payment amount. By encapsulating the formula into a dedicated function,
the code remains clean, reusable, and easy to maintain.

Example Output
What is your balance? 5000
What is the APR on the card (as a percent)? 12
What is the monthly payment you can make? 100
It will take you 70 months to pay off this card.

Constraints
 The program must prompt for the APR as a percentage (not as a decimal), and perform
the division internally to calculate the daily rate.
 A function named calculateMonthsUntilPaidOff should be implemented, which takes
the balance, APR, and monthly payment as arguments and returns the number of
months required.
 All calculations should be handled within the function, avoiding the use of external
variables.
 Fractions of a cent must always be rounded up to the next cent to ensure accuracy in
financial calculations.

Challenges
 Extend the program to allow the user to enter either the number of months they want
to pay off the balance in or the monthly payment amount, and calculate the other
accordingly.
 Build flexibility into the system so that the user can choose between calculating payoff
time or required monthly payments.
 Enhance usability by improving error handling (e.g., ensuring payment is large enough
to cover interest) and possibly creating a GUI or web-based tool for better visualization.

P a g e 25 | 116
 Task 18: Validating Inputs

Validating user input is essential to ensure data accuracy and program reliability. A poorly
validated program may accept incorrect or incomplete values, leading to unexpected behavior
or errors later. This project focuses on creating a program that validates four types of user
input: first name, last name, employee ID, and ZIP code. Each input must follow specific rules
such as minimum length requirements, format restrictions, and numeric validation. By breaking
down the logic into smaller functions, the program becomes modular, reusable, and easier to
maintain. The program should display meaningful error messages for invalid inputs, and
confirm when all inputs are valid.

Example Output
Enter the first name: J
Enter the last name:
Enter the ZIP code: ABCDE
Enter an employee ID: A12-1234

"J" is not a valid first name. It is too short.

The last name must be filled in.
The ZIP code must be numeric.
A12-1234 is not a valid ID.

Constraints
 Implement a separate function for each type of validation (first name, last name,
employee ID, and ZIP code).
 Create a validateInput function that accepts all input data and invokes the specific
validation functions.
 Use a single output statement to display the validation results after all checks are
complete.

Challenges
 Use regular expressions to validate inputs such as the employee ID format (AA-1234)
and ZIP code numeric check.
 Extend the program into a GUI or web application that provides immediate, user-
friendly feedback when fields lose focus.
 Implement re-validation loops so that the user is prompted again until all inputs are
valid, ensuring robust error handling.

P a g e 26 | 116
 Task 19: Handling Bad Input

The Rule of 72 is a simple formula used to estimate how long it will take for an investment to
double, calculated by dividing 72 by the expected rate of return. This makes it a useful tool for
quickly evaluating investment opportunities like stocks, bonds, or savings accounts. However,
the calculation requires valid input, since division by zero or non-numeric values would cause
errors. The goal of this project is to build a program that prompts the user for the rate of
return, validates the input, and continues asking until a valid numeric value greater than zero
is entered. Once valid input is provided, the program will calculate and display the number of
years required to double the investment.

Example Output
What is the rate of return? 0
Sorry. That's not a valid input.

What is the rate of return? ABC

Sorry. That's not a valid input.

What is the rate of return? 4

It will take 18 years to double your initial investment.

Constraints
 The program must not allow the user to enter 0 as a rate of return.
 Non-numeric values must also be rejected.
 A loop should be used to repeatedly prompt the user until valid input is provided.

Challenges
 Display a different error message specifically for the case where the user enters 0, to
clearly distinguish it from other invalid inputs.
 Extend the program to handle edge cases, such as extremely small or large values of
the rate of return, and ensure the program remains user-friendly.
 Consider expanding the program into a GUI or web-based version that provides instant
feedback for invalid inputs.

P a g e 27 | 116
 Task 20: Karvonen Heart Rate

When starting a fitness program, it is important to know your target heart rate to ensure safe
and effective exercise. The Karvonen Heart Rate formula is a widely used method to determine
the target heart rate for different intensity levels. This project focuses on building a program
that prompts the user for their age and resting heart rate, then calculates and displays the
target heart rate for a range of exercise intensities from 55% to 95%. The results should be
presented in a tabular format, giving users a clear understanding of the heart rate zones they
should aim for during workouts.

Example Output
Resting Pulse: 65 Age: 22

Intensity | Rate
-------------|------
55% | 138 bpm
60% | 145 bpm
65% | 151 bpm
...
85% | 178 bpm
90% | 185 bpm
95% | 191 bpm

Constraints
 Do not hard-code the percentages; use a loop to increment intensity values from 55%
to 95%.
 Ensure that both the age and resting heart rate inputs are validated as numeric values,
and prevent the user from continuing without valid input.
 Display results in a neatly formatted table for readability.

Challenges
 Implement a GUI-based version where the user can adjust intensity using a slider
control. The target heart rate values should update in real time as the slider moves.
 Allow customization of the increment step for intensity (e.g., every 5% or every 2%) to
give users more flexibility in viewing results.
 Extend the program to provide fitness recommendations based on the user’s age and
calculated heart rate zones.

P a g e 28 | 116
 Task 21: Guess the Number Game

The Guess the Number Game is an interactive program where the computer randomly selects
a number, and the player must guess it with the help of hints. To make the game more
engaging, it includes three difficulty levels: easy (1–10), medium (1–100), and hard (1–1000).
The player selects a difficulty level at the start, and the game generates a random number
within that range. For each guess, the computer provides feedback indicating whether the
guess is too high or too low, while keeping track of the total number of attempts. Once the
correct number is guessed, the program displays the number of guesses taken and asks
whether the player wants to play again, making it both challenging and replayable.

Example Output
Let's play Guess the Number.
Pick a difficulty level (1, 2, or 3): 1
I have my number. What's your guess? 1
Too low. Guess again: 5
Too high. Guess again: 2
You got it in 3 guesses!
Play again? n
Goodbye!

Constraints
 The program must not allow non-numeric entries for guesses or difficulty selection.
 If the player enters invalid (non-numeric) input, it should be counted as a wrong guess.
 The game must track and display the total number of guesses at the end of each round.

Challenges
 Provide personalized comments based on the number of guesses:
 1 guess: “You’re a mind reader!”
 2–4 guesses: “Most impressive.”
 3–6 guesses: “You can do better than that.”
 7 or more guesses: “Better luck next time.”
 Keep track of previous guesses and notify the player if a number has already been
guessed, counting it as a wrong attempt.
 Implement a graphical version of the game where the player interacts with a grid of
numbers, and each clicked or tapped number is removed from the screen for a more
visual experience.

P a g e 29 | 116
 Task 22: Magic 8 Ball

The Magic 8 Ball is a simple game that simulates the classic fortune-telling toy. The program
prompts the user to enter a yes-or-no style question and then randomly selects a response
from a predefined set of possible answers. These responses include “Yes,” “No,” “Maybe,” and
“Ask again later.” By combining arrays (to store responses) with a random number generator
(to select one), the game provides an unpredictable and entertaining experience for the user.

Example Output
What's your question? Will I be rich and famous?
Ask again later.

Constraints
 The program must use a pseudo-random number generator to select the response.
 All possible responses should be stored in a list or array, and one should be chosen at
random during execution.

Challenges
 Extend the game into a GUI application to make it more visually appealing and
interactive.
 If supported by the device, integrate native libraries so that the user can physically
“shake” the device to generate a new random response, mimicking the real Magic 8
Ball toy.

P a g e 30 | 116
 Task 23: Employee List Removal

Managing lists often requires removing specific entries based on certain criteria. For example,
in a workplace scenario, you might need to update an employee roster when someone leaves
the organization. This project focuses on creating a program that maintains a list of employee
names. Initially, the program displays the complete list of employees. The user is then
prompted to enter the name of an employee to remove. Once a valid name is entered, the
program removes it from the list and displays the updated list of employees. This exercise
helps practice list manipulation, input handling, and output formatting.

Example Output
There are 5 employees:
John Smith
Jackie Jackson
Chris Jones
Amanda Cullen
Jeremy Goodwin

Enter an employee name to remove: Chris Jones

There are 4 employees:

John Smith
Jackie Jackson
Amanda Cullen
Jeremy Goodwin

Constraints
 Store employee names in an array or list.
 Ensure that the program correctly removes the specified name from the list and
updates the employee count.

Challenges
 If the user enters a name that does not exist in the list, display an appropriate error
message.
 Enhance the program to read the list of employees from a file, with each employee on
a separate line.
 Extend functionality to write the updated employee list back to the same file, ensuring
persistence of changes.

P a g e 31 | 116
 Task 24: Picking a Winner

Contests and prize drawings often require a fair and random way of selecting winners from a
group of participants. This project focuses on building a program that allows users to enter
the names of contestants and stores them in a list. The input continues until the user submits
a blank entry, which indicates that no more names are being added. Once the list of
contestants is complete, the program randomly selects one name as the winner and displays
it. This exercise helps practice collecting dynamic input, storing data in lists, and applying
randomness in program logic.

Example Output
Enter a name: Homer
Enter a name: Bart
Enter a name: Maggie
Enter a name: Lisa
Enter a name: Moe
Enter a name:

The winner is... Maggie.

Constraints
 Use a loop to capture contestant names and store them in a list.
 Use a random number generator to select a winner from the list.
 Do not include blank entries in the list.
 If the language requires fixed-size arrays, consider using a dynamic data structure such
as an ArrayList.

Challenges
 After selecting a winner, remove the winner from the list and allow the program to
continue selecting additional winners if needed.
 Implement a GUI version of the program that visually shuffles the list of names before
announcing the winner.
 Create a separate registration application to manage contestant entries, and then use
this program to pull in the registered participants for winner selection.

P a g e 32 | 116
 Task 25: Computing Statistics

Collecting and analyzing statistical data is essential for understanding patterns, identifying
outliers, and improving system performance. This project focuses on building a program that
prompts the user to enter response times from a website in milliseconds. The program
continues to collect input until the user types “done.” Once all values are entered, the program
calculates and displays key statistical metrics: the average (mean), minimum, maximum, and
standard deviation. Separating input collection, processing, and output ensures modularity,
while arrays and loops are used to efficiently store and process the data.

Example Output
Enter a number: 100
Enter a number: 200
Enter a number: 1000
Enter a number: 300
Enter a number: done

Numbers: 100, 200, 1000, 300

The average is 400.
The minimum is 100.
The maximum is 1000.
The standard deviation is 400.25.

Constraints
 Use loops and arrays to handle input collection and perform calculations.
 Exclude the “done” entry from the array of inputs.
 Properly convert numeric values from strings as needed.
 Maintain a clear separation between input, processing, and output logic.

Challenges
 Implement separate functions named mean, max, min, and standardDeviation, each
accepting an array of numbers and returning the corresponding result.
 Extend the program to read numbers from an external file instead of prompting the
user for input, enabling automated analysis of larger datasets.
 Enhance the program to handle invalid entries gracefully, prompting the user to re-
enter numeric values.

P a g e 33 | 116
 Task 26: Password Generator

Creating a secure password that meets specific requirements is an important task for
protecting personal and organizational data. This project focuses on building a program that
generates strong passwords based on user-defined criteria. The program prompts the user for
the minimum password length, the number of special characters, and the number of numeric
digits. Using these inputs, the program generates a randomized password that meets the
specified requirements. By combining lists of characters with a random number generator, the
program produces unpredictable and secure passwords while giving users flexibility over the
password composition.

Example Output
What's the minimum length? 8
How many special characters? 2
How many numbers? 2

Your password is: aurn2$1s#

Constraints
 Use lists to store letters, numbers, and special characters for password generation.
 Incorporate randomness in selecting characters and arranging them within the
password.
 Ensure the password meets all user-specified requirements for length, special
characters, and numbers.

Challenges
 Implement logic to randomly convert vowels to numbers, such as replacing ‘E’ with 3
or ‘A’ with 4, to increase password complexity.
 Allow the program to generate multiple password options at once, giving the user a
choice.
 Automatically copy the generated password to the user’s clipboard for convenience.
 Extend the program to include additional rules, such as avoiding ambiguous characters
(e.g., 0 and O) or ensuring at least one uppercase letter.

P a g e 34 | 116
 Task 27: Filtering Values

In many applications, the data collected needs to be filtered based on specific criteria to be
useful. This project focuses on creating a program that prompts the user to enter a list of
numbers separated by spaces and then outputs a new list containing only the even numbers.
Using arrays to store input values and loops to process them allows efficient filtering.
Encapsulating the filtering logic in a separate function makes the code modular, reusable, and
easier to maintain.

Example Output
Enter a list of numbers, separated by spaces: 1 2 3 4 5 6 7 8
The even numbers are: 2 4 6 8

Constraints
 Convert the input string into an array of numbers.
 Implement your own algorithm for filtering; do not rely on built-in functions like filter
or similar enumeration features.
 Use a function called filterEvenNumbers that accepts the input array and returns a new
array containing only the even numbers.

Challenges
 Extend the program to read input from a text file instead of user input.
 Print only the even-numbered lines from the file, demonstrating filtering in a real-world
scenario.
 Enhance the program to handle invalid entries gracefully, such as non-numeric inputs,
without crashing.

P a g e 35 | 116
 Task 28: Sorting Records

When managing employee data, it is often necessary to sort records to quickly locate
information or perform visual comparisons. This project focuses on creating a program that
stores a dataset of employees, including their first name, last name, position, and separation
date. The program should sort the employees by last name and display the sorted records in
a neatly formatted table. Using a list of maps or dictionaries allows for flexible storage of
employee attributes while enabling easy sorting and display of information.

Example Output
Name | Position | Separation Date
------------------------- |-----------------------|----------------
Jacquelyn Jackson | DBA |
Jake Jacobson | Programmer |
John Johnson | Manager | 2016-12-31
Michaela Michaelson | District Manager | 2015-12-19
Sally Weber | Web Developer | 2015-12-18
Tou Xiong | Software Engineer| 2016-10-05

Constraints
 Implement the employee dataset using a list of maps (or dictionaries), where each map
stores the attributes of an employee.
 Sort the list by last name before displaying the records.
 Display the output in a tabular format for readability.

Challenges
 Allow the user to choose the sorting criteria, such as last name, position, or separation
date, instead of always sorting by last name.
 Store and retrieve employee records using a database (e.g., MySQL) or a key-value
store (e.g., Redis) to practice working with persistent storage.
 Extend the program to handle large datasets efficiently and implement additional
sorting options like ascending or descending order.

P a g e 36 | 116
 Task 29: Filtering Records

While sorting records is useful, filtering is often needed to focus on specific entries that meet
certain criteria. This project focuses on creating a program that allows users to search for
employee records by entering a search string. The program compares the search string against
the first and last name fields of each record and displays all matching employees in a tabular
format. Using an array of maps or associative arrays enables flexible storage and easy filtering
of employee attributes while maintaining clean, structured code.

Example Output
Enter a search string: Jac
Results:
Name | Position | Separation Date
---------------------------|------------------|----------------
Jacquelyn Jackson | DBA |
Jake Jacobson | Programmer |

Constraints
 Implement the employee dataset using an array of maps or an associative array, where
each map contains first name, last name, position, and separation date.
 Filter records by comparing the search string to the first or last name.
 Display the matching results in a tabular format.

Challenges
 Make the search case-insensitive to improve usability.
 Add the option to search by position as well as by name.
 Add the ability to filter employees whose separation date is six months ago or more.
 Extend the program to read employee data from a file, rather than hardcoding it, to
handle larger datasets.

P a g e 37 | 116
 Task 30: Name Sorter

Alphabetizing the contents of a file is a practical way to practice file manipulation and sorting
techniques in programming. This project involves creating a program that reads a list of names
from a file, sorts them alphabetically, and outputs the sorted list to another file. The program
should handle an arbitrary number of names, making it flexible and reusable for different
datasets. Alphabetical sorting allows users to quickly locate names and ensures that records
are presented in an organized manner.

Example Output
Total of 7 names
----------------
Ling, Mai
Johnson, Jim
Jones, Aaron
Jones, Chris
Swift, Geoffrey
Xiong, Fong
Zarnecki, Sabrina

Constraints
 Do not hard-code the number of names; the program should handle any number of
entries.
 Read the names from a file, sort them in alphabetical order, and write the results to an
output file.

Challenges
 Extend the program to read names from user input one at a time and then output the
sorted list to a file.
 Test the program with large datasets to evaluate its performance and efficiency.
 Implement the program in a functional programming language and compare its
approach and performance to traditional imperative implementations.

P a g e 38 | 116
 Task 31: Parsing a Data File

Data often comes in structured formats that must be broken down into records for processing.
A common format is CSV (comma-separated values), which stores multiple fields in a single
line separated by commas. This project involves creating a program that reads a CSV file
containing employee records, including last name, first name, and salary. The program should
parse the data manually, without using a CSV library, and display it in a neatly formatted table.
Proper alignment of columns ensures readability and allows users to quickly scan and compare
the records.

Example Output
Last First Salary
--------------------------------
Ling Mai 55900
Johnson Jim 56500
Jones Aaron 46000
Jones Chris 34500
Swift Geoffrey 14200
Xiong Fong 65000
Zarnecki Sabrina 51500

Constraints
 Manually parse the CSV data without using a CSV parser library.
 Align columns using spaces, making each column one space longer than the longest
value in that column.
 Ensure that all data is displayed in a clean, tabular format for readability.

Challenges
 Format the salary as currency, including a dollar sign and comma separators.
 Sort the records by salary from highest to lowest.
 Rework the program to use a CSV parsing library and compare the performance and
simplicity of the manual approach versus the library approach.

P a g e 39 | 116
 Task 32: Website Generator

Creating a basic website structure can be automated using a program that generates folders
and files based on user input. This project involves building a program that prompts the user
for the site name and author, and optionally whether they want folders for JavaScript and CSS
files. The program should then generate a folder with the site name, create an [Link] file
containing the site name in the <title> tag and the author in a <meta> tag, and optionally
create subfolders for JavaScript and CSS. This project helps practice file and directory
manipulation, user input handling, and basic HTML generation.

Example Output
Site name: awesomeco
Author: Max Power
Do you want a folder for JavaScript? y
Do you want a folder for CSS? y

Created ./awesomeco
Created ./awesomeco/[Link]
Created ./awesomeco/js/
Created ./awesomeco/css/

Constraints
 Prompt the user for site name and author.
 Ask the user whether they want JavaScript and CSS folders.
 Generate an [Link] file with the correct <title> and <meta> tags.
 Create folders for the site and optionally for JavaScript and CSS if the user selects them.
Challenges
 Implement the program as a cross-platform script that works on Windows, macOS, and
Linux.
 Extend the program into a web application that generates the site structure and
provides it as a downloadable zip file.
 Add additional optional folders, such as images or assets, and automatically populate
[Link] with links to them.

P a g e 40 | 116
 Task 33: Product Search

Accessing and searching structured product data is simplified by storing it in formats like JSON,
which allows easy parsing and retrieval. This project involves creating a program that prompts
the user for a product name and retrieves the corresponding price and quantity from a JSON
data file. If the product exists, the program displays its details; if it does not, the program
informs the user and prompts again. This project helps practice reading structured data,
searching through it efficiently, and handling dynamic user input.

Example Output
What is the product name? iPad
Sorry, that product was not found in our inventory.

What is the product name? Widget

Name: Widget
Price: $25.00
Quantity on hand: 5
Constraints
 The product data is stored in a JSON file, and the program should use a JSON parser
to extract the values.
 If no product matches the search, prompt the user again for a valid product name.
 Display the product information clearly, including name, price, and quantity.

Challenges
 Make the product search case-insensitive to improve usability.
 If a product is not found, allow the user to add a new product by entering the price
and quantity, then update the JSON file so the new product is immediately available
for future searches.
 Extend the program to handle large product inventories efficiently, and validate inputs
for price and quantity before updating the JSON file.

P a g e 41 | 116
 Task 34: Word Finder

In text processing, it is often necessary to read a file, perform replacements or modifications,

and write the result to a new file. This project involves creating a program that reads an input
file, searches for all occurrences of the word “utilize,” replaces each with “use,” and writes the
modified content to a new file. This exercise helps practice file handling, string manipulation,
and automated text corrections while maintaining the integrity of the original file.

Example Output
Input File content:
One should never utilize the word "utilize" in writing. Use "use" instead.
Output File Content:
One should never use the word "use" in writing. Use "use" instead.
Constraints
 Prompt the user for the name of the output file.
 Write the modified content to a new file, leaving the original file unchanged.

Challenges
 Track the number of replacements made and display the count when the program
finishes.
 Use a configuration file that maps “bad” words to “good” words, rather than hard-
coding the replacement.
 Extend the program to process a folder of files, applying the same replacements to
each file and saving the results separately.

P a g e 42 | 116
 Task 35: Word Frequency Finder

Analyzing the frequency of words in a text is useful for tasks such as creating word clouds, text
analysis, and identifying key terms. This project involves creating a program that reads a text
file, counts the occurrence of each word, and constructs a histogram showing each word
alongside its frequency. The program should display the histogram in descending order of
frequency, allowing users to quickly identify the most commonly used words. This project helps
practice file handling, text processing, and data visualization techniques.

Example Output
Input File([Link])
badger badger badger badger mushroom mushroom
snake badger badger badger
Output on Screen
badger: *******
mushroom: **
snake: *
Constraints
 The histogram should be sorted, with the most frequently used word at the top and
the least frequent at the bottom.
 Accurately count all word occurrences, including multiple instances on the same line.

Challenges
 Implement a graphical version that generates bar charts or other visual representations
of word frequency.
 Test the program with a large text file (e.g., Shakespeare’s Macbeth) and optimize the
algorithm for faster processing.
 Rewrite the program in another programming language and compare the processing
times between implementations.
 Extend the program to ignore common stop words (e.g., "the," "and," "a") to focus on
meaningful content.

P a g e 43 | 116
 Task 36: Who’s in Space?

Real-time information about astronauts currently in space is publicly available through the
OpenNotify API. This project involves creating a program that fetches live data from the API,
including the number of people in space, their names, and the spacecraft they are on. The
program should parse this data and display it in a clear tabular format, allowing users to quickly
see who is in space and on which craft. Working with live API data helps practice HTTP requests,
JSON parsing, and dynamic data presentation.

Example Output
There are 3 people in space right now:

Name | Craft
---------------------------|-------
Gennady Padalka | ISS
Mikhail Kornienko | ISS
Scott Kelly | ISS
Constraints
 Read the data directly from the API each time the program runs; do not use a pre-
downloaded file.
 Parse the JSON response and extract name and craft information for each astronaut.
 Display the data in a tabular format for readability.

Challenges
 Adjust the table column widths dynamically so the header matches the longest value
in each column.
 Group astronauts by craft to avoid repeating the spacecraft name multiple times.
 Sort the results alphabetically by last name, taking care with names that include
multiple spaces or middle names (e.g., “Mary Sue Van Pelt”).
 Extend the program to update automatically at regular intervals or provide a GUI
display that refreshes with live data.

P a g e 44 | 116
 Task 37: Grabbing the Weather

Knowing the current weather can help you plan your day, whether it’s deciding to wear a coat
or grab an umbrella. This project involves creating a program that prompts the user for a city
name and retrieves the current weather data for that location using the OpenWeatherMap API.
The program should display the temperature and other weather details in a clear and
meaningful format. Separating data retrieval from display logic allows for better program
organization and easier maintenance, while working with live API data teaches HTTP requests,
JSON parsing, and dynamic data presentation.

Example Output
Where are you? Chicago IL
Chicago weather:
65 degrees Fahrenheit
Constraints
 Keep the processing of the weather feed separate from the part of the program that
displays results.
 Retrieve the current temperature for the specified city using the OpenWeatherMap API.

Challenges
 Display additional data provided by the API, such as sunrise and sunset times, humidity,
and weather description.
 Convert the wind direction in degrees to descriptive words like “North,” “Southwest,”
or “South-southwest.”
 Develop a scheme to comment on the day, e.g., “It’s a nice day out!” if it’s sunny and
warm.
 Display the temperature in both Celsius and Fahrenheit.
 Provide practical advice, such as whether the user needs a coat or an umbrella, based
on current conditions.

P a g e 45 | 116
 Task 38: Flickr Photo Search

Many online services provide powerful search features that allow users to query and filter
content. This project involves creating a program with a graphical interface that allows a user
to enter a search term and displays photographs matching that term using Flickr’s public photo
feed API. The program should dynamically fetch the relevant images and display them in a
user-friendly interface. This project provides practice with API requests, JSON parsing, GUI
development, and integrating live content into a visual interface.

Example Output
The program should display the photographs in a grid or list format corresponding
to the search string entered by the user. For example, if the user searches for
“sunset,” the GUI should show a collection of sunset photos retrieved from Flickr.

Constraints
 The program must fetch images from Flickr’s public feed each time a search is
performed.
 Use a graphical interface to display the images.
 In JavaScript, this can be done using HTML and the DOM (avoid jQuery or
external frameworks).
 In Java, use Swing for a desktop application or Android for a mobile app.
 If the language lacks a GUI toolkit, generate an HTML page and open it in a
local browser.

Challenges
 If using JavaScript, implement the program with modern frameworks like Angular,
Ember, or React, potentially building versions in each to compare approaches.
 Extend the program to use the Twitter API to fetch and display tweets related to the
search term alongside the images.
 Add features such as clicking on an image to view details, pagination, or filtering by
image attributes (tags, author, date).

P a g e 46 | 116
 Task 39: Movie Recommendations

External APIs provide rich datasets that can be leveraged to build personalized applications.
This project involves creating a program that allows users to search for a movie and displays
key information such as the title, year of release, rating, running time, and synopsis.
Additionally, the program provides a recommendation based on the audience score: if the
score is above 80%, the program recommends watching the movie; if it is below 50%, it advises
avoiding the movie. This exercise helps practice API integration, conditional logic, and
presenting data in a user-friendly way.

Example Output
Enter the name of a movie: Guardians of the Galaxy
Title: Guardians of the Galaxy
Year: 2014
Rating: PG-13
Running Time: 121 minutes
Description: From Marvel...
You should watch this movie right now!
Constraints
 Use the Rotten Tomatoes API ([Link] and obtain a
valid API key.
 Retrieve and display title, year, rating, running time, synopsis, and audience score for
the specified movie.
 Provide recommendations based on the audience score threshold: above 80% = watch,
below 50% = avoid.

Challenges
 Develop a graphical version of the program that displays the movie poster along with
textual rating information.
 Implement a caching mechanism for movie data to reduce repeated API calls, with an
expiration policy to keep the data up to date.
 Extend the program to allow multiple movie searches in one session and maintain a
history of recommendations.

P a g e 47 | 116
 Task 40: Pushing Notes to Firebase

Many external services allow applications not only to read data but also to update and manage
it in real time. Firebase is one such service, offering a JSON-based API that enables developers
to create their own databases for web, mobile, and desktop applications. This project involves
creating a simple command-line application that allows users to save notes to Firebase and
display all existing notes. The application should support commands to add a new note and
to show all stored notes, providing hands-on experience with REST API integration, data
storage, and basic command-line interface design.
Example Output
$ mynotes new Learn how to invert binary trees
Your note was saved.
$ mynotes show
2050-12-31 - Learn how to invert binary trees
2050-12-30 - Notetaking on the command line is cool.
Constraints
 Store the Firebase API key in a configuration file separate from the application code.
 Use Firebase’s REST API ([Link] instead of a prebuilt
client library.
 Implement commands for adding a note (mynotes new <note>) and displaying all
notes (mynotes show).
Challenges
 Extend the application to search and view notes based on keywords or dates.
 Replace the REST API implementation with a Firebase client library to explore more
advanced features.
 Add the ability to tag notes and retrieve them by tag.
 Revisit previous file-handling projects and adapt them to use Firebase for storing and
managing data instead of local files.

P a g e 48 | 116
 Task 41: Creating Your Own Time Service

While consuming external services is common, being able to create and provide your own web
service is a valuable skill. This project involves building a simple web service that returns the
current time as JSON data, allowing other applications or developers to consume it. Alongside
the service, a client application should connect to the web service, parse the JSON response,
and display the current time in a readable format. This exercise provides hands-on experience
with web service creation, JSON handling, and client-server communication.

Example Output
The current time is 15:06:26 UTC January 4 2050.
Constraints
 Ensure that the server response has the content type set to application/json.
 Build the server application with minimal code, focusing on functionality rather than
complexity.
Challenges
 Extend the server to display a random quote instead of the current time. Store multiple
quotes in an array and return one randomly.
 Create a client-side component that displays the quotes in a different language than
the one used on the server.
 Add functionality to allow the client to request the time in different formats or time
zones.

P a g e 49 | 116
 Task 42: Todo List

The Todo List is a classic project for practicing full program design, involving user input, data
persistence, and basic CRUD (Create, Read, Update, Delete) operations. In this project, you will
create a command-line Todo List application that allows users to enter tasks, store them
permanently so they persist across sessions, display all stored tasks, and remove tasks when
completed. Users can continue adding tasks until they provide a blank entry, which signals the
end of input. This project introduces core programming concepts such as data storage, user
interaction, and task management.

Example Output
Enter a task: Buy groceries
Enter a task: Walk the dog
Enter a task:
Your tasks are:
1. Buy groceries
2. Walk the dog
Enter the number of the task you completed: 2
Task "Walk the dog" has been removed.
Remaining tasks:
1. Buy groceries
Constraints
 Store all tasks in a permanent, external data source to ensure persistence across
program runs.
 If using a server-side language, consider using Redis or a similar database.
 You may also use third-party services like Parse or Firebase to store the tasks.
 Do not store blank tasks.
Challenges
 Implement the Todo List as a web application using only front-end technologies,
storing tasks in IndexedDB.
 Build a mobile version (Android or iOS) that connects to a custom backend you
develop, exposing APIs for retrieving the list, adding new items, and marking items as
complete.
 Extend the application with priority levels, due dates, or categories for each task.
 Add search and filter functionality to locate tasks quickly.

P a g e 50 | 116
 Task 43: URL Shortener

The goal of this project is to create a web application that takes a long URL and converts it
into a shortened URL, similar to services like [Link] or [Link]. Users should be able to submit a
long URL through a form, receive a short local URL, and access the long URL via the short URL.
The application should track how many times each short URL is visited and provide a statistics
page for each short URL showing the original long URL, the short URL, and the visit count. This
project emphasizes web development, persistent storage, URL validation, and user interaction.

Example Output
Enter URL to shorten: [Link]

Short URL: [Link]

Visit [Link] to go to your original URL.

Visit [Link] to view statistics:

Short URL: /abc1234

Long URL: [Link]
Number of visits: 5
Constraints
 The application must use a persistent datastore so that short URLs are available across
server restarts. In-memory storage is not allowed.
 The application must validate input URLs to prevent invalid entries.
 Redirects from the short URL must reliably send users to the original long URL.
Challenges
 Detect and handle duplicate URLs, so that the same long URL always maps to the same
short URL.
 Use Redis or RavenDB as the persistent data store.
 Record the date and time of each access to the short URL and generate graphs to
visualize usage over time.
 Implement a RESTful API for creating short URLs and fetching statistics
programmatically.
 Extend the system to support custom short URLs chosen by the user.

P a g e 51 | 116
 Task 44: Text Sharing

The goal of this project is to create a web application that allows users to share short snippets
of text, similar to services like Pastie. Users should be able to enter text in a text area, save it,
and receive a unique URL that can be used to access the text. When someone visits that URL,
the saved text should be displayed along with an option to edit it. If the user chooses to edit,
the text should populate the creation interface so that it can be modified and saved again. The
project emphasizes web development, text storage, URL generation, and user-friendly editing.

Example Output
Enter your text:
--------------------------------
Hello, this is a snippet of text to share!
--------------------------------
[Save]

Text saved! Your unique URL is: [Link]

Visit the URL to see your text:

Hello, this is a snippet of text to share!

[Edit]
Constraints
 Use a slug or hashed value (SHA, MD5, etc.) to generate the URL instead of relying on
a primary key.
 Text must be persistently stored in a data store so it can be retrieved later.
 Editing should copy the text into the creation interface, not overwrite without
confirmation.
Challenges
 Support Markdown formatting for saved text snippets.
 Implement version control, so that edits do not overwrite previous versions but instead
save them as new revisions.
 Create an API that allows external applications (command-line, mobile, or native) to
add new text snippets or view existing ones.
 Extend functionality to allow sharing, searching, or tagging of snippets for easier
organization.

P a g e 52 | 116
 Task 45: Tracking Inventory

The purpose of this project is to create a program that helps users track their personal
inventory. Users should be able to enter details for each item, including the item name, serial
number, and estimated value. The program should store this data persistently and generate
reports in multiple formats, such as HTML and CSV. These reports should display the inventory
in a tabular format, making it easy to view and manage all items. The focus is on data entry,
storage, and generating readable reports for inventory management.

Example Output
Name | Serial Number | Value
----------------------------------------------------
Xbox One | AXB124AXY | $399.00
Samsung TV | S40AZBDE4 | $599.99

Generated reports:
[Link]
[Link]
Constraints
 Store the inventory data in a persistent local data file using JSON, XML, or YAML
format.
 Require that the value field is numeric.
 Ensure that the data can be reliably read and written each time the program runs.

Challenges
 Extend the program to store photos of each item. On mobile devices, allow capturing
images using the device camera.
 Implement a search feature so users can locate items quickly by name, serial number,
or other attributes.
 Add functionality to sort or filter items by value, name, or date added.
 Allow export to additional formats such as PDF or Excel for more flexible reporting.

P a g e 53 | 116
 Task 46: Trivia App

The goal of this project is to create a multiple-choice trivia application that quizzes the player
using questions stored in a local file. Each question should include the correct answer and
several distractors (wrong answers). The program should randomly select questions and
randomize the order of answers when presenting them to the player. The player’s score should
be tracked, and the game should end if the player selects an incorrect answer. This application
emphasizes file handling, randomization, and interactive gameplay in a simple quiz format.

Example Output
Question: What is the capital of France?
A) Berlin
B) Paris
C) Rome
D) Madrid
Enter your answer: B
Correct! Next question:
Question: Who wrote 'Hamlet'?
A) Shakespeare
B) Dickens
C) Tolkien
D) Hemingway
Enter your answer: D
Incorrect! Game over.
Your score: 1
Constraints
 Store all questions, answers, and distractors in a local data file (such as JSON, CSV, or
plain text).
 Do not use a key-value store or relational database for storing questions.
 Ensure that each game randomly selects questions and shuffles answer options each
time.

Challenges
 Add a difficulty level to each question, and present increasingly difficult questions as
the player progresses.
 Implement a question management mode that allows an administrator (parent,
teacher, or user) to add, edit, or remove questions and answers.
 Expand to a graphical or web-based version with buttons for answer choices and real-
time score tracking.
 Implement timed questions to increase game challenge and engagement.

P a g e 54 | 116
 Task 47: OCR Digit Decoder

Bonny Brain receives scanned lists of numbers that need to be converted into usable electronic
data. These scans are first processed by an OCR recognizer, which outputs ASCII text
representing the numbers. Each digit from 0–9 follows a fixed ASCII-art style pattern with
multiple rows and columns. However, the OCR output can be inconsistent, with irregular
spacing between digits and sometimes missing trailing spaces. The challenge is to process
such ASCII text input and reconstruct the actual sequence of digits into a valid integer.

Example Output
Input (OCR scan):
4 4 77777 11 11 4 4 22
4 4 7 111 111 4 4 2 2
4444 7 11 11 4444 2
4 7 11 11 4 2
4 7 11l1 11l1 4 2222

Output (reconstructed number):

471142
Constraints
 The input consists of 5 rows of ASCII-art representing numbers.
 Each digit follows a predefined ASCII structure for 0–9.
 There may be extra spaces between digits or missing spaces after the last digit.
 Input size can vary depending on how many digits are present in the scanned line.
 Only digits (0–9) are represented; no alphabetic characters or special symbols are
included.

Challenges
 Pattern Matching: Each digit’s ASCII-art must be correctly identified despite spacing
inconsistencies.
 Handling Noise: Extra spaces between digits or missing trailing spaces must not cause
recognition errors.
 Alignment Issues: Ensuring that the five-line ASCII-art representation aligns properly
for parsing.
 Efficiency: The algorithm should be able to handle longer digit sequences without
excessive processing time.
 Robustness: The solution must reliably differentiate between visually similar digits (e.g.,
1 vs. 7) in ASCII-art form.

P a g e 55 | 116
 Task 48: Time Converter

Clever clock often receives text messages that include times written in the 12-hour AM/PM
format. However, she prefers time to always be expressed in the 24-hour military format. This
requires converting every time expression in the text, regardless of whether it is written in
uppercase (AM/PM) or lowercase (am/pm), or even with punctuation like (a.m./p.m.). The
conversion must correctly handle special cases, such as 12:00 AM being 00:00 and 12:00 PM
being 12:00. The goal is to automatically transform any string containing 12-hour formatted
times into a string with 24-hour formatted times.

Example Output
Input:
"We raid the harbor at 11:00 PM and meet on the amusement mile at 1:30 AM."
Output:
"We raid the harbor at 2300 and meet on the amusement mile at 0130."

Input:
"Get out of bed: 12:00AM, bake a cake: 12 PM."

Output:
"Get out of bed: 0000, bake a cake: 1200."
Constraints
 Input strings may contain multiple time expressions in AM/PM format.
 AM/PM indicators can appear in any case (e.g., am, PM, a.m., p.m.).
 Midnight (12:00 AM) must be converted to 00:00.
 Noon (12:00 PM) must remain 12:00.
 Output must remove the colon and represent the time in HHMM format.
 The rest of the string (non-time text) must remain unchanged.

Challenges
 Pattern Detection: Correctly identifying times in various AM/PM formats inside
arbitrary strings.
 Case Insensitivity & Punctuation: Handling inputs like a.m., A.M., pm, etc.
 Edge Cases: Converting times around 12:00 correctly (e.g., 12 AM → 0000, 12 PM →
1200).
 Multiple Matches: Managing multiple time conversions in a single sentence without
altering unrelated text.
 Robustness: Ensuring that malformed or incomplete time patterns do not cause
incorrect replacements.

P a g e 56 | 116
 Task 49: Address Line Splitter

Captain Cook’s software needs to process multi-line addresses, where each address consists
of three or four lines. The lines represent name, street, city, and optionally country. Different
systems use different newline conventions—Unix uses \n, Windows uses \r\n, and old
teleprinters could use \r or \n\r. The task is to split a string containing an address into its
individual lines, assign them to the respective variables, and provide a default value of
"Drusselstein" for the country if it is missing. Finally, the address should be reassembled as a
single CSV-style line separated by semicolons.

Example Output
Input:
"Boots and Bootles\n21 Pickle Street\n424242 Douglas\nArendelle"
Output:
"Boots and Bootles;21 Pickle Street;424242 Douglas;Arendelle"
Input:
"Doofenshmirtz Evil Inc.\nStrudelkuschel 4427\nDanville"
Output:
"Doofenshmirtz Evil Inc.;Strudelkuschel 4427;Danville;Drusselstein"

Constraints
 Address strings contain three or four lines only.
 Line separators may be \n (LF), \r (CR), \r\n (CR LF), or \n\r (LF CR).
 The first three lines (name, street, city) are mandatory.
 The fourth line (country) is optional.
 If the country line is missing, it should default to "Drusselstein".
 Output should be a single line with semicolon-separated values.

Challenges
 Handling Multiple Line Separators: Correctly splitting the string regardless of whether
the address uses \n, \r, \r\n, or \n\r.
 Optional Data: Properly detecting missing country lines and assigning the default
value.
 Consistency: Ensuring the CSV output format always contains exactly four fields.
 Robust Parsing: Avoiding errors if there are extra blank lines or irregular spacing.
 String Reassembly: Maintaining the order of lines and correctly inserting semicolons.

P a g e 57 | 116
 Task 50: Word Reverser

During the transmission of a message, all the words got reversed, making the sentence
unreadable. To restore the original message, each reversed word needs to be flipped back
while preserving the overall sentence structure. The task is to split the sentence into words
(using spaces and punctuation marks as separators), reverse each word individually, and then
combine them back into a readable format.

Example Output
Input:
"erehW did eht etarip esahcrup sih kooh? tA eht dnah-dnoces pohs!"
Output:
"Where did the pirate purchase his hook At the hand second shop"
Constraints
 Words are separated by spaces and/or punctuation marks.
 All words are fully reversed individually.
 Punctuation marks can be ignored in the output.
 The input string can contain multiple sentences.
 The algorithm should preserve the original word order after reversing each word.

Challenges
 Word Separation: Accurately identifying word boundaries when spaces and
punctuation marks are mixed.
 Reversing Words: Correctly reversing each individual word while maintaining proper
order in the sentence.
 Ignoring Punctuation: Ensuring that punctuation does not interfere with the word
reversal process.
 Multiple Sentences: Handling inputs with more than one sentence correctly.
 Robustness: Avoiding errors with unusual spacing or special characters within the text.

P a g e 58 | 116
 Task 51: Score Validator

Captain Veer enjoys archery and records his scores, which range from 0 to 10, in a sequence.
Along with the scores, he uses relation signs <, >, and = to describe whether his next attempt
is better, worse, or the same. Goldy Goldfish is assigned the task of verifying whether these
relation signs are applied correctly. The goal is to write a program that takes such a string as
input and checks if the entire sequence of relations between the numbers holds true. If all
relations are valid, the program should return true; otherwise, it should return false.

Example Output
Input:
1 < 2 > 1 < 10 = 10 > 2
Output:
true
Input:
1<1
Output:
false
Input:
1<
Output:
false
Input:
1
Output:
true
Constraints
 Input will be a string containing numbers (0–10) separated by relation signs <, >, or =.
 The string must follow a valid alternating pattern of number–operator–number.
 A string with a single number is valid and should return true.
 Trailing operators without a number make the expression invalid.

Challenges
 Correctly parsing the string into alternating numbers and operators.
 Handling incomplete or malformed expressions.
 Evaluating the sequence step by step while maintaining logical consistency.
 Dealing with edge cases such as single-number inputs, repeated equality (=) signs, and
invalid operator placement.

P a g e 59 | 116
 Task 52: Contact Book

A Contact Book is a basic yet essential application that helps users store, manage, and retrieve
personal or professional contacts efficiently. The system should support CRUD operations—
Create, Read, Update, and Delete—allowing users to add new contacts, view existing ones,
modify details, and remove outdated or incorrect entries. Each contact typically includes
attributes such as name, phone number, email, and address. By implementing a contact book
with CRUD functionality, learners gain hands-on experience in designing data structures,
applying file handling or database concepts, and understanding user-centric application
development.

Example Output
--- Contact Book ---
1. Add Contact
2. View All Contacts
3. Search Contact
4. Update Contact
5. Delete Contact
6. Exit
Enter your choice: 1

Enter Name: Alice

Enter Phone: 9876543210
Enter Email: alice@[Link]
Enter Address: New York
Contact saved successfully!

--- Contact Book ---

Enter your choice: 2
Contacts:
1. Alice | 9876543210 | alice@[Link] | New York
Constraints
 The application should allow storing multiple contacts without duplication of phone
numbers (unique constraint).
 Input fields such as phone number and email must follow valid formats.
 Maximum storage capacity depends on chosen implementation (e.g., arrays, lists, or
database).
 CRUD operations must execute in a reasonable time (ideally O(1) for hash-based
lookups, O(n) for list searches).
 Application should handle invalid inputs gracefully without crashing.

Challenges
 Ensuring uniqueness of contacts (avoiding duplicates based on phone/email).
 Implementing efficient search and update operations as the number of contacts grows.
 Managing persistent storage so that data is not lost after program termination (file
handling or databases).
 Handling edge cases, such as updating non-existent contacts or deleting from an
empty list.
 Designing a user-friendly interface that is intuitive and supports easy navigation.
P a g e 60 | 116
 Task 53: ChatMate

A Simple Chatbot ChatMate is a text-based application that simulates basic human–computer

conversation. The chatbot interacts with users by responding to predefined queries such as
greetings, questions, or simple commands. It works on a rule-based approach, where the user’s
input is matched against a set of predefined keywords, and the chatbot provides appropriate
responses. If the input does not match, a default reply is given. The purpose of this project is
to demonstrate how conversational interfaces can be developed in Java using simple control
structures, string handling, and data storage, laying a foundation for more advanced chatbot
systems.

Example Output
--- ChatMate Application ---
Type 'bye' to exit.
You: hi
Bot: Hello! How can I help you today?
You: what is your name
Bot: I am your friendly chatbot.
You: tell me a joke
Bot: Why don’t programmers like nature? Too many bugs!
You: bye
Bot: Goodbye! Have a great day!
Constraints
 The chatbot works only with predefined keywords and cannot understand free-form
natural language.
 Input should be text-based and simple; complex sentences may not be recognized.
 Only a limited set of commands (like greetings, asking name, joke, etc.) are supported.
 User must type “bye” or equivalent exit command to end the conversation.
 Runs on a terminal/console environment; no graphical interface is provided.

Challenges
 Designing a sufficient set of keywords and responses to make the chatbot feel
engaging.
 Handling variations in user input (e.g., “Hello”, “Hi there”, “Hey bot”) without missing
intent.
 Avoiding repetitive or generic responses that may reduce user satisfaction.
 Maintaining user interaction flow while keeping the program simple and lightweight.
 Scaling the chatbot beyond basic responses to support more complex features like
context or memory.

P a g e 61 | 116
 Task 54: Cook Master

A Recipe Book is designed to store, manage, and retrieve cooking recipes efficiently. The
system allows users to perform CRUD operations—Create, Read, Update, and Delete—on
recipes, which include details such as recipe name, ingredients, preparation steps, cooking
time, and servings. This application aims to provide an organized platform for users to save
their favorite recipes, discover new ones, and modify or remove recipes as needed. By
developing a Recipe Book, learners gain practical experience with data structures, file handling
or database management, and designing user-friendly interfaces for real-world applications.

Example Output
--- Recipe Book ---
1. Add Recipe
2. View All Recipes
3. Search Recipe
4. Update Recipe
5. Delete Recipe
6. Exit
Enter your choice: 1
Enter Recipe Name: Chocolate Cake
Enter Ingredients: Flour, Cocoa, Sugar, Eggs, Butter
Enter Steps: Mix ingredients, Bake at 350F for 30 mins
Enter Cooking Time: 45 mins
Enter Servings: 8
Recipe saved successfully!
--- Recipe Book ---
Enter your choice: 2
Recipes:
1. Chocolate Cake
Ingredients: Flour, Cocoa, Sugar, Eggs, Butter
Steps: Mix ingredients, Bake at 350F for 30 mins
Cooking Time: 45 mins
Servings: 8
Constraints
 Recipe names must be unique to avoid duplication.
 Ingredients and steps should be properly formatted (comma-separated or stepwise).
 Maximum storage depends on chosen implementation (e.g., lists, files, or database).
 CRUD operations should execute efficiently, even for a large number of recipes.
 User input should be validated to prevent missing or incomplete information.

Challenges
 Ensuring recipe uniqueness and preventing duplicates.
 Handling complex recipes with multiple ingredients and step-by-step instructions.
 Efficiently searching, updating, or deleting recipes from a large collection.
 Designing a clear and user-friendly interface for easy navigation.
 Implementing persistent storage so that recipes remain available across application
restarts.

P a g e 62 | 116
 Task 55: DriveEase

A DriveEase application designed to manage the operations of a car rental business efficiently.
The system allows users to browse available vehicles, rent a car, return a car, and manage
vehicle details. Administrators can add new cars, update car information, and remove vehicles
from the fleet. This project provides practical experience in implementing CRUD operations,
handling user inputs, and managing data related to inventory and transactions. It simulates
real-world operations of a rental service, ensuring that users can easily find available cars, track
rentals, and maintain accurate records of their fleet.

Example Output
--- Car Rental System ---
1. View Available Cars
2. Rent a Car
3. Return a Car
4. Add New Car
5. Update Car Details
6. Remove Car
7. Exit
Enter your choice: 1
Available Cars:
1. Toyota Corolla | Sedan | 2020 | $50/day
2. Honda Civic | Sedan | 2019 | $45/day
3. Ford Explorer | SUV | 2021 | $80/day
Enter your choice: 2
Enter Car ID to rent: 1
Enter Rental Days: 3
Car rented successfully! Total cost: $150
--- Car Rental System ---
Enter your choice: 3
Enter Car ID to return: 1
Car returned successfully!
Constraints
 Each car must have a unique ID to track rentals and availability.
 Users must provide valid inputs for renting and returning cars.
 Rental cost is calculated based on car type, duration, and pricing rules.
 Maximum fleet size depends on the chosen implementation (e.g., array, list, or
database).
 The system should prevent double booking of the same car at the same time.

Challenges
 Ensuring that the car inventory is accurately updated after rentals and returns.
 Handling concurrent rentals or multiple users trying to rent the same car.
 Calculating rental costs dynamically based on car type, duration, and additional
options.
 Providing a user-friendly interface for browsing, renting, and managing cars.
 Implementing persistent storage to maintain rental records and car availability across
sessions.
P a g e 63 | 116
 Task 56: FinTrack

A Bank Account Management System FinTrack is designed to simulate the operations of a

banking system. The system allows users to create accounts, deposit and withdraw money,
check balances, and view transaction history. Administrators can manage multiple accounts,
update account details, and perform essential banking operations. This project provides
hands-on experience with object-oriented programming, data management, and
implementing real-world business logic in a structured way. It helps learners understand how
to model accounts, handle transactions securely, and maintain accurate records, simulating a
simplified version of real banking systems.

Example Output
--- Bank Account Management System ---
1. Create New Account
2. Deposit Money
3. Withdraw Money
4. Check Balance
5. View Transaction History
6. Exit
Enter your choice: 1
Enter Account Holder Name: John Doe
Enter Initial Deposit: 5000
Account created successfully! Account Number: 101
Enter your choice: 2
Enter Account Number: 101
Enter Deposit Amount: 2000
Deposit successful! Current Balance: 7000
Enter your choice: 4
Enter Account Number: 101
Current Balance: 7000
Enter your choice: 6
Thank you for using the Bank Account Management System!
Constraints
 Each bank account must have a unique account number.
 Transactions should not allow overdrafts beyond the available balance.
 Inputs for amounts and account details must be valid and properly formatted.
 Maximum number of accounts depends on the implementation (array, list, or
database).
 The system must ensure data consistency, especially for concurrent deposits and
withdrawals.
Challenges
 Preventing inconsistencies in account balances during multiple transactions.
 Ensuring secure and accurate handling of deposits and withdrawals.
 Managing transaction history for all accounts efficiently.
 Designing a user-friendly interface to access different banking operations.
 Implementing persistent storage so that account information and transactions are
retained across sessions.
P a g e 64 | 116
 Task 57: Room Reserve
A Hotel Booking System is designed to manage hotel reservations efficiently. The system
allows users to search for available rooms, make bookings, cancel reservations, and view
booking details. Administrators can add new rooms, update room information, and manage
bookings to ensure availability and proper allocation. This project provides practical
experience in implementing CRUD operations, handling user inputs, and managing data
related to inventory and reservations. It simulates real-world hotel operations, enabling users
to reserve rooms seamlessly while helping hotel management maintain organized records of
room occupancy and bookings.

Example Output
--- Hotel Booking System ---
1. View Available Rooms
2. Book a Room
3. Cancel Booking
4. Add New Room
5. Update Room Details
6. Exit
Enter your choice: 1
Available Rooms:
1. Room 101 | Single | $50/night
2. Room 102 | Double | $80/night
3. Room 201 | Suite | $150/night
Enter your choice: 2
Enter Room Number to book: 102
Enter Customer Name: Alice
Booking successful! Room 102 reserved for Alice.
Enter your choice: 3
Enter Booking ID to cancel: 1
Booking canceled successfully!
Enter your choice: 6
Thank you for using the Hotel Booking System!

Constraints
 Each room must have a unique room number to track bookings accurately.
 Users must provide valid inputs for booking, cancellation, and room management.
 The system should prevent double booking of the same room.
 Maximum number of rooms and bookings depends on the chosen implementation
(e.g., list, database).
 Room rates and availability must be updated correctly after every transaction.

Challenges
 Ensuring accurate room availability and preventing double bookings.
 Managing concurrent booking requests efficiently if multiple users are involved.
 Keeping track of booking history and customer details.
 Calculating costs dynamically based on room type, duration, and additional services.
 Designing a user-friendly interface that allows easy navigation through booking,
cancellation, and room management operations.
P a g e 65 | 116
 Task 58: Smart File Organizer

A Smart File Organizer is a utility designed to automatically organize files within a directory
based on their types, such as documents, images, videos, or audio files. The system scans a
given folder, identifies the file type using extensions, and moves files into corresponding
subfolders for better organization. This project provides hands-on experience in file handling,
directory management, and automation using programming languages like Java or Python. It
aims to reduce manual effort in managing cluttered folders and helps users maintain a clean
and structured file system efficiently.

Example Output
Enter the path of the directory to organize: C:/Users/John/Downloads
Organizing files...
Moved 10 images to /Images
Moved 5 documents to /Documents
Moved 3 videos to /Videos
Moved 2 audio files to /Audio
Moved 1 archive file to /Archives
File organization completed successfully!
Constraints
 The script must have read/write permissions for the target directory.
 Files are organized based on their extensions; unknown extensions may be placed in
an “Others” folder.
 The script should not overwrite existing files with the same name in target folders.
 Performance may vary based on the number of files and size of the directory.
 The directory path must be valid and accessible for the script to run successfully.

Challenges
 Ensuring files are moved safely without data loss or overwriting existing files.
 Handling large directories efficiently without slowing down the system.
 Correctly identifying file types even if extensions are missing or unusual.
 Providing clear feedback to the user about what files were organized and where.
 Making the script platform-independent if needed (Windows, Linux, Mac).

P a g e 66 | 116
 Task 59: ExpensePro
An ExpensePro help users to monitor and manage their personal finances effectively. The
system allows users to record daily expenses, categorize them (e.g., food, travel, utilities), view
summaries, and generate reports to understand spending patterns. Users can add, update, or
delete expense entries, providing a clear picture of their financial habits over time. This project
provides hands-on experience with CRUD operations, data handling, and basic analytics while
teaching the importance of budgeting and financial management. It simulates real-world
financial tracking, enabling users to make informed decisions about their spending and
savings.
Example Output
--- Expense Tracker ---
1. Add Expense
2. View All Expenses
3. Update Expense
4. Delete Expense
5. View Expense Summary
6. Exit
Enter your choice: 1
Enter Date (YYYY-MM-DD): 2025-09-26
Enter Category: Food
Enter Description: Lunch at Cafe
Enter Amount: 250
Expense added successfully!
Enter your choice: 2
Expenses:
1. 2025-09-26 | Food | Lunch at Cafe | $250
Enter your choice: 5
Expense Summary:
Food: $250
Travel: $0
Utilities: $0
Total Expenses: $250
Enter your choice: 6
Thank you for using the ExpensePro!
Constraints
 Each expense entry should have a valid date, category, and amount. Categories must
be predefined or user-defined but consistent for proper tracking.
 Maximum number of expense records depends on the implementation. The system
should handle invalid inputs gracefully without crashing.
 Summaries and reports must accurately reflect all recorded expenses.
Challenges
 Ensuring accurate addition, updating, and deletion of expense entries.
 Categorizing expenses correctly and generating meaningful summaries. Handling a
large number of entries efficiently without performance issues.
 Providing a user-friendly interface for easy navigation and data entry. Implementing
persistent storage so that expense data is retained across sessions.
P a g e 67 | 116
 Task 60: Comment Extractor

The Filter Comments from Lists project focuses on processing structured log data to extract
only the relevant comments. In a logbook with recurring entries of four lines each—Magnetic
declination, Speed of water current, Weather, and Comments—the goal is to retain only the
fourth line of every group, which contains the desired comment. The project involves
implementing a method that systematically removes the first three entries from each set of
four lines, ensuring that only the comments remain. This exercise provides practical experience
with list manipulation, indexing, and exception handling in Java. It also demonstrates how to
process structured repeating patterns in data efficiently.

Example Output
Input:
["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4", "C1", "C2", "C3", "C4"]
Output:
["A4", "B4", "C4"]
Input:
[]
Output:
[]
Input:
["A1"]
Output:
Exception: Illegal size 1 of list, must be divisible by 4
Constraints
 The input list size must be divisible by 4; otherwise, an exception should be thrown.
 Each group of four entries must maintain the order: first three lines are data, fourth line
is the comment.
 Empty lists are valid and should remain unchanged.
 The method must handle lists of arbitrary length while maintaining efficiency.

Challenges
 Correctly handling lists whose size is not divisible by 4 by throwing an appropriate
exception.
 Efficiently iterating and removing items from the list while avoiding
ConcurrentModificationException.
 Ensuring the relative order of the extracted comments is preserved.
 Handling edge cases, such as empty lists or very large lists, without errors or
performance degradation.
 Designing the method to be reusable for different types of structured logs with similar
patterns.

P a g e 68 | 116
 Task 61: Eating with Friends

The Eating with Friends: Compare Elements, Find Commonalities project focuses on analyzing
the interests of guests seated in a circle at a party. Each guest has three boolean attributes—
likesToShoot, likesToGamble, and likesBlackmail. The goal is to ensure that every guest has at
least one neighbor with whom they share at least one common interest. The project involves
implementing a method that checks the list of guests and identifies whether this condition is
met. If all guests share at least one property with a neighbor, the method returns -1; otherwise,
it returns the index of the first guest who does not share any property with their neighbors.
This project provides practical experience in list processing, object comparison, circular
indexing, and implementing rules based on multiple object properties.

Example Output
Input:
List<Guest> guests = [Link](
new Guest(true, false, true),
new Guest(false, false, true),
new Guest(true, false, false)
);
Output:
-1
Input:
List<Guest> guests = [Link](
new Guest(true, false, true),
new Guest(false, false, false),
new Guest(true, false, false)
);
Output:
1
Constraints
 The list of guests may contain any number of entries, including zero.
 Guest attributes are boolean values representing interests; new properties may be
added if needed.
 Guests are arranged in a circular seating, meaning the first and last guests are
neighbors.
 The method must efficiently compare properties for all guests without unnecessary
repetitions.

Challenges
 Correctly handling circular neighbor relationships (first and last guest are adjacent).
 Comparing multiple boolean properties for each pair of neighbors efficiently.
 Returning the index of the first guest without shared interests in case of violations.
 Extending the Guest type with additional properties while maintaining correctness of
the method.
 Ensuring the solution scales well for large guest lists and avoids off-by-one or
boundary errors.

P a g e 69 | 116
 Task 62: Check Lists

The Check Lists for the Same Order of Elements project focuses on verifying the relative order
of elements in circular arrangements. In this scenario, two lists of names represent individuals
seated in a circle, and the goal is to determine whether the names in both lists appear
consecutively and in the same sequence, accounting for the circular nature of seating (where
the last person is adjacent to the first). The method should return true if the sequences match
under any rotation, and false otherwise. This project provides practical experience with list
manipulation, circular data handling, sequence comparison, and algorithmic thinking to
handle edge cases such as repeated names or different starting points.

Example Output
Input:
List<String> names1 = [Link]("Alexandre", "Charles", "Anne", "Henry");
List<String> names2 = [Link]("Alexandre", "Charles", "Anne", "Henry");
Output:
true
Input:
List<String> names1 = [Link]("Alexandre", "Charles", "Anne", "Henry");
List<String> names2 = [Link]("Alexandre", "Charles", "Henry", "Anne");
Output:
false
Constraints
 Both lists must be non-empty and contain at least one name.
 Names may repeat in the list, and duplicates must be handled correctly.
 The method must account for circular seating, treating the last and first elements as
consecutive.
 The comparison should be order-sensitive, meaning all names must appear in the same
relative sequence.
 The method should handle lists of arbitrary length efficiently.

Challenges
 Correctly handling circular rotations so that sequences match regardless of starting
point.
 Comparing lists that contain duplicate names without producing false positives.
 Ensuring efficient comparison for long lists while avoiding unnecessary iterations.
 Dealing with edge cases such as empty lists or lists of different sizes.
 Maintaining readability and correctness while implementing a robust algorithm for
circular sequence checking.

P a g e 70 | 116
 Task 63: Weather Tracker

The Weather Tracker project focuses on analyzing a list of weather data to identify the longest
consecutive sequence of the same weather type. Given a list of weather entries, the task is to
determine which weather occurs the most times consecutively, how many times it occurs in
that sequence, and the starting index of that sequence. A WeatherOccurrence record is used
to store this information, containing the weather type, the number of consecutive occurrences,
and the starting index. The project provides practical experience with list traversal, handling
null values, sequence detection, and working with custom data structures in Java. It also
teaches how to efficiently process sequential data and identify patterns in lists.

Example Output
Input:
List<String> weather = [Link](
"Rain", "Sun", "Rain", "Rain", "Hail", "Snow", "Storm", "Sun", "Sun", "Rain", "Rain",
"Sun"
);
Output:
WeatherOccurrence(weather="Sun", occurrences=2, startIndex=7)
Input:
List<String> weather = [Link](
"Rain", "Rain", "Rain", "Sun", "Sun", "Sun"
);
Output:
WeatherOccurrence(weather="Rain", occurrences=3, startIndex=0)
Constraints
 The input list may contain null elements, which should be handled appropriately.
 The method should process lists of any length, including empty lists.
 If multiple weather types have the same longest consecutive occurrence, the method
can return any one of them.
 The list may contain repeated entries, but only consecutive repetitions count toward
the sequence.
 The method should operate efficiently without unnecessary iterations or memory
overhead.

Challenges
 Correctly handling null elements in the list without causing exceptions.
 Accurately identifying consecutive sequences and tracking both their length and
starting index.
 Handling edge cases, such as empty lists or sequences of equal length for different
weather types.
 Ensuring the solution scales efficiently for large lists with many weather entries.
 Returning results in a structured way using a custom record while maintaining clarity
and correctness.

P a g e 71 | 116
 Task 64: Receipt Master

The Receipt Master project focuses on creating a programmatic receipt system that
consolidates items, calculates totals, and formats output in a user-friendly manner. Each
receipt consists of multiple items, each having a name and a gross price in cents. The project
requires implementing a Receipt class with a nested Item class. The receipt should consolidate
duplicate items—entries with the same name and price—by showing the quantity multiplied
by the item price. Additionally, the receipt should display each item’s total and the overall sum,
formatted according to a specified locale’s currency conventions. This project provides
practical experience with object-oriented design, nested classes, data aggregation, and
formatting outputs for user readability.

Example Output
Input:
Receipt receipt = new Receipt();
[Link](new [Link]("Peanuts", 222));
[Link](new [Link]("Lightsaber", 19999));
[Link](new [Link]("Peanuts", 222));
[Link](new [Link]("Logbook", 1000));
[Link](new [Link]("Peanuts", 222));
[Link](receipt);
Output:
3 × Peanuts 2,22 € 6,66 €
1 × Lightsaber 199,99 € 199,99 €
1 × Logbook 10,00 € 10,00 €

Sum: 216,65 €
Constraints
 Each item must have a name and a price in cents.
 Duplicate items with the same name and price should be consolidated in the output.
 Items with the same name but different prices are treated as separate entries.
 The receipt must correctly calculate totals for individual items and the overall sum.
 Currency formatting must use [Link](locale) for
consistency.
 The system should handle an arbitrary number of items efficiently.

Challenges
 Correctly consolidating duplicate items while preserving accurate quantities and totals.
 Ensuring proper currency formatting based on the chosen locale.
 Managing nested class design (Item inside Receipt) and maintaining clean code
structure.
 Handling edge cases such as empty receipts or items with the same name but different
prices.
 Displaying the output in a neat, readable, and aligned format that resembles a real-
world receipt.

P a g e 72 | 116
 Task 65: Veggie Cheeser

The Veggie Cheeser project focuses on modifying a list of recipe ingredients by

programmatically adding “cheese” around vegetables. The task requires creating a method
insertCheeseAroundVegetable(List<String> ingredients) that inserts the ingredient “cheese”
before or after each occurrence of a vegetable in the list. A fixed set of vegetables is predefined
for the program to identify. The list must remain modifiable so that elements can be inserted
dynamically without creating a new list. This project provides practical experience with list
manipulation, iteration, element insertion, and maintaining order within a mutable collection,
simulating a real-world scenario of dynamically enhancing a recipe.

Example Output
Input:
[Gnocchi, zucchini, peppers, cream, broth, milk, butter, onion, tomato, salt, bell
pepper]
Output:
[Gnocchi, zucchini, cheese, peppers, cheese, cream, broth, milk, butter, onion,
cheese, tomato, cheese, salt, bell pepper]
Input:
[Cheese]
Output:
[Cheese]
Constraints
 The method must operate on a modifiable list and insert elements directly into it.
 A fixed set of vegetables should be predefined for the program to identify.
 Non-vegetable ingredients remain unchanged.
 The order of the original ingredients must be preserved.
 The solution should handle lists of any length, including empty lists or lists without
vegetables.

Challenges
 Correctly inserting “cheese” around each vegetable while maintaining the correct order
in the list.
 Handling multiple consecutive vegetables without causing insertion errors or skipping
elements.
 Ensuring the list is modifiable and updates occur in-place rather than creating new lists
unnecessarily.
 Dealing with edge cases such as empty lists, lists containing only vegetables, or lists
with repeated ingredients.
 Efficiently iterating through the list while safely modifying it to prevent concurrent
modification issues.

P a g e 73 | 116
 Task 66: Musical Chairs

The Musical Chairs project replicates the traditional party game of musical chairs using lists in
Java. At a birthday party, guests sit on chairs and move around them when the music starts,
and this behavior is modeled by storing guest names in a list and rotating the elements to
simulate movement. The project is divided into two parts: the first part focuses on building a
MusicalChairs class that stores guest names, enables rotation of the list by a specified distance,
and displays the updated list in a comma-separated format, while the second part extends the
simulation by introducing elimination, where the list is rotated, the last guest is removed in
each round, and the process continues until only one guest remains, who is declared the
winner. This project offers practical experience in list manipulation, applying Java’s Collections
methods, handling randomization, and implementing iterative elimination logic in a fun and
engaging way.

Example Output
Input:
MusicalChairs musicalChairs = new MusicalChairs("Laser", "Milka", "Popo",
"Despot");
[Link](2);
[Link](musicalChairs);

Output:
Popo, Despot, Laser, Milka
Constraints
 The list of guest names may initially be empty.
 The rotation distance can be any integer (positive or negative).
 Rotation should be done in-place using Java’s Collections utilities.
 During the play() method, the distance for each rotation is randomly generated.
 The process must stop once only one guest remains in the list.

Challenges
 Handling empty lists gracefully, ensuring the program does not crash when no guests
are provided.
 Implementing circular list rotation correctly, ensuring elements wrap around as in the
real game.
 Designing the elimination logic (rotate and remove) without introducing index errors.
 Incorporating randomness in the rotation distance for realistic simulation while
ensuring termination.
 Keeping the program efficient and readable, especially when scaling for larger guest
lists.

P a g e 74 | 116
 Task 67: Compatibility Checker

The Compatibility Checker – Common Hobbies Analysis project simulates a scenario where
two individuals list their hobbies to check how compatible they are. Each person’s hobbies are
stored in a set of strings, and the goal is to determine the similarity between the two sets
based on their shared hobbies. By finding the intersection of the sets, the program can
calculate the percentage of common interests compared to the total hobbies. The project also
explores different approaches to measuring compatibility, such as set operations, Jaccard
similarity, or other comparison techniques. This provides hands-on practice in using Java
collections, particularly sets, to handle unique elements, perform comparisons, and calculate
percentages.

Example Output
Input:
Set<String> hobbies1 = [Link](
"Candy making", "Camping", "Billiards", "Fishkeeping", "Eating",
"Action figures", "Birdwatching", "Axe throwing"
);
Set<String> hobbies2 = [Link](
"Axe throwing", "Candy making", "Camping",
"Action figures", "Case modding", "Skiing", "Satellite watching"
);
Output:
Common hobbies: [Candy making, Camping, Action figures, Axe throwing]
Similarity Percentage: 40.0%
Constraints
 Each list of hobbies is represented as a Set<String> to avoid duplicates.
 The similarity percentage is calculated based on the size of the intersection compared
to the union or one of the sets.
 Both sets can be of different sizes, and either may be empty.
 Only exact string matches count as common hobbies.

Challenges
 Correctly handling cases where one or both sets are empty.
 Ensuring that percentage similarity is computed consistently (e.g., intersection vs.
union or relative to one person’s list).
 Managing string comparisons, which may be case-sensitive.
 Exploring multiple similarity measures (e.g., Jaccard index, cosine similarity, or
percentage overlap).
 Making the solution scalable if the sets of hobbies grow very large.

P a g e 75 | 116
 Task 68: Array-to-Map Converter

The Array-to-Map Converter project focuses on transforming a two-dimensional array of

strings into a [Link]. Unlike flexible collection types such as List and Set, which allow
easy data transfer using built-in methods like addAll(Collection), the Map interface requires
explicit handling of key-value pairs. In this project, the first element of each inner array is
treated as the key, and the second element as the value. Duplicate keys overwrite earlier
entries, ensuring the map contains only the latest value for each key. Additionally, the
implementation enforces strict validation rules: keys and values cannot be null, and such cases
should result in exceptions. This project provides practical experience in array manipulation,
exception handling, and the use of maps for key-value storage in Java.

Example Output
Input:
String[][] array = {
{"red", "#FF0000"},
{"green", "#00FF00"},
{"blue", "#0000FF"}
};
Map<String, String> colorMap = convertToMap(array);
[Link](colorMap);
Output:
{red=#FF0000, green=#00FF00, blue=#0000FF}
Constraints
 Each inner array must contain exactly two non-null elements: one key and one value.
 Keys must correctly implement hashCode() and equals() to ensure proper behavior in
the map.
 If duplicate keys exist, the latest entry overwrites the previous one.
 Null keys or values should result in an exception being thrown.
 The input array may be empty, resulting in an empty map.

Challenges
 Handling null keys or values gracefully by raising appropriate exceptions.
 Ensuring duplicate keys are managed correctly, with later values replacing earlier ones.
 Validating that each sub-array has the required two elements before processing.
 Designing the solution to work efficiently for large arrays.
 Maintaining readability and robustness while adhering to Java’s Map interface
requirements.

P a g e 76 | 116
 Task 69: RPN Pocket Calculator

The RPN Pocket Calculator project is designed to simulate a calculator that works with Reverse
Polish Notation (RPN), a postfix mathematical notation where operators follow their operands.
Unlike traditional infix expressions (e.g., 47 + 11), RPN expressions (e.g., 47 11 +) eliminate the
need for parentheses and operator precedence rules, as these are inherently resolved by the
input order. This approach was popularized in Hewlett-Packard calculators in the 1980s and is
also used in systems like PostScript, as it allows easy evaluation using a stack. In this project,
the program tokenizes an input string representing an RPN expression, evaluates it step by
step using stack operations, and outputs the final result. Initially, the program works with a
fixed string for testing, but it can later accept input from the command line to behave like a
real calculator. The implementation also emphasizes error handling for invalid expressions,
incorrect operators, and stack underflow situations, making it a practical exercise in string
processing, stack operations, and exception handling.

Example Output
Input:
12 34 23 + *
Output:
804
Constraints
 Input expressions must be valid RPN strings containing integers and supported
operators (+, -, *, /).
 Tokenization should be done using [Link]() or a Scanner.
 Division by zero must be handled with appropriate error messages.
 Each operator requires two operands; insufficient operands should trigger an error.
 The stack must contain exactly one value at the end of evaluation, which is the final
result.

Challenges
 Handling invalid tokens (anything other than numbers and valid operators).
 Managing stack underflow, where an operator is encountered without enough
operands.
 Handling division by zero safely and clearly reporting errors.
 Ensuring the stack has exactly one value at the end; multiple leftover values indicate an
invalid expression.
 Making the calculator robust to malformed input from the command line while
providing helpful error messages.

P a g e 77 | 116
 Task 70: Forget No Ship

The Forget No Ship project simulates an annual naval exercise where 13 ships, numbered from
10 to 22, must be boarded exactly once. After the exercise, Bonny Brain receives a list of ship
IDs representing the boarding records. However, some reports may include mistakes such as
missing ships or duplicate entries, making it tedious to verify manually. To solve this, the
project introduces a program that automatically checks whether all ships were boarded exactly
once. The method checkForCompletedCompetition(int... shipIds) is implemented to identify
ships that were missed and ships that were boarded multiple times. By avoiding nested loops,
the solution ensures efficient verification with linear runtime complexity. This project
strengthens concepts of array manipulation, frequency counting, and the use of hash-based
structures for error detection.

Example Output
Input:
{10, 20, 21, 15, 16, 17, 18, 19, 11, 12, 13, 14, 22}
Output:
All ships were boarded exactly once.
Input:
{10, 20, 21, 15, 16, 17, 18, 22}
Output:
Missing ships: 11, 12, 13, 14, 19
Input:
{10, 20, 21, 10, 15, 16, 10}

Output:
Ship 10 boarded multiple times.
Missing ships: 11, 12, 13, 14, 17, 18, 19, 22

Constraints
 Ship IDs must lie between 10 and 22 (inclusive).
 Input must contain at most 13 valid ship IDs; duplicates are allowed but flagged.
 The program must not use nested loops (quadratic runtime is disallowed).
 Input with invalid ship IDs (outside 10–22) should be ignored or reported.

Challenges
 Efficiently detecting duplicates without nested loops.
 Identifying missing ships while ensuring the list covers the entire range (10–22).
 Handling invalid or corrupted input gracefully.
 Designing a solution that balances clarity with performance by using hash sets or
frequency maps.
 Presenting the results in a user-friendly format, even when multiple errors exist
simultaneously.

P a g e 78 | 116
 Task 71: Weather Data Logger

In modern times, accurate and continuous weather monitoring is critical for forecasting,
research, and disaster management. Weather stations collect a wide range of environmental
data such as temperature, humidity, wind speed, and atmospheric pressure at regular intervals.
However, manually recording this information is inefficient, prone to human error, and often
leads to missing or duplicate entries. The Weather Data Logger project aims to automate this
process by storing weather readings in real time and ensuring that the data captured is valid
and consistent. It allows users to input new readings, validates them against predefined ranges,
and flags anomalies or missing entries. The system also provides summarized insights such as
daily averages or trends over time, which can support decision-making in agriculture,
transport, and emergency response. By automating collection and validation, the project
ensures reliability, accuracy, and accessibility of weather data.

Example Output
Input: Daily Logs
Timestamp: 2025-09-26 06:00, Temp=28°C, Humidity=70%, Wind=15 km/h
Timestamp: 2025-09-26 12:00, Temp=32°C, Humidity=55%, Wind=10 km/h
Timestamp: 2025-09-26 18:00, Temp=30°C, Humidity=60%, Wind=12 km/h
Output: Logged Readings
06:00 → Temp: 28°C, Humidity: 70%, Wind: 15 km/h
12:00 → Temp: 32°C, Humidity: 55%, Wind: 10 km/h
18:00 → Temp: 30°C, Humidity: 60%, Wind: 12 km/h
Output: Daily Summary
Temperature: Min=28°C, Max=32°C, Avg=30°C
Humidity: Min=55%, Max=70%, Avg=61.7%
Wind Speed: Min=10 km/h, Max=15 km/h, Avg=12.3 km/h
Missing entries: None
Duplicate entries: None
Input:
Timestamp: 2025-09-26 12:00, Temp=65°C, Humidity=50%, Wind=8 km/h
Output:
Error: Temperature 65°C out of valid range (-50°C to 60°C). Entry rejected.

Constraints
 Temperature must be within -50°C to 60°C, humidity within 0% to 100%, and wind
speed within realistic limits (e.g., 0–200 km/h).
 Each weather reading must have a unique timestamp; duplicate timestamps should
trigger an error.
 Missing readings for any expected timestamp should be flagged in the summary.
 The system must handle multiple readings per day and calculate summaries correctly.
 Null or non-numeric values for temperature, humidity, or wind speed must be rejected.
 The logger should efficiently handle large volumes of data, potentially spanning
multiple days or months.
 Summaries must include minimum, maximum, and average values for each weather
parameter.

P a g e 79 | 116
Challenges
 Maintaining chronological order while logging readings with timestamps.
 Correctly identifying and rejecting duplicate entries.
 Validating readings against realistic ranges while allowing for rare but valid weather
events.
 Efficiently computing daily summaries (min, max, average) without excessive
computation overhead.
 Handling missing data points in the daily summary gracefully.
 Supporting future extensions such as additional weather parameters (rainfall, UV index,
air pressure).
 Ensuring robust error reporting so that invalid entries are clearly flagged without
disrupting valid data logging.

P a g e 80 | 116
 Task 72: Smart Parking System

With rapid urbanization, parking management has become a critical challenge in cities, where
limited parking spaces often lead to congestion and delays. The Smart Parking System project
addresses this issue by providing a real-time solution for tracking parking slot occupancy. The
system ensures that no two vehicles are assigned the same slot simultaneously and monitors
available and occupied slots continuously. It also records the entry and exit times of vehicles,
allowing efficient calculation of parking duration and fees if needed. Additionally, the system
supports dynamic allocation, enabling vehicles to reserve slots in advance or cancel
reservations. This project provides practical experience in real-time data management,
validation, and concurrency handling, making it relevant for developing scalable urban
solutions.

Example Output
Input:
Park Car #KA05AB1234 at Slot 10
Output:
Car parked successfully.
Input:
Park Car #KA05AB1234 at Slot 10 (again)
Output:
Error: Slot 10 is already occupied.
Input:
Remove Car #KA05AB1234 from Slot 10
Output:
Car removed successfully. Slot 10 is now available.
Additional Output:
Available slots: 1-9, 11-14, 16-50
Occupied slots: 10, 15

Constraints
 Each parking slot can hold only one vehicle at a time.
 Vehicle numbers must be unique to prevent duplicate entries.
 Slot IDs must be within a valid range (e.g., 1 to 50 for a small parking lot).
 Vehicles must be parked and removed only through the system, ensuring accurate
tracking.
 The system must handle dynamic slot allocation, including reservations and
cancellations.
 Data must remain consistent and accurate even during simultaneous vehicle entries or
exits.
 Invalid or duplicate vehicle numbers, or out-of-range slot IDs, should trigger clear error
messages.

Challenges
 High-traffic management: Handling multiple vehicles trying to park or leave at the
same time without conflicts.
 Concurrency control: Ensuring the system updates slot availability correctly during
P a g e 81 | 116
 simultaneous operations.
 Error handling: Preventing data mismatches or duplicate assignments and providing
informative messages to users.
 Scalability: Supporting large parking areas with hundreds or thousands of slots
efficiently.
 Reservation management: Allowing pre-booking and cancellation while keeping real-
time tracking consistent.
 Reporting: Maintaining real-time logs for available and occupied slots, vehicle history,
and parking durations.
 Extensibility: Allowing future features like automated payment integration, slot sensors,
or mobile app interfaces.

P a g e 82 | 116
 Task 73: Bus Route Optimization

Efficient public transportation is critical for urban mobility, reducing congestion, and improving
commuter satisfaction. The Bus Route Optimization System project addresses the challenge of
finding the shortest and most efficient routes between bus stops within a city’s transport
network. The system models bus stops as nodes and routes as edges in a graph, allowing the
application of graph algorithms such as Dijkstra’s or A* to determine optimal paths. In addition
to finding the shortest route, the project provides alternate routes in case of road closures,
heavy traffic, or other disruptions. It also calculates estimated travel times and can
accommodate dynamic updates in the network, such as adding or removing stops or routes.
This project provides practical experience in graph theory, algorithm implementation, and real-
time decision-making, making it suitable for smart city transportation solutions.

Example Output
Input:
Start = A
End = D
Output:
Shortest Route = A → B → D
Distance = 12 km
Alternate Route = A → C → D
Input: If a route is blocked
Start = X
End = Z
Output:
Shortest Route = X → Y → Z
Alternate Route = X → W → Z

Constraints
 All bus stops must be connected, either directly or indirectly, to form a valid network.
 Route distances or weights must be non-negative.
 The network must handle dynamic changes, such as adding new stops or closing
routes.
 Alternate routes should be provided if the primary shortest route is unavailable.
 The system must efficiently handle large networks with hundreds of stops and routes.
 Routes must reflect real-world constraints, such as one-way roads and stop-specific
access.
 Input start and end points must exist in the network; invalid stops should trigger an
error.
Challenges
 Scalability: Handling large-scale transportation networks with numerous stops and
routes efficiently.
 Traffic and time optimization: Incorporating real-time factors like traffic congestion,
delays, or peak hours.
 Dynamic updates: Adapting shortest path calculations when stops or routes are added,
removed, or temporarily blocked.
 Alternate path generation: Ensuring reliable alternate routes are found quickly without
P a g e 83 | 116
 repeating the primary path.
 Algorithm efficiency: Selecting the best graph algorithm to compute shortest paths fast
under heavy demand.
 Data accuracy: Maintaining an accurate representation of distances, connectivity, and
constraints across the network.
 Integration potential: Allowing extension to real-time bus tracking, estimated arrival
times, or user-facing mobile applications.

P a g e 84 | 116
 Task 74: IoT-based home Energy Monitor

With the rising cost of electricity and growing environmental concerns, households need
better ways to monitor and optimize energy consumption. The IoT-based Home Energy
Monitor project provides a solution by tracking electricity usage of various appliances in real
time using smart sensors. The system identifies devices consuming excess power, detects
unusual consumption patterns, and generates actionable insights for cost reduction. Users can
view detailed summaries of daily, weekly, or monthly energy consumption, receive alerts for
potential wastage, and make informed decisions about energy usage. This project offers
practical experience in IoT device integration, real-time data collection, analysis, and
visualization, as well as energy efficiency and smart home automation.

Example Output
Input:
Appliance: Air Conditioner, Power: 1500W
Appliance: Refrigerator, Power: 200W
Appliance: Washing Machine, Power: 500W
Output:
Real-time Consumption:
Air Conditioner: 1.5 kW
Refrigerator: 0.2 kW
Washing Machine: 0.5 kW
High Consumption Alert: Air Conditioner exceeds recommended threshold.
Daily Summary:
Total Energy Used: 3.2 kWh
Top 3 Energy Consumers:
1. Air Conditioner → 45%
2. Washing Machine → 30%
3. Refrigerator → 25%
Estimated Cost: $1.25
Constraints
 All appliances must be equipped with smart sensors capable of real-time power
monitoring.
 The system must handle multiple devices simultaneously without lag or data loss.
 Power readings must be numeric, accurate, and within realistic limits.
 Alerts should be triggered only when consumption exceeds predefined thresholds.
 Data storage must support daily, weekly, and monthly summaries efficiently.
 System should function reliably in the presence of intermittent sensor failures or
network issues.
 Estimated energy cost calculations must use configurable electricity rates.

Challenges
 Real-time monitoring: Capturing and processing high-frequency energy data from
multiple appliances.
 Data accuracy: Ensuring sensor readings are precise and synchronized across devices.

P a g e 85 | 116
 Threshold management: Detecting high consumption while avoiding false positives.
 Scalability: Supporting multiple devices across a household or building.
 Data visualization: Presenting clear summaries, alerts, and consumption trends to users.
 Integration: Combining IoT sensors, network protocols, and backend data processing.
 Cost estimation: Accurately converting energy usage into monetary values considering
variable electricity rates.
 Fault tolerance: Handling sensor or network failures without losing critical data.

P a g e 86 | 116
 Task 75: E-Waste Collection Scheduler

Proper management of electronic waste (e-waste) is crucial for environmental sustainability

and regulatory compliance. The E-Waste Collection Scheduler project provides a system to
efficiently schedule pickups of e-waste from households, offices, and collection centers. It
tracks collection points, optimizes routes for vehicles to minimize travel time and fuel costs,
and ensures that pickups are completed on schedule. The system also generates reports for
recycling compliance, including the amount and type of e-waste collected, pickup dates, and
vehicle assignments. This project offers practical experience in logistics planning, route
optimization using algorithms, real-time tracking, and data reporting, making it highly relevant
for smart city initiatives and environmental management programs.

Example Output
Input:
Collection Points:
1. 123 Main St, 2 units
2. 456 Oak Rd, 1 unit
3. 789 Pine Ave, 3 units
Available Vehicles: Truck 1, Truck 2
Output:
Pickup Schedule:
Truck 1 → 123 Main St, 456 Oak Rd
Truck 2 → 789 Pine Ave
Route Optimization:
Truck 1 → 123 Main St → 456 Oak Rd → Depot
Truck 2 → 789 Pine Ave → Depot
Daily Summary Report:
Total Units Collected: 6
Collection Points Covered: 3
Vehicles Used: 2
Estimated Fuel Savings: 15% (via optimized routes)
Constraints
 Each collection vehicle can carry only a limited number of e-waste units.
 Pickup schedules must respect time windows provided by collection points.
 Collection points must be accurately geocoded for route optimization.
 Routes must avoid traffic-heavy areas if possible for efficiency.
 The system must prevent double assignment of the same collection point.
 Reports must comply with regulatory requirements, capturing quantities, pickup times,
and responsible vehicles.
 The system should handle dynamic changes, such as last-minute pickups or
cancellations.

Challenges
 Route optimization: Efficiently planning paths for multiple vehicles to minimize time
and distance.
 Load balancing: Ensuring each vehicle is neither overburdened nor underutilized.
P a g e 87 | 116
 Dynamic scheduling: Adapting to last-minute changes in collection points or
availability.
 Data accuracy: Maintaining correct records of units collected, vehicle assignments, and
timestamps.
 Scalability: Supporting large-scale e-waste collection operations across cities.
 Integration: Combining vehicle tracking, route planning algorithms, and reporting
tools.
 Regulatory compliance: Generating reports that meet environmental and legal
standards.
 Fault tolerance: Handling unexpected issues like vehicle breakdowns or missed pickups
without disrupting the schedule.

P a g e 88 | 116
 Task 76: Fitness Activity Tracker

Maintaining a healthy lifestyle requires consistent tracking of physical activity, but manual
monitoring of workouts, steps, and calorie consumption can be tedious and error-prone. The
Fitness Activity Tracker project addresses this challenge by providing a system that logs daily
workouts, step counts, calories burned, and other fitness metrics automatically or via user
input. It generates daily and weekly summaries, tracks progress over time, and provides
personalized recommendations to improve fitness levels. The system can also set goals, send
reminders, and detect patterns in activity to suggest adjustments. This project provides hands-
on experience in data collection, analysis, reporting, and user engagement, making it suitable
for personal health monitoring or integration with smart wearable devices.

Example Output
Input:
Date: 2025-09-26
Workouts: Running 30 min, Yoga 45 min
Steps: 8500
Calories Burned: 500
Output:
Daily Summary:
Workouts Completed: Running (30 min), Yoga (45 min)
Total Steps: 8,500
Calories Burned: 500 kcal
Weekly Summary:
Average Steps: 7,200/day
Average Calories Burned: 450 kcal/day
Most Frequent Activity: Yoga
Recommendations:
- Increase daily steps to 10,000 for better cardiovascular health
- Include strength training twice a week
- Maintain hydration and balanced diet
Constraints
 Activity entries must include accurate timestamps and numeric values for steps and
calories.
 Workouts should be categorized (e.g., cardio, strength, flexibility) for proper analysis.
 The system should prevent duplicate entries for the same time period.
 Data storage must support daily, weekly, and monthly summaries efficiently.
 Recommendations must be generated based on user activity patterns and predefined
thresholds.
 The system should handle multiple users if scaled to groups or families.
 Integration with devices (e.g., smartwatches, pedometers) must ensure consistent and
reliable data collection.

Challenges
 Data accuracy: Ensuring steps, calories, and workout durations are recorded correctly.
 Goal tracking: Monitoring progress toward user-defined fitness goals and generating
alerts.

P a g e 89 | 116
 Scalability: Handling multiple users and large datasets over long periods.
 Recommendations: Providing personalized suggestions based on activity trends
without being intrusive.
 Integration: Combining inputs from multiple devices and formats into a unified log.
 Visualization: Presenting summaries, trends, and insights in an understandable format
for users.
 Error handling: Managing missing or corrupted entries without affecting overall
tracking.
 Behavior analysis: Detecting patterns or anomalies to optimize fitness plans.

P a g e 90 | 116
 Task 77: Vehicle Maintenance Reminder

Regular vehicle maintenance is critical to ensure safety, performance, and longevity, but many
owners struggle to track service schedules, mileage, and parts replacement. The Vehicle
Maintenance Reminder System addresses this problem by providing a platform that records
service history, monitors mileage, and tracks replacement schedules for key components such
as oil, brakes, tires, and filters. The system sends proactive reminders to vehicle owners for
upcoming maintenance tasks, helping prevent breakdowns and costly repairs. Users can also
view detailed service logs, upcoming due dates, and recommendations for preventive
maintenance. This project provides practical experience in data management, scheduling, alert
generation, and user notifications, making it highly relevant for smart vehicle management
applications.

Example Output
Input:
Vehicle: KA05AB1234
Last Service Date: 2025-06-15
Current Mileage: 15,000 km
Next Oil Change Due: 20,000 km
Brake Inspection Interval: Every 10,000 km
Tire Replacement Interval: Every 40,000 km
Output:
Maintenance Reminders for Vehicle KA05AB1234:
- Oil Change: Due at 20,000 km
- Brake Inspection: Due at 20,000 km (Next scheduled based on 10,000 km interval)
- Tire Replacement: Next due at 40,000 km

Service History:
- 2025-06-15: Oil change, tire rotation
- 2025-03-10: Brake inspection
- 2024-12-05: Full service
Constraints
 Each vehicle must have a unique identifier (e.g., registration number).
 Service schedules and intervals must be accurately defined for each type of
maintenance.
 Mileage tracking must be numeric and updated after every trip or service.
 Reminders must be triggered based on either mileage thresholds or time intervals.
 Historical service data must be maintained in a persistent storage system.
 Users must be able to add, update, or delete vehicle details and service records.
 Alerts must be delivered reliably (e.g., via email, SMS, or app notifications).

Challenges
 Data accuracy: Ensuring mileage and service records are correctly updated.
 Scheduling alerts: Triggering notifications at the right time or mileage thresholds.
 Multiple vehicles: Handling data for multiple vehicles per user without conflicts.
 Integration: Potentially syncing with onboard vehicle systems or GPS devices for
automatic mileage tracking.
 Scalability: Supporting fleets with hundreds of vehicles efficiently.
P a g e 91 | 116
 User engagement: Presenting reminders and service logs in an intuitive and actionable
format.
 Error handling: Managing missed updates, incorrect entries, or duplicate records.
 Customization: Allowing users to adjust maintenance intervals based on driving
patterns or manufacturer recommendations.

P a g e 92 | 116
 Task 78: Virtual Classroom Attendance Manager

Managing student attendance in online classes can be time-consuming and prone to errors if
done manually. The Virtual Classroom Attendance Manager project provides an automated
solution to track attendance in real time, monitor student participation, and generate detailed
reports for teachers and administrators. The system can flag students with low attendance,
track participation trends over weeks or months, and provide actionable insights to improve
engagement. Additionally, it supports multiple classes, subjects, and instructors, ensuring
scalability for larger institutions. This project offers practical experience in data management,
real-time tracking, reporting, and notifications, and helps ensure academic compliance and
better classroom engagement in digital learning environments.

Example Output
Input:
Class: Mathematics 101
Date: 2025-09-26
Students Present: Alice, Bob, Charlie
Students Absent: David, Eva
Output:
Attendance Report for Mathematics 101 on 2025-09-26:
Present: Alice, Bob, Charlie
Absent: David, Eva

Summary:
- Alice: 95% attendance
- Bob: 90% attendance
- Charlie: 100% attendance
- David: 65% attendance (Flagged: Low Attendance)
- Eva: 70% attendance (Flagged: Low Attendance)

Recommendations:
- Send automated reminders to students flagged for low attendance.
- Generate weekly summary report for class engagement.
Constraints
 Each student must have a unique identifier (e.g., student ID or email).
 Attendance must be recorded per class session accurately.
 System should support multiple courses, instructors, and class sections.
 Low attendance thresholds must be configurable by the instructor.
 Data storage must support daily, weekly, and semester-long attendance reports.
 Attendance records must be immutable once confirmed to prevent tampering.
 System should be able to integrate with online learning platforms or video
conferencing tools.

Challenges
 Real-time tracking: Capturing attendance automatically during live sessions.
 Data accuracy: Ensuring students are not marked present erroneously due to technical
issues.
 Scalability: Managing large classes or multiple sections without performance issues.

P a g e 93 | 116
 Reporting: Generating meaningful summaries, including low attendance flags and
trends.
 Notifications: Sending timely alerts to students or parents regarding attendance
concerns.
 Integration: Synchronizing with LMS, video conferencing, or registration databases.
 Fraud prevention: Preventing students from marking attendance for others.
 Customizability: Allowing instructors to define attendance policies and thresholds for
engagement.

P a g e 94 | 116
 Task 79: AI-Powered Resume Analyzer

Recruitment is often a time-consuming and subjective process, especially when dealing with
hundreds or thousands of applicants. The AI-Powered Resume Analyzer project provides an
automated solution to analyze resumes, extract key skills, qualifications, and experiences, and
rank candidates based on alignment with job requirements. By leveraging natural language
processing (NLP) and scoring algorithms, the system evaluates each resume against
predefined job criteria, identifies top candidates, and generates a ranked list for HR teams.
This project helps reduce bias, save time, and improve the quality of candidate selection. It
also offers practical experience in text parsing, keyword matching, scoring algorithms, and
report generation.

Example Output
Input:
Job Requirements: Java, Spring Boot, REST API, SQL
Resumes:
1. Alice – Java, Spring Boot, SQL, Docker
2. Bob – Python, Django, SQL
3. Charlie – Java, Spring Boot, REST API, SQL, AWS
Output:
Candidate Rankings:
1. Charlie → Score: 95%
2. Alice → Score: 80%
3. Bob → Score: 40%
Recommendation: Invite top 2 candidates for interview.
Constraints
 Resumes must be provided in a parseable format (e.g., text, PDF, or Word).
 Job requirements should be well-defined keywords or skill sets.
 Scoring must consider skill relevance, experience, and completeness.
 The system should handle large volumes of resumes efficiently.
 Duplicate resumes must be detected and filtered.
 The output ranking must be deterministic for identical inputs.
 Optional: The system should handle synonyms and variations of keywords (e.g., “Java
EE” vs. “Java Enterprise Edition”).

Challenges
 Text parsing: Extracting meaningful information from diverse resume formats.
 Keyword matching: Accurately identifying relevant skills and qualifications.
 Scoring algorithm: Designing a fair scoring system that balances skills, experience, and
education.
 Scalability: Processing hundreds or thousands of resumes efficiently.
 Handling ambiguity: Recognizing synonyms, abbreviations, and context-specific terms.
 Bias reduction: Avoiding unintended bias based on names, universities, or other non-
relevant factors.
 Integration: Supporting HR tools for seamless workflow and reporting.
 Flexibility: Allowing HR to update scoring criteria and job requirements without system
overhaul.
P a g e 95 | 116
 Task 80: Virtual ATM System

The Virtual ATM System project aims to replicate the basic functionalities of a real-world
Automated Teller Machine (ATM) using fundamental Object-Oriented Programming (OOP)
concepts in Java. The system should allow a user to authenticate using a PIN and perform
essential banking operations such as checking balance, depositing funds, and withdrawing
money. By encapsulating sensitive details like the account balance and PIN within a
UserAccount class, the program ensures data security and controlled access. The ATM class
will serve as the interface between the user and the account, providing methods to handle
various transactions. This project demonstrates the practical application of encapsulation,
classes, and methods in Java through a real-life inspired scenario.

Example Output
Welcome to the ATM
Enter your PIN: 1234
Authentication successful!
Choose an option:
1. Check Balance
2. Deposit
3. Withdraw
4. Exit
Enter choice: 3
Enter amount to withdraw: 2000
Withdrawal successful! Remaining Balance: 3000
Constraints
 The system should only allow access with the correct PIN.
 Withdrawals cannot exceed the available account balance.
 Deposits and withdrawals should accept only positive amounts.
 Balance inquiry should always show the latest balance after transactions.

Challenges
 Ensuring secure handling of the PIN and restricting direct access to sensitive variables.
 Preventing invalid inputs such as negative deposits or overdrafts during withdrawals.
 Designing a simple yet user-friendly menu-driven system for interaction.
 Managing transaction updates consistently so that account balance reflects real-time
changes.

P a g e 96 | 116
 Task 81: E-Voting

The E-Voting System project simulates a simple electronic voting process using Java and basic
object-oriented programming concepts. It allows voters to register with their details, securely
cast their votes, and ensures that each registered voter can vote only once. The system uses
collections such as Map to efficiently store and count votes for different candidates. File
handling is used to persist voter information and voting results, making the application
reusable beyond a single execution. This project reflects how electronic voting systems work
in the real world, emphasizing secure voter registration, vote integrity, and accurate result
display.

Example Output
=== Welcome to E-Voting System ===
1. Register Voter
2. Cast Vote
3. Display Results
4. Exit
Enter choice: 1
Enter Voter ID: V101
Enter Name: John
Voter registered successfully!
Enter choice: 2
Enter Voter ID: V101
Candidates: [Alice, Bob, Charlie]
Enter your vote: Alice
Vote recorded successfully!
Enter choice: 3
Results:
Alice -> 1 votes
Bob -> 0 votes
Charlie -> 0 votes
Constraints
 A voter must register before casting a vote.
 Each voter can cast only one vote.
 The system must prevent duplicate voter IDs.
 Candidate names must be predefined and consistent throughout the process.
 Votes must be stored reliably (using file I/O) to preserve data between sessions.

Challenges
 Designing a mechanism to prevent double voting while keeping the system simple.
 Handling incorrect inputs gracefully, such as invalid voter IDs or candidate names.
 Ensuring persistence of voting data across program restarts using file handling.
 Maintaining the integrity of votes while providing an easy-to-use console interface.

P a g e 97 | 116
 Task 82: Music Playlist Manager

The Music Playlist Manager project aims to simulate the functionalities of a basic music player
using Java’s object-oriented programming concepts. It allows users to manage a playlist by
adding and removing songs, navigating through tracks, and simulating playback using text
output. Collections such as ArrayList or LinkedList are used to store and manage the sequence
of songs efficiently. Additional features like shuffle and repeat enhance the user experience by
offering flexibility in how songs are played. Encapsulation ensures that the details of each song,
such as title and artist, are securely managed within the Song class while exposing only
necessary methods to interact with the playlist. This project demonstrates how Java collections
and OOP principles can be applied to mimic real-world media applications.

Example Output
=== Music Playlist Manager ===
1. Add Song
2. Remove Song
3. Play Next Song
4. Play Previous Song
5. Shuffle Playlist
6. Repeat Current Song
7. Exit
Enter choice: 1
Enter song title: Shape of You
Enter artist: Ed Sheeran
Song added successfully!
Enter choice: 3
Now Playing: Shape of You by Ed Sheeran
Enter choice: 5
Shuffling playlist...
Now Playing: Believer by Imagine Dragons
Constraints
 A playlist must contain at least one song to start playback.
 Song titles and artists should not be empty or null.
 Shuffle should not repeat the same song consecutively unless only one song exists.
 Repeat mode should replay the current song until turned off.
 The system should maintain the order of songs unless shuffle is explicitly selected.

Challenges
 Efficiently managing playlist navigation (next, previous, shuffle) without breaking
sequence.
 Preventing duplicate songs while still allowing flexibility in playlist creation.
 Handling edge cases such as an empty playlist or trying to play beyond the last song.
 Simulating realistic playback behavior using simple console output while keeping the
design user-friendly.

P a g e 98 | 116
 Task 83: Task Alert System

The Task Alert System is designed to help users manage and keep track of their daily tasks
efficiently. Users can add tasks along with specific deadlines, and the system will notify them
when tasks are due. The project uses Object-Oriented Programming concepts to encapsulate
task details within a Task class and manage multiple tasks using collections such as ArrayList
or HashMap. The Java Date/Time API is used to handle deadlines, and a Timer or Scheduler
mechanism ensures timely notifications. This project demonstrates how OOP, collections, and
time-based event handling can be combined to create a practical productivity tool.

Example Output
=== Task Reminder Application ===
1. Add Task
2. View Tasks
3. Exit
Enter choice: 1
Enter task name: Submit Assignment
Enter deadline (yyyy-MM-dd HH:mm): 2025-09-28 18:00
Task added successfully!
Enter choice: 2
Tasks:
1. Submit Assignment - Due: 2025-09-28 18:00
[Notification at 2025-09-28 18:00] Reminder: Submit Assignment is due now!

Constraints
 Task names should not be empty or null.
 Deadlines must be entered in the correct date-time format.
 Notifications are triggered only for tasks that have not yet passed their deadlines.
 The system should handle multiple tasks and ensure notifications are sent for each.

Challenges
 Correctly parsing and validating user input for task names and deadlines.
 Managing multiple tasks and scheduling notifications efficiently.
 Ensuring the timer or scheduler triggers notifications at the correct time, even if
multiple tasks are due simultaneously.
 Handling edge cases such as overdue tasks, duplicate task names, or invalid date
formats gracefully.

P a g e 99 | 116
 Task 84: Employee Performance Management

The Employee Performance Management is a Java-based application designed to help

organizations monitor and evaluate the performance of their employees efficiently. The system
allows administrators to add employee details, record their performance scores for specific
tasks or periods, and generate performance reports. Using Object-Oriented Programming
concepts, employee information is encapsulated within an Employee class, while collections
such as ArrayList or HashMap are used to manage multiple employees and their scores. This
project demonstrates how OOP principles and collections can be applied to build a practical
tool for performance management in a workplace environment.

Example Output
=== Employee Performance Tracker ===
1. Add Employee
2. Record Performance Score
3. Generate Report
4. Exit
Enter choice: 1
Enter Employee ID: E101
Enter Name: John Doe
Employee added successfully!
Enter choice: 2
Enter Employee ID: E101
Enter Score: 85
Score recorded successfully!
Enter choice: 3
Performance Report:
Employee ID: E101, Name: John Doe, Average Score: 85

Constraints
 Employee IDs must be unique.
 Performance scores should be numeric and within a valid range (e.g., 0–100).
 The system should handle multiple employees and multiple performance entries for
each employee.
 Reports must correctly calculate averages or totals based on recorded scores.

Challenges
 Ensuring unique identification of employees and preventing duplicate entries.
 Validating input scores and handling invalid data gracefully.
 Efficiently managing performance data for multiple employees using collections.
 Generating accurate and formatted performance reports even when the dataset grows.

P a g e 100 | 116
 Task 85: Online Exam Proctoring System

The Online Exam Proctoring System is a Java-based application designed to simulate an online
examination environment while ensuring integrity and fairness. The system allows students to
take timed tests, automatically monitors the duration of the exam, and prevents multiple logins
to maintain security. Using Object-Oriented Programming concepts, the exam, questions, and
student details are encapsulated in separate classes. Collections are used to store questions
and student records efficiently. This project demonstrates how OOP principles, time
management, and basic security measures can be applied to create a functional online
examination platform.

Example Output
=== Online Exam Proctoring System ===
Enter Student ID: S101
Login successful!
Exam: Java Basics Test
Time Allotted: 10 minutes
Question 1: What is JVM?
a) Java Virtual Machine
b) Java Very Much
c) Java Variable Method
d) None of the above
Enter your answer: a
Question 2: Which keyword is used to inherit a class in Java?
a) implement
b) extends
c) inherits
d) super
Enter your answer: b
Time remaining: 2 minutes
Exam completed!
Your score: 2/2

Constraints
 Each student must have a unique ID for login.
 Students cannot log in multiple times for the same exam.
 The exam must be completed within the allotted time; late submissions are not
allowed.
 Questions and answers should be predefined and immutable during the exam.
 Only valid choices for answers (e.g., a, b, c, d) are accepted.

Challenges
 Preventing multiple logins or attempts from the same student to maintain exam
integrity.
 Accurately monitoring exam time and automatically submitting when the time expires.
 Designing a simple console interface that simulates real exam conditions.
 Managing question storage, randomization, and result calculation efficiently using
collections.
P a g e 101 | 116
 Task 86: Smart Agriculture System

In modern agriculture, inefficient irrigation and lack of real-time monitoring of soil and
weather conditions often lead to reduced crop yields and wastage of water resources. The
Smart Agriculture System is designed to address these issues by continuously monitoring
critical parameters such as soil moisture, temperature, and local weather conditions. Using
Java, the system collects data from sensors, analyzes it, and provides recommendations for
optimized irrigation schedules and crop care, helping farmers make data-driven decisions,
conserve water, and improve crop productivity.

Example Output
Soil Moisture Level: 35% (Low)
Temperature: 28°C
Weather Forecast: Sunny
Recommended Action: Irrigation required. Activate sprinklers for 20 minutes.

Constraints
 Accurate sensor data collection is essential; faulty readings can affect
recommendations.
 The system relies on real-time data and may require stable internet connectivity for
weather updates.
 Scalability: Handling multiple fields and sensors simultaneously may increase system
complexity.

Challenges
 Integrating various hardware sensors with the Java-based software system.
 Real-time processing of sensor data and timely decision-making.
 Handling exceptions such as sensor failures or extreme weather conditions.
 Designing a user-friendly interface for farmers with minimal technical knowledge.

P a g e 102 | 116
 Task 87: Automated Code Reviewer

In software development, ensuring that code follows quality standards and is free of common
errors is essential but often time-consuming. The Automated Code Reviewer system is
designed to streamline this process by analyzing code submissions, checking for adherence to
coding standards, identifying potential bugs, and providing actionable suggestions for
improvement. The system can parse source code, detect common issues such as improper
naming conventions, unused variables, and syntax errors, and generate a report to help
developers enhance code quality efficiently.

Example Output
Code Analysis Report:
- File: [Link]
- Issue 1: Variable 'temp' is declared but never used. [Warning]
- Issue 2: Method 'calculateSum' exceeds recommended length of 30 lines. [Warning]
- Issue 3: Naming convention violation: Class name 'mainClass' should start with an
uppercase letter. [Error]
Recommended Actions:
- Remove unused variables
- Refactor large methods into smaller ones
- Correct class and method naming conventions

Constraints
 Only supports Java code submissions.
 Real-time analysis may be limited for very large code files.
 The system assumes syntactically correct code; parsing completely invalid Java files
may fail.
Challenges
 Parsing and analyzing Java code accurately while handling edge cases.
 Detecting logical bugs beyond syntax and standard violations.
 Providing actionable, human-understandable suggestions instead of just error
messages.
 Scaling the system to handle multiple simultaneous code submissions efficiently.

P a g e 103 | 116
 Task 88: AI-Powered Personal Finance Advisor

Managing personal finances effectively is a challenge for many individuals due to the
complexity of tracking expenses, understanding spending patterns, and making informed
decisions about savings and investments. The AI-Powered Personal Finance Advisor is
designed to address this challenge by automatically monitoring financial transactions,
analyzing spending behavior, and providing personalized suggestions to optimize savings and
investment strategies. The system leverages intelligent algorithms to categorize expenses,
detect unnecessary spending, and offer actionable recommendations that help users achieve
their financial goals efficiently.

Example Output
Expense Summary for September:
- Total Income: $4,500
- Total Expenses: $3,200
• Food: $800
• Transportation: $300
• Entertainment: $500
• Utilities: $600
- Suggested Savings: $1,000
- Recommendations:
• Reduce dining out by $200
• Increase monthly investment in mutual funds by $150
• Set up automated savings plan of $500

Constraints
 Accurate and timely financial data input is necessary for reliable analysis.
 The system requires secure handling of sensitive financial information.
 Predictive recommendations may not account for unexpected expenses or market
fluctuations.

Challenges
 Integrating AI algorithms to accurately categorize and analyze diverse financial
transactions.
 Ensuring data security and privacy while handling sensitive financial records.
 Providing personalized suggestions that are practical and actionable for a wide range
of users.
 Scaling the system to handle multiple accounts and different financial institutions
efficiently.

P a g e 104 | 116
 Task 89: Travel Itinerary Planner

Planning a trip involves managing multiple factors such as destinations, activities,

accommodations, and budgets, which can be time-consuming and confusing for travelers. The
Travel Itinerary Planner addresses this problem by providing an intelligent system that helps
users create detailed travel plans based on their preferences, including preferred locations,
interests, duration, and budget constraints. The system also suggests must-visit places,
estimates expenses, and presents a user-friendly itinerary, enabling travelers to make informed
decisions and enjoy a well-organized trip without the hassle of manual planning.

Example Output
Trip Planner Summary:
Destination: Paris, France
Duration: 5 days
Budget: $1,500
Suggested Places:
- Day 1: Eiffel Tower, Seine River Cruise
- Day 2: Louvre Museum, Notre-Dame Cathedral
- Day 3: Montmartre, Sacré-Cœur
- Day 4: Palace of Versailles
- Day 5: Shopping at Champs-Élysées
Estimated Expenses:
- Accommodation: $500
- Food: $300
- Transport: $200
- Sightseeing Tickets: $250
- Miscellaneous: $250
Total Estimated Budget: $1,500

Constraints
 Accurate location and weather data depend on external APIs.
 Budget estimation is approximate and may vary depending on real-time prices.
 Travel suggestions may be limited by the user’s specified preferences and duration.

Challenges
 Integrating multiple APIs (location, weather, transport, etc.) and handling response
delays or failures.
 Generating optimized itineraries that balance time, cost, and user preferences.
 Designing an intuitive GUI that presents complex information clearly.
 Handling exceptions such as unavailable accommodations or sudden changes in
weather.

P a g e 105 | 116
 Task 90: E-Learning Platform

In modern education, students often struggle to manage learning materials, track their
progress, and identify areas where they need improvement. The E-Learning Platform with
Progress Tracking addresses these challenges by providing a digital environment where
students can access learning resources, attempt quizzes, and receive performance feedback.
The system monitors progress, highlights strengths and weaknesses, and offers personalized
recommendations to help students enhance their learning outcomes. This platform ensures
that both learners and educators can make data-driven decisions to improve knowledge
retention and academic performance.

Example Output
Student: Alice Johnson
Course: Introduction to Programming
Modules Completed: 5/8
Quizzes Attempted: 3/5
Average Score: 78%
Progress Summary:
- Module 1: Completed (Score: 85%)
- Module 2: Completed (Score: 70%)
- Module 3: Completed (Score: 80%)
Recommendations:
- Review Module 2 concepts on loops
- Attempt practice exercises for Module 4
- Focus on debugging exercises for upcoming quiz

Constraints
 Requires accurate tracking of student interactions and quiz attempts.
 Database or file storage must be properly maintained to prevent data loss.
 Performance recommendations are based on available data and may not cover all
learning styles.

Challenges
 Designing an intuitive GUI to display learning materials, quizzes, and progress reports.
 Ensuring data integrity and secure storage of student records.
 Generating meaningful and actionable recommendations based on student
performance.
 Scaling the platform to support multiple students, courses, and concurrent access.

P a g e 106 | 116
 Task 91: Smart Home Automation System

Managing home appliances efficiently can be challenging, especially when residents want to
reduce energy consumption, enhance comfort, and automate routine tasks. The Smart Home
Automation System addresses this issue by allowing users to control devices such as lights,
fans, and air conditioners both remotely and automatically based on sensor inputs or
predefined schedules. The system can monitor environmental conditions, trigger appliances
when needed, and provide a user-friendly interface for manual overrides, helping homeowners
save energy, improve convenience, and ensure a more intelligent living environment.

Example Output
Home Automation Dashboard:
- Living Room Lights: ON
- Bedroom AC: OFF
- Kitchen Fan: ON
- Security System: ARMED
Automated Actions:
- Temperature Sensor: 30°C → Bedroom AC turned ON
- Motion Detected: Living Room → Lights turned ON
- Scheduled Task: Garden Sprinklers at 6:00 AM → Sprinklers activated

Constraints
 Accurate sensor readings are required for proper automation.
 System relies on stable network connectivity for remote access.
 Limited support for appliances not compatible with IoT integration.

Challenges
 Integrating various sensors and appliances into a unified control system.
 Ensuring real-time response for automated actions based on sensor data.
 Designing an intuitive GUI that allows easy monitoring and manual control.
 Handling exceptions such as device malfunctions, network failures, or conflicting
schedules.

P a g e 107 | 116
 Task 92: Energy Consumption Tracker

Rising energy costs and environmental concerns have made efficient electricity usage a priority
for households and businesses. The Smart Energy Consumption Tracker addresses this
challenge by monitoring the power consumption of home appliances in real-time, analyzing
usage patterns, and generating reports with actionable suggestions to save energy. The system
provides insights into which appliances consume the most energy, identifies periods of high
usage, and recommends ways to optimize electricity consumption, helping users reduce their
bills and minimize their environmental footprint.

Example Output
Energy Usage Report:
- Total Consumption Today: 15.3 kWh
- Appliance-wise Usage:
• Refrigerator: 3.5 kWh
• Air Conditioner: 5.2 kWh
• Washing Machine: 2.0 kWh
• Lights & Fans: 4.6 kWh
Recommendations:
- Reduce AC usage during peak hours
- Switch off lights and fans in unoccupied rooms
- Consider energy-efficient appliances for high-consumption devices

Constraints
 Accurate measurement requires proper calibration of IoT sensors.
 System performance depends on continuous data collection and stable network
connectivity.
 Recommendations are based on historical and real-time usage patterns and may not
account for sudden changes in energy needs.

Challenges
 Integrating IoT sensors to accurately measure appliance-level electricity consumption.
 Processing and analyzing real-time data efficiently to generate timely reports.
 Designing an intuitive GUI to present energy usage and recommendations clearly.
 Handling exceptions such as sensor failure, network interruptions, or inaccurate
readings.

P a g e 108 | 116
 Task 93: Virtual Event Management

Organizing events, whether online or offline, involves multiple tasks such as managing
registrations, ticketing, attendee tracking, and communication with participants, which can be
time-consuming and prone to errors. The Virtual Event Management System addresses these
challenges by providing an integrated platform to streamline event administration. It enables
organizers to create events, manage participant registrations, generate tickets, and monitor
attendance in real-time. The system also simplifies communication with attendees and ensures
a smooth and organized event experience for both organizers and participants.

Example Output
Event: Tech Innovators Summit 2025
Date: 15th November 2025
Venue: Virtual (Zoom) & Onsite Hall A
Registered Participants: 120
Tickets Issued: 120
Check-in Status:
- Online Participants: 85/85
- Onsite Participants: 35/35
Notifications:
- Reminder sent to all participants 1 day before the event
- Event link shared with online attendees

Constraints
 Requires reliable internet connectivity for online events.
 Accurate attendee data must be maintained to prevent duplicate registrations.
 Ticket generation and check-in processes must handle high volumes during peak
times.

Challenges
 Designing a user-friendly interface for both organizers and attendees.
 Managing real-time tracking of registrations, ticketing, and check-ins.
 Ensuring data security and privacy for participant information.
 Scaling the system to handle multiple simultaneous events without performance issues.

P a g e 109 | 116
 Task 94: Online Auction System

Conducting auctions manually can be time-consuming, error-prone, and limited by

geography. The Online Auction System addresses these challenges by providing a platform
where users can list items for auction, place bids in real-time, and automatically determine
winners when the auction ends. The system ensures transparency, maintains bid history,
notifies participants of status updates, and handles all calculations and deadlines
automatically. By enabling real-time interaction, it allows buyers and sellers to participate
efficiently from anywhere, ensuring fair competition and accurate results.

Example Output
Auction Item: Vintage Camera
Starting Price: $150
Current Highest Bid: $220
Highest Bidder: user123
Time Remaining: 00:15:32
Bidding History:
- user101: $160
- user202: $180
- user123: $220
Auction Closed:
Winner: user123
Final Price: $220

Constraints
 Requires stable internet connection for real-time bidding.
 System must handle multiple concurrent auctions and users efficiently.
 Bids must be validated to prevent invalid or duplicate entries.

Challenges
 Implementing real-time bid updates and notifications to all participants.
 Ensuring fairness and preventing bid manipulation or concurrency issues.
 Managing database consistency for bid history and auction states.
 Designing a user-friendly interface for both buyers and sellers.

P a g e 110 | 116
 Task 95: Tic-Tac-Toe Game

Tic-Tac-Toe is a simple yet engaging two-player game played on a 3x3 grid. Each player takes
turns marking a cell with their symbol, either ‘X’ or ‘O’, and the goal is to form a line of three
symbols horizontally, vertically, or diagonally. The console-based Tic-Tac-Toe Game allows
players to play interactively, with the board displayed after every move. The system detects
invalid inputs, declares a winner when a winning condition is met, or announces a draw if all
cells are filled without a winner. This project helps practice logical thinking, control structures,
and array manipulation in a programming environment.

Example Output
Tic-Tac-Toe Game Started!
Player 1 (X), Player 2 (O)
Current Board:
---
---
---
Player 1, enter row and column (0-2): 0 0
Current Board:
X--
---
---
Player 2, enter row and column (0-2): 1 1
Current Board:
X--
-O-
---
... (game continues) ...
Result: Player 1 Wins! (Three X in a row)

Constraints
 The game is strictly two-player; no AI opponent is included.
 Inputs must be within the grid range (0–2 for rows and columns).
 A cell cannot be selected more than once.

Challenges
 Detecting all possible winning conditions across rows, columns, and diagonals.
 Validating inputs to prevent overwriting cells or entering invalid coordinates.
 Ensuring the game ends properly with a winner or draw announcement.
 Keeping the board updated and user-friendly in console output.

P a g e 111 | 116
 Task 96: Weather-based Plant Care System

Plants require proper care, including the right amount of water and protection from
unfavourable weather conditions, but many farmers and gardeners rely on guesswork rather
than data-driven decisions. The Weather-Based Plant Care System solves this issue by
monitoring soil conditions and collecting weather data to provide intelligent
recommendations for plant care. The system can suggest optimal irrigation schedules, alert
users about unfavourable weather, and guide them in maintaining healthy plant growth. By
combining environmental data with soil analysis, it helps conserve water, improve crop yield,
and ensure sustainable plant care practices.

Example Output
Plant Care Dashboard:
Soil Moisture Level: 28% (Low)
Temperature: 32°C
Weather Forecast: Sunny for next 3 days

Recommendations:
- Irrigate the plants today for 20 minutes.
- Avoid overwatering as no rain is expected this week.
- Provide shade protection during peak afternoon hours.

Constraints
 Accurate sensor data and reliable weather API responses are required for effective
recommendations.
 Continuous internet connectivity is needed to fetch real-time weather updates.
 System recommendations may not cover unique plant-specific requirements unless
customized.

Challenges
 Integrating soil sensors with weather data sources and processing them effectively.
 Providing real-time and accurate care suggestions under changing environmental
conditions.
 Designing a simple interface that makes plant care insights easy to understand for
end-users.
 Handling cases of sensor failure, inconsistent data, or sudden weather changes.

P a g e 112 | 116
 Task 97: Crime Record Management System

Managing crime-related information manually can be inefficient, error-prone, and time-

consuming for law enforcement agencies. The Crime Record Management System provides a
digital platform to store and track crime reports, details of suspects, and case statuses
systematically. The system helps investigators update records during different stages of a case,
generate investigation progress reports, and prepare closure summaries once cases are
resolved. By digitizing these processes, it enhances efficiency, ensures data consistency, and
improves accessibility of critical information for authorities.

Example Output
Crime Record Management System
New Report Added:
Case ID: CR1021
Crime Type: Burglary
Location: Downtown Street
Suspect: Unknown
Status: Under Investigation
Update Case:
Case ID: CR1021
Suspect Identified: John Doe
Status Updated: In Court
Closure Report:
Case ID: CR1021
Crime Type: Burglary
Suspect: John Doe
Final Status: Closed
Verdict: Guilty

Constraints
 Each case must have a unique case ID for tracking.
 Sensitive information must be stored securely.
 System accuracy depends on proper data entry by authorized personnel.
 Access must be role-based to prevent misuse of records.

Challenges
 Designing a secure system to prevent unauthorized access or data tampering.
 Maintaining scalability to handle a large number of records over time.
 Ensuring efficient search and retrieval of case details.
 Generating detailed reports in a format that supports decision-making by law
enforcement.

P a g e 113 | 116
 Task 98: Parcel Track

Managing courier services manually often leads to delays, misplaced parcels, and inefficiencies
in updating delivery records. The Courier Management System provides a streamlined digital
solution for handling parcel bookings, tracking delivery status, and maintaining updated
records. It allows staff to register new parcels, assign tracking IDs, update delivery progress,
and generate bills or receipts for customers. By automating these processes, the system
ensures better transparency, reduces errors, and improves customer satisfaction by providing
timely updates and accurate billing.

Example Output
Courier Management System
New Booking:
Parcel ID: P1005
Sender: Alice Johnson
Receiver: Bob Smith
Destination: New York
Status: Booked
Bill Generated: $50
Update Status:
Parcel ID: P1005
Current Status: In Transit
Delivery Receipt:
Parcel ID: P1005
Receiver: Bob Smith
Status: Delivered
Total Bill: $50

Constraints
 Each parcel must be assigned a unique tracking ID.
 Accurate status updates are essential to maintain customer trust.
 Billing details must be calculated consistently for different parcel weights and
destinations.
 Records should be securely stored and retrievable for auditing.

Challenges
 Handling real-time tracking updates for multiple parcels simultaneously.
 Designing an efficient search and retrieval system for parcel records.
 Ensuring the reliability of billing and receipt generation.
 Maintaining scalability to support large courier networks and high transaction
volumes.

P a g e 114 | 116
 Task 99: Course Registration System

Managing student course enrollments manually can lead to errors, overbooked classes, and
inefficient tracking of available seats and waitlists. The Course Registration System provides a
digital solution that allows students to enroll in courses, monitor seat availability, and join
waitlists when classes are full. The system keeps records of all enrollments, ensures that course
capacity limits are not exceeded, and generates summary reports for administrators. By
automating the registration process, it reduces administrative workload, prevents conflicts,
and ensures that students have a clear view of their course schedules.

Example Output
Course Registration Dashboard
Available Courses:
1. Data Structures (Seats: 3)
2. Database Systems (Seats: 0, Waitlist: 2)
3. Operating Systems (Seats: 5)
Student Enrollment:
Name: John Doe
Selected Course: Data Structures
Enrollment Status: Successfully Enrolled
Waitlist Update:
Course: Database Systems
Student: Jane Smith
Status: Added to Waitlist Position 3
Enrollment Summary:
- Data Structures: 3/3 enrolled
- Database Systems: 0/30 enrolled, 2 on waitlist
- Operating Systems: 5/30 enrolled

Constraints
 Each course has a maximum number of seats that cannot be exceeded.
 Waitlists must be maintained fairly on a first-come, first-served basis.
 Student enrollment must be updated in real-time to avoid conflicts.
 Data integrity must be ensured to prevent duplicate registrations.

Challenges
 Managing seat availability and waitlists dynamically as students register or drop
courses.
 Ensuring that the system can handle concurrent enrollments without errors.
 Designing an intuitive console or GUI interface for both students and administrators.
 Generating accurate and detailed enrollment reports for academic planning.

P a g e 115 | 116
 Task 100: Skill Match

Finding the right job or candidate can be a time-consuming and inefficient process when done
manually. The Job Portal Application provides a digital platform where employers can post job
openings and applicants can submit resumes. The system analyzes candidate profiles and
matches them with suitable job listings based on skills, experience, and qualifications. By
automating this process, the platform ensures that employers find relevant candidates faster
and applicants discover opportunities that best match their skills, making recruitment and job
hunting more efficient and transparent.

Example Output
Job Listings:
1. Software Developer - Skills Required: Java, SQL
2. Data Analyst - Skills Required: Python, Excel
3. Web Designer - Skills Required: HTML, CSS, JavaScript
Applicant Submission:
Name: Alice Johnson
Skills: Java, SQL, HTML
Matching Jobs:
- Software Developer: Suitable
- Web Designer: Partially Suitable
Application Status:
- Software Developer: Applied Successfully
- Web Designer: Pending Review

Constraints
 Candidate profiles must be accurately maintained with up-to-date skills and
experience.
 Job postings must include clear requirements to ensure proper matching.
 The system must prevent duplicate applications for the same job.
 Data privacy must be ensured for both applicants and employers.

Challenges
 Designing an efficient matching algorithm to pair candidates with suitable jobs.
 Handling a large number of job postings and applications simultaneously.
 Maintaining secure storage of sensitive information like resumes and personal details.
 Providing a user-friendly interface for both applicants and employers.

P a g e 116 | 116
 Find out more:
[Link]

Institute of Aeronautical Engineering

(Autonomous)
Dundigal, Hyderabad - 500 043, Telangana, India
Ph - 040-29705852, 29705853, 29705854
Call +91 8886234501, 8886234502

Enquiries: info@[Link]