如何在Elixir中利用质数列表优化欧拉项目解题效率？

核心问题：Elixir的不可变性 #

你遇到的问题本质是Elixir变量是不可变的，命令式语言里的可变变量在Elixir里不存在。你在for循环里写的list = list ++ [i]只是在当前迭代的作用域里创建了一个新的list绑定，完全不会影响循环外的原始list——这就是为什么编译器警告你“外部的list未被使用”。

解决欧拉第7题：高效生成第N个质数 #

你提到的用已生成的质数列表验证新数的思路是对的，在Elixir里可以用Stream.unfold实现状态跟踪（维护已发现的质数列表），贴合你原本的Stream风格：

defmodule PrimeGenerator do
  def nth_prime(n) do
    Stream.unfold([2], fn primes ->
      next_candidate = List.last(primes) + 1
      next_prime = find_next_prime(next_candidate, primes)
      new_primes = primes ++ [next_prime]
      {next_prime, new_primes}
    end)
    |> Enum.take(n - 1)
    |> List.last()
    # 初始primes已包含第一个质数2，只需再取n-1个
  end

  defp find_next_prime(candidate, primes) do
    sqrt_candidate = :math.sqrt(candidate) |> Float.floor() |> trunc()
    # 仅检查候选数平方根以内的质数，减少无效计算
    if Enum.any?(primes, fn p -> p > sqrt_candidate or rem(candidate, p) == 0 end) do
      find_next_prime(candidate + 1, primes)
    else
      candidate
    end
  end
end

# 获取第10001个质数
PrimeGenerator.nth_prime(10001)

优化点说明：

• 仅检查候选数平方根以内的质数：若一个数有大于平方根的因数，对应另一个因数必然小于平方根，无需额外检查
• 复用已生成的质数列表：避免从2开始遍历所有数，效率大幅提升
• Stream.unfold维护状态：每次迭代传递更新后的质数列表，模拟命令式“可变列表”的逻辑，但完全符合Elixir不可变规则

解决欧拉第10题：计算两百万以内质数的和 #

这里不能用for循环直接“更新”列表，需改用Enum.reduce累积质数列表——reduce会把每一步的累积结果传递到下一次迭代，完美替代命令式的可变状态：

defmodule PrimeSum do
  def sum_below(n) do
    # 用reduce累积质数列表，初始值为[2]
    primes = Enum.reduce(3..(n-1), [2], fn i, acc ->
      sqrt_i = :math.sqrt(i) |> Float.floor() |> trunc()
      # 检查当前数是否能被已有的质数（且<=平方根）整除
      if Enum.any?(acc, fn p -> p > sqrt_i or rem(i, p) == 0 end) do
        acc # 非质数，累积值不变
      else
        acc ++ [i] # 是质数，加入累积列表
      end
    end)

    Enum.sum(primes)
  end
end

# 计算两百万以内质数的和
PrimeSum.sum_below(2_000_000) |> IO.puts()

关键修正：

• Enum.reduce(3..(n-1), [2], fn i, acc -> ... end)：acc是每次迭代时的质数列表，每次迭代返回新的acc（不变或添加新质数）
• 加入平方根检查优化，减少不必要的计算
• 完全符合Elixir不可变特性，无变量绑定冲突问题

额外性能提示 #

处理大列表时，acc ++ [i]的效率会逐渐降低（链表尾部追加需遍历整个列表），可以改成倒序存储质数列表，每次用[i | acc]添加新质数，最后反转：

primes = Enum.reduce(3..(n-1), [2], fn i, acc ->
  sqrt_i = :math.sqrt(i) |> Float.floor() |> trunc()
  if Enum.any?(acc, fn p -> p > sqrt_i or rem(i, p) == 0 end) do
    acc
  else
    [i | acc] # 链表头部插入，O(1)操作
  end
end)
|> Enum.reverse()

这样能大幅提升大列表的处理速度，因为链表头部插入是常数时间，尾部追加是线性时间。

内容的提问来源于stack exchange，提问作者SDA