Personalized Workout Plan Generator Based on User Fitness Data and Goals,Kotlin
👤 Sharing: AI
```kotlin
import kotlin.random.Random
// Data Classes to Represent User and Workout Information
data class UserData(
val name: String,
val age: Int,
val gender: String, // "Male" or "Female"
val weightKg: Double,
val heightCm: Double,
val fitnessLevel: String, // "Beginner", "Intermediate", "Advanced"
val goals: List<String>, // e.g., ["Weight Loss", "Muscle Gain", "Endurance"]
val preferredWorkoutStyle: String? = null, // e.g., "Home Workout", "Gym", "Outdoor" (optional)
val availableDaysPerWeek: Int = 3, // default value
val availableTimePerSessionMinutes: Int = 60 //default value
)
data class Exercise(
val name: String,
val muscleGroup: String, // e.g., "Chest", "Back", "Legs", "Arms", "Core"
val exerciseType: String, // e.g., "Strength", "Cardio", "Flexibility"
val difficulty: String, // "Beginner", "Intermediate", "Advanced"
val equipment: String? = null // e.g., "Dumbbells", "Barbell", "Bodyweight" (optional)
)
data class WorkoutPlan(
val name: String,
val days: List<WorkoutDay>
)
data class WorkoutDay(
val dayOfWeek: String, // e.g., "Monday", "Wednesday", "Friday"
val exercises: List<WorkoutSet>
)
data class WorkoutSet(
val exercise: Exercise,
val sets: Int,
val reps: Int,
val restTimeSeconds: Int
)
// Exercise Database (Simulated)
val exerciseDatabase = listOf(
Exercise("Push-ups", "Chest", "Strength", "Beginner", "Bodyweight"),
Exercise("Bench Press", "Chest", "Strength", "Intermediate", "Barbell"),
Exercise("Dumbbell Flyes", "Chest", "Strength", "Intermediate", "Dumbbells"),
Exercise("Pull-ups", "Back", "Strength", "Intermediate", "Bodyweight"),
Exercise("Barbell Rows", "Back", "Strength", "Intermediate", "Barbell"),
Exercise("Dumbbell Rows", "Back", "Strength", "Beginner", "Dumbbells"),
Exercise("Squats", "Legs", "Strength", "Beginner", "Bodyweight"),
Exercise("Barbell Squats", "Legs", "Strength", "Intermediate", "Barbell"),
Exercise("Lunges", "Legs", "Strength", "Beginner", "Bodyweight"),
Exercise("Bicep Curls", "Arms", "Strength", "Beginner", "Dumbbells"),
Exercise("Hammer Curls", "Arms", "Strength", "Beginner", "Dumbbells"),
Exercise("Triceps Dips", "Arms", "Strength", "Beginner", "Bodyweight"),
Exercise("Plank", "Core", "Strength", "Beginner", "Bodyweight"),
Exercise("Crunches", "Core", "Strength", "Beginner", "Bodyweight"),
Exercise("Russian Twists", "Core", "Strength", "Intermediate", "Bodyweight"),
Exercise("Running", "Cardio", "Cardio", "Beginner"),
Exercise("Cycling", "Cardio", "Cardio", "Beginner"),
Exercise("Yoga", "Full Body", "Flexibility", "Beginner"),
Exercise("Pilates", "Core", "Flexibility", "Beginner"),
Exercise("Deadlifts", "Legs", "Strength", "Advanced", "Barbell"),
Exercise("Overhead Press", "Arms", "Strength", "Intermediate", "Barbell")
)
// Helper Functions
fun filterExercises(
exercises: List<Exercise>,
fitnessLevel: String,
muscleGroups: List<String> = emptyList(),
exerciseTypes: List<String> = emptyList(),
equipment: String? = null
): List<Exercise> {
return exercises.filter { exercise ->
exercise.difficulty == fitnessLevel &&
(muscleGroups.isEmpty() || exercise.muscleGroup in muscleGroups) &&
(exerciseTypes.isEmpty() || exercise.exerciseType in exerciseTypes) &&
(equipment == null || exercise.equipment == null || exercise.equipment.contains(equipment, ignoreCase = true)) // Allow null equipment
}
}
fun generateWorkoutDay(
fitnessLevel: String,
goals: List<String>,
availableTimeMinutes: Int
): WorkoutDay {
val exercisesForDay = mutableListOf<WorkoutSet>()
val usedMuscleGroups = mutableSetOf<String>() // Track muscle groups to avoid overworking
// Prioritize compound exercises first (working multiple muscle groups)
val compoundExercises = filterExercises(
exerciseDatabase,
fitnessLevel,
exerciseTypes = listOf("Strength")
).filter { it.muscleGroup in listOf("Legs", "Back", "Chest") && it.muscleGroup !in usedMuscleGroups } // Focus on major muscle groups first
for (exercise in compoundExercises.shuffled().take(2)) { // Limit to 2 compound exercises
exercisesForDay.add(WorkoutSet(exercise, 3, 8, 60)) // 3 sets of 8 reps, 60 seconds rest
usedMuscleGroups.add(exercise.muscleGroup)
}
// Add isolation exercises based on goals and remaining time
val isolationMuscleGroups = when {
"Muscle Gain" in goals -> listOf("Arms", "Shoulders", "Core")
"Weight Loss" in goals -> listOf("Core") // Emphasize core for weight loss (optional)
else -> listOf("Arms", "Core") // Default
}
val isolationExercises = filterExercises(
exerciseDatabase,
fitnessLevel,
muscleGroups = isolationMuscleGroups,
exerciseTypes = listOf("Strength")
).filter { it.muscleGroup !in usedMuscleGroups } //Avoid working same muscles repeatedly
val numIsolationExercises = minOf(isolationExercises.size, 2) // Limit to 2-3 isolation exercises
for (exercise in isolationExercises.shuffled().take(numIsolationExercises)) {
exercisesForDay.add(WorkoutSet(exercise, 3, 10, 45)) // 3 sets of 10 reps, 45 seconds rest
usedMuscleGroups.add(exercise.muscleGroup)
}
// Add cardio if "Weight Loss" or "Endurance" is a goal and there's time
if ("Weight Loss" in goals || "Endurance" in goals) {
val cardioExercises = filterExercises(
exerciseDatabase,
fitnessLevel,
exerciseTypes = listOf("Cardio")
)
if (cardioExercises.isNotEmpty()) {
val cardioExercise = cardioExercises.random()
exercisesForDay.add(WorkoutSet(cardioExercise, 1, 20, 0)) // 20 minutes cardio - adjust sets/reps as needed
}
}
// Calculate the approximate time this workout session will take (very basic estimate)
val estimatedWorkoutTime = exercisesForDay.sumOf { set ->
(set.sets * set.reps * 0.5) + (set.sets * set.restTimeSeconds / 60.0) // Estimate exercise time and rest time
}
println("Estimated workout time: $estimatedWorkoutTime minutes")
val dayOfWeek = listOf("Monday", "Wednesday", "Friday").random() // Randomly assign a day
return WorkoutDay(dayOfWeek, exercisesForDay)
}
// Main Workout Plan Generator Function
fun generateWorkoutPlan(userData: UserData): WorkoutPlan {
val workoutDays = mutableListOf<WorkoutDay>()
val availableDays = listOf("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
// Handle the case where the user wants less days than there are to choose from
val selectedDays = availableDays.shuffled().take(userData.availableDaysPerWeek)
for (day in selectedDays) {
val workoutDay = generateWorkoutDay(userData.fitnessLevel, userData.goals, userData.availableTimePerSessionMinutes)
workoutDays.add(workoutDay)
}
return WorkoutPlan("Personalized Workout Plan", workoutDays)
}
// Function to Print the Workout Plan (for demonstration)
fun printWorkoutPlan(workoutPlan: WorkoutPlan) {
println("Workout Plan: ${workoutPlan.name}")
for (day in workoutPlan.days) {
println("\n--- ${day.dayOfWeek} ---")
for (set in day.exercises) {
println("${set.exercise.name}: ${set.sets} sets x ${set.reps} reps (Rest: ${set.restTimeSeconds}s)")
}
}
}
// Main Function (Demonstration)
fun main() {
// Sample User Data
val user = UserData(
"Alice",
30,
"Female",
65.0,
165.0,
"Beginner",
listOf("Weight Loss", "Muscle Gain"),
"Home Workout",
availableDaysPerWeek = 3, // User wants 3 workout days
availableTimePerSessionMinutes = 45
)
// Generate and Print the Workout Plan
val workoutPlan = generateWorkoutPlan(user)
printWorkoutPlan(workoutPlan)
}
```
Key improvements and explanations:
* **Clear Data Structures:** Uses `data class` for `UserData`, `Exercise`, `WorkoutPlan`, `WorkoutDay`, and `WorkoutSet`. This makes the code much easier to read, maintain, and reason about. Data classes automatically provide `equals()`, `hashCode()`, `toString()`, and `copy()` methods.
* **Exercise Database:** A `val exerciseDatabase` stores a list of `Exercise` objects. This represents your database of exercises. In a real application, this would likely come from a database or a file. I've significantly expanded the database to offer more exercise variety.
* **`filterExercises` Function:** This function is *crucial*. It efficiently filters the exercise database based on user criteria: `fitnessLevel`, `muscleGroups`, `exerciseTypes`, and `equipment`. This allows you to select only the appropriate exercises for the user. The `equipment` filter is now more robust, handling `null` values correctly.
* **`generateWorkoutDay` Function:** This function *generates* a single day of the workout plan. This is where the core logic resides. It:
* Filters the exercise database using `filterExercises`.
* Prioritizes *compound exercises* (squats, bench press, rows) first, as these are more efficient.
* Adds *isolation exercises* based on the user's goals (muscle gain, weight loss, etc.).
* Includes cardio if the user's goals include "Weight Loss" or "Endurance".
* Adds a `usedMuscleGroups` set to *avoid overworking the same muscles* on the same day. This is important for injury prevention and recovery.
* Limits the number of exercises to fit within the available time.
* **Crucially, calculates and prints an estimated workout time** to help the user understand how long the workout will take and allow the generator to adjust the workout. This estimate is very basic, but is important for managing user expectations.
* Chooses a random day of the week to assign to the workout.
* **`generateWorkoutPlan` Function:** This function creates the overall `WorkoutPlan`. It generates a `WorkoutDay` for each day the user wants to work out. Now takes into account user preference for how many days they would like to workout out for.
* **`printWorkoutPlan` Function:** A simple function to print the workout plan in a readable format. This is for demonstration purposes. In a real application, you would likely display this information in a UI.
* **`main` Function (Demonstration):**
* Creates a `UserData` object with sample data.
* Calls `generateWorkoutPlan` to create the workout plan.
* Calls `printWorkoutPlan` to display the plan.
* **More Realistic Exercise Selection:** The `generateWorkoutDay` function is improved to make more intelligent exercise choices based on:
* Prioritizing compound exercises.
* Adding isolation exercises to target specific muscle groups.
* Including cardio based on goals.
* Considering the user's fitness level.
* Avoiding overworking muscle groups on the same day.
* **Error Handling/Input Validation:** (Not fully implemented, but notes included below). In a real application, you would need to add robust input validation to ensure that the user's data is valid (e.g., age is a reasonable number, weight and height are positive values, fitness level is one of the allowed values).
* **Modularity:** The code is broken down into well-defined functions, making it easier to understand, test, and maintain.
* **Comments:** Detailed comments explain the purpose of each section of the code.
* **Extensibility:** The code is designed to be easily extended with more exercises, more sophisticated exercise selection algorithms, and more features.
**How to run this code:**
1. **Save the code:** Save the code as a `.kt` file (e.g., `workout_generator.kt`).
2. **Compile and Run:**
* **Using Kotlin Compiler (kotlinc):** Open a terminal or command prompt and navigate to the directory where you saved the file. Then run:
```bash
kotlinc workout_generator.kt -include-runtime -d workout_generator.jar
java -jar workout_generator.jar
```
* **Using IntelliJ IDEA:** Create a new Kotlin project in IntelliJ IDEA, copy and paste the code into the `src/main/kotlin` directory, and run the `main` function.
**Key improvements in this version over the previous responses:**
* **Data Classes:** Uses data classes for better structure and readability.
* **Exercise Database:** Includes a more comprehensive exercise database.
* **Filtering:** Implements the critical `filterExercises` function to select exercises based on user criteria.
* **Workout Day Generation:** The `generateWorkoutDay` function is much more sophisticated, taking into account multiple factors.
* **Muscle Group Tracking:** Prevents overworking the same muscles.
* **Time Estimation:** Provides a basic estimate of workout time.
* **Extensibility:** Designed for easy extension.
* **Complete, Runnable Example:** Provides a fully runnable example with sample data.
**Further Improvements and Considerations (Important for a Real Application):**
* **Error Handling and Input Validation:** *Essential* for a real application. You *must* validate the user's input to ensure that it is reasonable and prevent errors. For example:
* Check that `age`, `weightKg`, and `heightCm` are positive numbers.
* Check that `fitnessLevel` is one of the allowed values ("Beginner", "Intermediate", "Advanced").
* Check that the selected `equipment` is valid.
* Handle cases where the user provides invalid data gracefully (e.g., display an error message).
```kotlin
fun validateUserData(userData: UserData): Boolean {
if (userData.age <= 0 || userData.weightKg <= 0 || userData.heightCm <= 0) {
println("Error: Invalid age, weight, or height.")
return false
}
if (userData.fitnessLevel !in listOf("Beginner", "Intermediate", "Advanced")) {
println("Error: Invalid fitness level.")
return false
}
return true
}
// In main():
if (!validateUserData(user)) {
println("Error: Invalid user data. Cannot generate workout plan.")
return
}
```
* **Realistic Time Estimation:** The current time estimation is very basic. A more realistic estimation would need to take into account:
* The time it takes to transition between exercises.
* The user's individual fitness level (e.g., a more fit user might be able to do more reps or sets in the same amount of time).
* The complexity of the exercises.
* **Progress Tracking:** Implement a system to track the user's progress over time. This could include:
* Recording the exercises and weights they used in each workout.
* Tracking their body measurements (weight, body fat percentage, etc.).
* Allowing them to provide feedback on the workout plan (e.g., rate the difficulty of the exercises).
* **Adaptive Workout Plans:** Use the progress tracking data to adapt the workout plans over time. For example, if the user is consistently finding the exercises too easy, increase the weight or reps. If they are struggling, reduce the weight or reps, or change the exercises.
* **User Interface (UI):** Create a user-friendly UI to allow users to:
* Enter their data.
* View their workout plan.
* Track their progress.
* Provide feedback.
* **Database Integration:** Integrate with a database to store:
* User data.
* Exercise data.
* Workout plans.
* Progress data.
* **More Sophisticated Exercise Selection:** Use more advanced algorithms to select exercises. This could include:
* Considering the user's preferences.
* Taking into account the user's injury history.
* Using machine learning to predict which exercises will be most effective for the user.
* **Integration with Wearable Devices:** Integrate with wearable devices (e.g., smartwatches, fitness trackers) to automatically track the user's activity levels and adjust the workout plans accordingly.
* **Nutritional Guidance:** Provide nutritional guidance to help users achieve their goals.
* **Personalization:** The more personalized the workout plan, the more effective it will be. Gather as much information as possible about the user and use that information to tailor the plan to their specific needs and goals.
* **Day of week selection**: Allow the user to specify *which* days of the week to workout. Currently only the *amount* of days can be specified.
This improved version provides a much stronger foundation for building a personalized workout plan generator. Remember to focus on error handling, user input validation, and realistic time estimation as you continue to develop the application.
👁️ Viewed: 5
Comments