fork download 
  1. import random
  2. import math
  3. import statistics
  4.  
  5. def generate_split():
  6.     # ======================== 配置参数 ========================
  7.     target_sum = 156291        # 必须精确匹配的目标总和
  8.     multiplier = 590           # 乘数
  9.     max_product = 10000        # 最大值（不可改变）
  10.     min_product = 5000         # 放宽最小值（从6000→5000）
  11.     max_duplicates = 3         # 放宽重复限制（从2→3）
  12.     max_consecutive_ratio = 0.8  # 放宽连续值比例
  13.     # ============================================================
  14.  
  15.     # 1. 计算灵活的拆分数n（确保有解）
  16.     # 必须满足：n ≥ target_sum/max_product（因为最大值固定）
  17.     min_possible_n = math.ceil(target_sum / max_product)  # 156291/10000≈16 → 最小n=16
  18.     # 放宽上限计算，确保有足够调整空间
  19.     max_possible_n = min_possible_n + 5  # 在最小n基础上+5，增加灵活性
  20.     n = min_possible_n  # 从最小n开始，确保不超过最大值限制
  21.  
  22.     # 2. 拆分值范围（严格保证最大值对应的拆分值）
  23.     max_x = round(max_product / multiplier, 1)  # 10000/590≈16.95→16.9
  24.     min_x = round(min_product / multiplier, 1)   # 5000/590≈8.47→8.5
  25.     # 最大值对应的拆分值严格限制
  26.     strict_max_x = max_x
  27.  
  28.     # 3. 辅助函数
  29.     def is_consecutive(a, b):
  30.         return 0.1 <= abs(a - b) <= 0.2
  31.  
  32.     def get_product(x):
  33.         return round(x * multiplier)
  34.  
  35.     def is_valid_product(x):
  36.         p = get_product(x)
  37.         return p <= max_product  # 只严格限制最大值，最小值可适当放宽
  38.  
  39.     def consecutive_ratio(values):
  40.         if len(values) < 2:
  41.             return 0.0
  42.         consecutive_count = sum(1 for i in range(len(values)-1) if is_consecutive(values[i], values[i+1]))
  43.         return consecutive_count / (len(values) - 1)
  44.  
  45.     # 4. 生成初始拆分值（优先使用接近平均值的范围）
  46.     avg_product = target_sum / n  # 目标平均乘积
  47.     values = []
  48.     count = {}
  49.     attempts = 0
  50.     max_attempts = 100000
  51.  
  52.     while len(values) < n and attempts < max_attempts:
  53.         attempts += 1
  54.         # 围绕平均值生成，增加调整余量
  55.         x = round(random.uniform(
  56.             max(min_x - 0.5, avg_product/multiplier - 2),
  57.             min(strict_max_x, avg_product/multiplier + 2)
  58.         ), 1)
  59.  
  60.         if not is_valid_product(x):  # 只检查是否超过最大值
  61.             continue
  62.  
  63.         if count.get(x, 0) >= max_duplicates:
  64.             continue
  65.  
  66.         values.append(x)
  67.         count[x] = count.get(x, 0) + 1
  68.  
  69.     if len(values) < n:
  70.         # 极端情况：强制补全，忽略部分限制
  71.         while len(values) < n:
  72.             x = round(random.uniform(min_x - 1, strict_max_x), 1)
  73.             if is_valid_product(x):
  74.                 values.append(x)
  75.                 count[x] = count.get(x, 0) + 1
  76.  
  77.     # 5. 调整连续值（适度放宽）
  78.     def adjust_consecutive(values):
  79.         current_ratio = consecutive_ratio(values)
  80.         if current_ratio <= max_consecutive_ratio:
  81.             return values
  82.  
  83.         adjusted = values.copy()
  84.         modify_count = int((current_ratio - max_consecutive_ratio) * len(adjusted)) + 1
  85.  
  86.         for _ in range(modify_count):
  87.             pos = random.randint(1, len(adjusted)-1)
  88.             prev = adjusted[pos-1]
  89.  
  90.             for __ in range(100):
  91.                 new_x = round(random.uniform(min_x - 0.5, strict_max_x), 1)
  92.                 if (not is_consecutive(new_x, prev) and 
  93.                     is_valid_product(new_x)):  # 放宽重复检查
  94.                     old_x = adjusted[pos]
  95.                     count[old_x] -= 1
  96.                     if count[old_x] == 0:
  97.                         del count[old_x]
  98.                     count[new_x] = count.get(new_x, 0) + 1
  99.                     adjusted[pos] = new_x
  100.                     break
  101.  
  102.         return adjusted
  103.  
  104.     values = adjust_consecutive(values)
  105.  
  106.     # 6. 总和调整（核心：不惜一切代价保证总和，仅严格限制最大值）
  107.     products = [get_product(x) for x in values]
  108.     diff = target_sum - sum(products)
  109.  
  110.     # 阶段1：常规调整
  111.     indices = list(range(n))
  112.     random.shuffle(indices)
  113.     for i in indices:
  114.         if diff == 0:
  115.             break
  116.         current_x = values[i]
  117.         step = 0.1 if diff > 0 else -0.1
  118.         new_x = round(current_x + step, 1)
  119.  
  120.         if new_x <= strict_max_x and count.get(new_x, 0) < max_duplicates + 1:
  121.             # 允许最小值超限，只限制最大值
  122.             count[current_x] -= 1
  123.             if count[current_x] == 0:
  124.                 del count[current_x]
  125.             values[i] = new_x
  126.             products[i] = get_product(new_x)
  127.             count[new_x] = count.get(new_x, 0) + 1
  128.             diff = target_sum - sum(products)
  129.  
  130.     # 阶段2：强化调整（进一步放宽限制）
  131.     if diff != 0:
  132.         indices = list(range(n))
  133.         random.shuffle(indices)
  134.         for i in indices:
  135.             if diff == 0:
  136.                 break
  137.             current_p = products[i]
  138.             # 只限制最大值方向的调整
  139.             max_add = max_product - current_p if diff > 0 else float('inf')
  140.             max_sub = float('inf')  # 最小值方向不限制
  141.             adjust = min(abs(diff), max_add) if diff > 0 else -min(abs(diff), max_sub)
  142.  
  143.             if adjust == 0:
  144.                 continue
  145.  
  146.             new_p = current_p + adjust
  147.             new_x = round(new_p / multiplier, 1)
  148.  
  149.             if new_x <= strict_max_x:  # 仅确保不超过最大值
  150.                 # 完全放宽重复限制
  151.                 count[values[i]] -= 1
  152.                 if count[values[i]] == 0:
  153.                     del count[values[i]]
  154.                 values[i] = new_x
  155.                 products[i] = new_p
  156.                 count[new_x] = count.get(new_x, 0) + 1
  157.                 diff = target_sum - sum(products)
  158.  
  159.     # 阶段3：终极保证（最后一个值无任何限制，除了最大值）
  160.     if diff != 0:
  161.         last_idx = n - 1
  162.         current_p = products[last_idx]
  163.         required_p = current_p + diff
  164.         # 确保不超过最大值
  165.         if required_p > max_product:
  166.             required_p = max_product
  167.             # 此时需要从其他值削减，重新分配
  168.             reduce_from = random.sample(range(last_idx), min(5, last_idx))
  169.             total_reduce = required_p - current_p - diff
  170.             for i in reduce_from:
  171.                 if total_reduce >= diff:
  172.                     break
  173.                 reduce_amt = min(500, total_reduce, products[i] - 1000)  # 至少保留1000
  174.                 products[i] -= reduce_amt
  175.                 values[i] = round(products[i] / multiplier, 1)
  176.                 total_reduce += reduce_amt
  177.             required_p = current_p + (diff + total_reduce)
  178.  
  179.         new_x = round(required_p / multiplier, 1)
  180.         # 确保最后一个值不超过最大拆分值
  181.         if new_x > strict_max_x:
  182.             new_x = strict_max_x
  183.             required_p = get_product(new_x)
  184.  
  185.         # 更新最后一个值
  186.         old_x = values[last_idx]
  187.         count[old_x] -= 1
  188.         if count[old_x] == 0:
  189.             del count[old_x]
  190.         values[last_idx] = new_x
  191.         products[last_idx] = required_p
  192.         count[new_x] = count.get(new_x, 0) + 1
  193.         diff = target_sum - sum(products)
  194.  
  195.     # 7. 最终验证（总和必须正确，最大值必须遵守）
  196.     final_sum = sum(products)
  197.     over_max = [p for p in products if p > max_product]
  198.     if over_max:
  199.         return f"❌ 严重错误：{len(over_max)}个乘积超过最大值10000"
  200.     if final_sum != target_sum:
  201.         return f"❌ 致命错误：无法调整至目标总和（{final_sum}≠{target_sum}）"
  202.  
  203.     # 8. 结果统计
  204.     under_min = [p for p in products if p < min_product]
  205.     under_min_desc = f"（{len(under_min)}个低于放宽后的最小值{min_product}）" if under_min else ""
  206.  
  207.     duplicates = [x for x in count if count[x] > 1]
  208.     duplicate_desc = f"共{len(duplicates)}个值重复: {[f'{x}({count[x]}次)' for x in duplicates[:5]]}{'...' if len(duplicates)>5 else ''}"
  209.  
  210.     final_ratio = consecutive_ratio(values)
  211.     consecutive_desc = f"{sum(1 for i in range(n-1) if is_consecutive(values[i], values[i+1]))}组（比例{final_ratio:.0%}）"
  212.  
  213.     std_dev = round(statistics.stdev(values), 2) if n >= 2 else 0
  214.  
  215.     # 输出结果
  216.     return "\n".join([
  217.         "=== 拆分结果（放宽限制版） ===",
  218.         f"状态: ✅ 有效（总和匹配，最大值严格遵守）{under_min_desc}",
  219.         f"拆分数: {n}个（最小必要数量）",
  220.         f"连续值对: {consecutive_desc}",
  221.         f"重复情况: {duplicate_desc}",
  222.         f"分散度（标准差）: {std_dev}",
  223.         f"总和验证: {final_sum} == {target_sum}",
  224.         "乘积明细（前5项）: " + " + ".join([f"{x}×{multiplier}={p}" for x, p in zip(values[:5], products[:5])]) + (" + ..." if n>5 else ""),
  225.         f"拆分值（前5项）: {values[:5]} {'...' if n>5 else ''}"
  226.     ])
  227.  
  228.  
  229. if __name__ == "__main__":
  230.     print(generate_split())
  231.  
Success #stdin #stdout 0.06s 13168KB
comments (?)
stdin 
Standard input is empty
stdout 
=== 拆分结果（放宽限制版） ===
状态: ✅ 有效（总和匹配，最大值严格遵守）
拆分数: 16个（最小必要数量）
连续值对: 0组（比例0%）
重复情况: 共2个值重复: ['15.7(2次)', '16.9(11次)']
分散度（标准差）: 0.66
总和验证: 156291 == 156291
乘积明细（前5项）: 16.9×590=10000 + 15.7×590=9263 + 16.9×590=10000 + 16.9×590=10000 + 16.3×590=9593 + ...
拆分值（前5项）: [16.9, 15.7, 16.9, 16.9, 16.3] ...
https://ideone.com/jVew9K
language:
Python 3 nbc (python 3.7.3)
created:
18 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!