Beginner Level:

• Variables:
• Variant 1: Declare and initialize variables of different data types (String,
Int, Float) and print their values.
• Variant 2: Perform arithmetic operations on integer and float variables
and print the results.
• Variant 3: Create a program that takes user input for name, age, and
GPA and displays them.
Variant 4: Create a program that swaps the values of two variables of
different data types (e.g., int and float). Variant 5: Implement a
program that calculates the area of a rectangle using length and width
as user inputs. Variant 6: Develop a program that converts temperature
from Celsius to Fahrenheit and vice versa using user input.

• Keywords (var, val, lateinit, lazy):

• Variant 1: Declare variables using var, val, lateinit, and lazy keywords
and observe their behavior.
• Variant 2: Explore the differences between val and var in terms of
mutability and initialization.
Variant 3: Experiment with lateinit keyword by declaring a nullable
variable and initializing it later in the code.
• Variant 4: Explore the usage of lazy keyword by initializing a complex
object only when it's accessed for the first time.
• Variant 5: Investigate the behavior of val keyword in loops and
demonstrate how it affects variable reassignment.

• Control Flow Statements:

• Variant 1: Write a program to check if a number is even or odd using if
statements.
• Variant 2: Implement a simple calculator program using when (Kotlin's
switch equivalent) to perform arithmetic operations.
• Variant 3: Write a program to determine the grade of a student based
on their exam score using nested if-else statements.
• Variant 4: Implement a program to check if a year is a leap year or not
using if-else statements.
• Variant 5: Develop a program that simulates a simple traffic light
system using when expression

• Arrays:
• Variant 1: Declare an array of integers, initialize it with values, and print
each element.
• Variant 2: Write a program to find the sum of all elements in an array.
Variant 3: Create an array of strings containing names of cities and
search for a specific city entered by the user.
• Variant 4: Write a program to find the largest and smallest elements in
an array of integers.
 • Variant 5: Implement a program that calculates the average of all
elements in an array of floats.

• High Order Functions:

• Variant 1: Use the let, apply, and run functions to perform operations
on objects.
• Variant 2: Create a higher-order function that takes a lambda as a
parameter and executes it.
• Variant 3: Use the with function to perform a series of operations on an
object without repeating its name.
• Perform operation in an account class deposit withdraw printinfo using with
function.
• Variant 4: Create a program that demonstrates the usage of extension
functions to add new functionality to existing classes.
• Variant 5: Develop a program that applies a lambda function to each element
of a list and returns the modified list

• Unit Functions and Exceptions:

• Variant 1: Define and call a simple unit function that prints a message.
• Variant 2: Create a program that handles exceptions using Kotlin's try,
catch, and finally blocks.
• Variant 3: Use the with function to perform a series of operations on an
object without repeating its name.
• Variant 4: Create a program that demonstrates the usage of extension
functions to add new functionality to existing classes.
• Variant 5: Develop a program that applies a lambda function to each
element of a list and returns the modified list.

Intermediate Level:

• Encapsulation, Abstraction, Inheritance, Polymorphism:

• Variant 1: Implement a simple class hierarchy representing different

shapes (e.g., Shape, Circle, Rectangle) and demonstrate inheritance.
• Variant 2: Create a class representing a bank account with
encapsulated fields and methods for deposit, withdrawal, and balance
inquiry.
Variant 3: Implement a class representing different vehicles (e.g., Car,
Motorcycle) and demonstrate polymorphism through method
overriding.
• Variant 4: Create an abstract class representing a geometric shape and
implement concrete classes for specific shapes (e.g., Circle, Rectangle).
• Variant 5: Develop a program that demonstrates encapsulation by
defining private properties and providing public methods to access and
modify them.
• Intent and Activity Lifecycle:

• Variant 1: Develop a simple app with two activities and demonstrate

the activity lifecycle using log statements.
• Variant 2: Implement an app with activities that communicate using
explicit intents.
• Variant 3: Build an app with multiple activities and demonstrate the
activity lifecycle by logging lifecycle events in each activity.
• Variant 4: Implement an app with a splash screen activity that
transitions to a main activity after a certain delay.
• Variant 5: Develop an app with activities that communicate using
implicit intents to perform actions such as dialing a phone number or
opening a web page.

• Fragments and RecyclerView:

• Variant 1: Create an app with a single activity containing a fragment
that displays a list using RecyclerView.
• Variant 2: Implement a master-detail layout using fragments and
RecyclerView for a more complex data presentation.
• Variant 3: Create an app with a ViewPager containing multiple
fragments, each displaying different content.
• Variant 4: Implement a search functionality in a RecyclerView-based
app to filter and display specific items.
• Variant 5: Develop a music player app using fragments to display album
art and RecyclerView to list songs in each album.

• Firebase Integration and Shared Preferences:

• Variant 1: Develop an app that stores user preferences using Shared

Preferences.
• Variant 2: Integrate Firebase Authentication into an app and
demonstrate login/logout functionality.
• Variant 3: Integrate Firebase Realtime Database into an app and
implement features such as data synchronization and offline
persistence.
• Variant 4: Develop an app that uses Shared Preferences to store user
login credentials securely and automatically login the user on app
launch.
• Variant 5: Implement Firebase Cloud Messaging (FCM) in an app to
send and receive push notifications.(Advance level )

• Remote Config and API Integration:

• Variant 1: Implement Firebase Remote Config to control app behavior
remotely.
• Variant 2: Integrate Retrofit library to fetch data from a REST API and
display it in your app.
 • Variant 3: Use Firebase Remote Config to dynamically change app
settings such as theme colors or feature toggles.
• Variant 4: Integrate OkHttp library to make HTTP requests to a REST
API and handle JSON responses.
• Variant 5: Develop a news reader app that fetches news articles from a
news API and displays them using RecyclerView.

• MVVM Architecture and LiveData:

• Variant 1: Implement a simple MVVM architecture for an app with
LiveData to observe data changes.
• Variant 2: Develop a weather app using MVVM architecture, LiveData,
and Retrofit to fetch weather data from an API.
• Variant 3: Implement a simple TODO list app using MVVM architecture,
LiveData, and Room Database for data storage.
• Variant 4: Develop a shopping app with MVVM architecture to display
product listings fetched from a remote API and allow users to add items
to their cart.
• Variant 5: Create a weather forecasting app using MVVM architecture
and LiveData to display weather updates fetched from a weather API.