交通事故赔偿

复制import json

# 交通事故赔偿计算：责任比例 + 各项费用

def calc_compensation(
    total_loss: float,       # 总损失（元）
    liability_ratio: float,  # 己方责任比例（0-1）
    medical: float = 0,      # 医疗费
    lost_wage: float = 0,    # 误工费
    nursing: float = 0,      # 护理费
    disability: float = 0    # 残疾赔偿金
) -> dict:
    if not (0 <= liability_ratio <= 1):
        raise ValueError("责任比例必须在 0~1 之间")
    
    # 对方赔偿 = 总损失 × (1 - 己方责任比例)
    other_pay = total_loss * (1 - liability_ratio)
    
    # 各项赔偿明细（对方承担部分）
    items = {
        "医疗费": medical * (1 - liability_ratio),
        "误工费": lost_wage * (1 - liability_ratio),
        "护理费": nursing * (1 - liability_ratio),
        "残疾赔偿金": disability * (1 - liability_ratio),
    }
    
    return {
        "总损失": total_loss,
        "己方责任比例": liability_ratio,
        "对方赔偿总额": round(other_pay, 2),
        "各项明细": {k: round(v, 2) for k, v in items.items()}
    }

# 示例：总损失 50 万，己方主责 70%
result = calc_compensation(
    total_loss=500000,
    liability_ratio=0.7,
    medical=80000,
    lost_wage=30000,
    nursing=15000,
    disability=200000
)
print(json.dumps(result, ensure_ascii=False, indent=2))
"""
输出：
{
  "总损失": 500000,
  "己方责任比例": 0.7,
  "对方赔偿总额": 150000.0,
  "各项明细": {
    "医疗费": 24000.0,
    "误工费": 9000.0,
    "护理费": 4500.0,
    "残疾赔偿金": 60000.0
  }
}
"""

复制package main

import (
	"fmt"
	"math"
)

// Compensation 交通事故赔偿计算
type Compensation struct {
	TotalLoss      float64            // 总损失
	LiabilityRatio float64            // 己方责任比例 (0-1)
	Items          map[string]float64 // 各项费用明细
}

func (c *Compensation) Calc() (float64, map[string]float64, error) {
	if c.LiabilityRatio < 0 || c.LiabilityRatio > 1 {
		return 0, nil, fmt.Errorf("责任比例必须在 0~1 之间")
	}
	// 对方赔偿 = 总损失 × (1 - 己方责任比例)
	otherPay := c.TotalLoss * (1 - c.LiabilityRatio)
	// 各项赔偿（对方承担部分）
	details := make(map[string]float64)
	for k, v := range c.Items {
		details[k] = math.Round(v*(1-c.LiabilityRatio)*100) / 100
	}
	return math.Round(otherPay*100) / 100, details, nil
}

func main() {
	c := Compensation{
		TotalLoss:      500000,
		LiabilityRatio: 0.7,
		Items: map[string]float64{
			"医疗费":     80000,
			"误工费":     30000,
			"护理费":     15000,
			"残疾赔偿金": 200000,
		},
	}
	otherPay, details, err := c.Calc()
	if err != nil {
		fmt.Println("错误:", err)
		return
	}
	fmt.Printf("对方赔偿总额: %.2f\n", otherPay)
	fmt.Println("各项明细:")
	for k, v := range details {
		fmt.Printf("  %s: %.2f\n", k, v)
	}
	// 输出:
	// 对方赔偿总额: 150000.00
	// 各项明细:
	//   医疗费: 24000.00
	//   误工费: 9000.00
	//   护理费: 4500.00
	//   残疾赔偿金: 60000.00
}

复制/**
 * 交通事故赔偿计算
 * @param {number} totalLoss - 总损失（元）
 * @param {number} liabilityRatio - 己方责任比例 (0-1)
 * @param {object} items - 各项费用明细
 * @returns {{ otherPay: number, details: object }}
 */
function calcCompensation(totalLoss, liabilityRatio, items = {}) {
  if (liabilityRatio < 0 || liabilityRatio > 1) {
    throw new Error('责任比例必须在 0~1 之间');
  }
  // 对方赔偿 = 总损失 × (1 - 己方责任比例)
  const otherPay = Math.round(totalLoss * (1 - liabilityRatio) * 100) / 100;
  // 各项赔偿（对方承担部分）
  const details = {};
  for (const [key, value] of Object.entries(items)) {
    details[key] = Math.round(value * (1 - liabilityRatio) * 100) / 100;
  }
  return { otherPay, details };
}

// 示例：总损失 50 万，己方主责 70%
const result = calcCompensation(500000, 0.7, {
  '医疗费': 80000,
  '误工费': 30000,
  '护理费': 15000,
  '残疾赔偿金': 200000
});
console.log('对方赔偿总额:', result.otherPay);
console.log('各项明细:', result.details);
// 输出:
// 对方赔偿总额: 150000
// 各项明细: { 医疗费: 24000, 误工费: 9000, 护理费: 4500, 残疾赔偿金: 60000 }