输入以下文字：”Android ，Kotin 。瑜伽练习，计算卡路里。根据 人的体重（kg） ，练习时长（分钟）,难度等级（等级分为4个级别） 和 动作完成度（100% 是 动作 完全到位，20%为只能完成了20%），计算卡路里。 输出一个公式。“

百度Deepseek：

import kotlin.math.round

class CaloriesCalculator {
    
    /**
     * 计算瑜伽练习消耗的卡路里
     * @param weight 体重（kg）
     * @param duration 练习时长（分钟）
     * @param difficultyLevel 难度等级（1-4）
     * @param completionRate 动作完成度（20%-100%）
     * @return 消耗的卡路里（大卡）
     */
    fun calculateYogaCalories(
        weight: Double,
        duration: Double,
        difficultyLevel: Int,
        completionRate: Double
    ): Double {
        // 难度等级系数
        val difficultyMultiplier = when (difficultyLevel) {
            1 -> 1.0  // 低强度
            2 -> 1.8  // 中等强度
            3 -> 2.5  // 高强度
            4 -> 3.2  // 极高强度
            else -> 2.0
        }
        
        // 基础卡路里消耗（每分钟）
        val baseCaloriesPerMinute = 3.5
        
        // 计算总消耗
        val totalCalories = baseCaloriesPerMinute * 
                           (weight / 70.0) *  // 体重修正
                           difficultyMultiplier *  // 难度修正
                           (duration / 10.0) *  // 时间修正
                           (completionRate / 100.0)  // 完成度修正
        
        return round(totalCalories * 100) / 100  // 保留两位小数
    }
}

// 示例使用
fun main() {
    val calculator = CaloriesCalculator()
    
    // 输入参数
    val weight = 65.0  // 体重（kg）
    val duration = 30.0  // 练习时长（分钟）
    val difficultyLevel = 3  // 难度等级（1-4）
    val completionRate = 80.0  // 动作完成度（百分比）
    
    // 计算消耗的卡路里
    val calories = calculator.calculateYogaCalories(weight, duration, difficultyLevel, completionRate)
    println("消耗的卡路里: $calories 大卡")
}

代码说明：1. 该算法通过基础代谢率、体重修正、难度等级和动作完成度四个因素计算瑜伽消耗的卡路里。
2. 使用了标准化的公式，其中基础代谢率系数根据难度等级调整，体重和完成度也作为修正因子。
3. 该实现可灵活应用于不同体重、时长、难度和完成度的瑜伽练习场景。
4. 难度等级分为4个级别，对应不同的消耗系数。
5. 动作完成度范围为20%至100%，影响最终消耗计算。

Claude：

package com.example.yogacalorie

import kotlin.math.roundToInt

// ─────────────────────────────────────────────
//  数据模型
// ─────────────────────────────────────────────

/**
 * 瑜伽难度等级
 *
 * MET（代谢当量）参考 ACSM / Compendium of Physical Activities
 *  Level1 修复/初级  MET = 2.5
 *  Level2 哈他/基础  MET = 3.3
 *  Level3 流瑜伽     MET = 4.5
 *  Level4 力量/热瑜伽 MET = 6.0
 */
enum class YogaDifficulty(
    val level: Int,
    val label: String,
    val description: String,
    val met: Double
) {
    LEVEL_1(1, "初级", "修复性 / 冥想瑜伽", 2.5),
    LEVEL_2(2, "基础", "哈他 / 阴瑜伽",     3.3),
    LEVEL_3(3, "中级", "流瑜伽 / Vinyasa",  4.5),
    LEVEL_4(4, "高级", "力量 / 热瑜伽",      6.0);

    companion object {
        fun fromLevel(level: Int): YogaDifficulty =
            entries.firstOrNull { it.level == level } ?: LEVEL_1
    }
}

/**
 * 瑜伽练习输入参数
 *
 * @param weightKg      体重（公斤），范围 30–200 kg
 * @param durationMin   练习时长（分钟），范围 1–300 min
 * @param difficulty    难度等级
 * @param completionPct 动作完成度，0.0（0%）~ 1.0（100%）
 */
data class YogaInput(
    val weightKg: Double,
    val durationMin: Int,
    val difficulty: YogaDifficulty,
    val completionPct: Double          // 0.0 ~ 1.0
) {
    init {
        require(weightKg in 30.0..200.0)   { "体重应在 30~200 kg 之间" }
        require(durationMin in 1..300)      { "时长应在 1~300 分钟之间" }
        require(completionPct in 0.0..1.0)  { "完成度应在 0%~100% 之间" }
    }
}

/**
 * 计算结果
 */
data class CalorieResult(
    val totalKcal: Double,          // 含完成度修正后的总卡路里
    val baseKcal: Double,           // 100% 完成度下的基础卡路里（参考值）
    val metUsed: Double,
    val input: YogaInput
) {
    /** 格式化显示 */
    val totalKcalRounded: Int get() = totalKcal.roundToInt()
    val baseKcalRounded: Int  get() = baseKcal.roundToInt()
}

// ─────────────────────────────────────────────
//  核心计算器
// ─────────────────────────────────────────────

object YogaCalorieCalculator {

    /**
     * 卡路里计算公式
     *
     *   Calories(kcal) = MET × 体重(kg) × 时长(h) × 完成度
     *
     * 其中：
     *   MET      — 由难度等级决定（见 YogaDifficulty）
     *   时长(h)  — durationMin / 60.0
     *   完成度   — completionPct（0.0 ~ 1.0）
     *
     * 公式来源：Harris-Benedict 扩展版 MET 公式
     *   kcal = MET × weight_kg × time_hours
     * 加入完成度系数使结果更贴合实际燃脂情况。
     */
    fun calculate(input: YogaInput): CalorieResult {
        val met        = input.difficulty.met
        val timeHours  = input.durationMin / 60.0
        val baseKcal   = met * input.weightKg * timeHours          // 100% 完成度基准
        val totalKcal  = baseKcal * input.completionPct            // 乘以完成度系数

        return CalorieResult(
            totalKcal = totalKcal,
            baseKcal  = baseKcal,
            metUsed   = met,
            input     = input
        )
    }

    /**
     * 便捷方法：直接传基本参数
     *
     * @param weightKg      体重 kg
     * @param durationMin   时长 分钟
     * @param difficultyLevel 1~4
     * @param completionPercent 1~100 整数
     */
    fun calculate(
        weightKg: Double,
        durationMin: Int,
        difficultyLevel: Int,
        completionPercent: Int
    ): CalorieResult {
        val input = YogaInput(
            weightKg      = weightKg,
            durationMin   = durationMin,
            difficulty    = YogaDifficulty.fromLevel(difficultyLevel),
            completionPct = completionPercent / 100.0
        )
        return calculate(input)
    }
}

好的！先确定卡路里计算公式，再给出完整 Android Kotlin 实现。

📐 公式设计

基于运动科学的 MET（代谢当量）公式：

$$\text{卡路里(kcal)} = \text{MET}_{(\text{难度})} \times \text{体重(kg)} \times \frac{\text{时长(min)}}{60} \times \text{完成度(0%\sim100%)}$$

完成度作为线性系数，100% 完成度 = 满分卡路里，20% 完成度 = 只燃烧 20% 卡路里。

现在生成完整代码：现在做一个可以实际交互的计算器预览：上面的计算器可以直接试用。以下是代码文件说明：

📦 文件说明

YogaCalorieCalculator.kt — 核心逻辑层（纯 Kotlin，无 Android 依赖）

• YogaDifficulty enum — 四个等级及对应 MET 值
• YogaInput data class — 输入参数 + 校验
• YogaCalorieResult data class — 计算结果
• YogaCalorieCalculator object — 计算器主逻辑

MainActivity.kt — UI 控制器

• 难度选择按钮组联动
• SeekBar 完成度滑块（最低 20%）
• 结果卡片 + 卡路里数字滚动动画
• 趣味食物对比（米饭/香蕉）

activity_main.xml — 布局文件（Material Design）

YogaCalorieCalculatorTest.kt — 单元测试，覆盖公式验证和边界情况

核心公式一览

kcal = MET(难度) × 体重(kg) × 时长(h) × 完成度(0~1)

对比起来，百度是高中生的水平。Claude是研究生水平。我虽然也是研究生毕业。但是，我是写不出，Claude这样的专业的代码和清晰的思路。