C# 如何停止添加在C中出现两次的数字#

所以我试图找到这个问题的答案：

如果我们列出10以下的所有自然数，它们是3或5的倍数，我们得到3、5、6和9。这些倍数之和是23。 求1000以下所有3或5的倍数之和

我正在使用C#，并且对该做什么有很好的想法，但是我的代码一直在计算两次出现的数字（例如15、30），我想知道最快/最简单的方法来抵消这一点。到目前为止，我所发现的一切都是用不同的语言表达的，所以如果你觉得这相对容易的话，我很抱歉。这就是我到目前为止所做的：

static void Main(string[] args)
    {
        var result1 = 0;
        var result2 = 0;
        var result3 = 0;
        var uniqueInts3 = new List<int>();
        for (var i = 0; i < 1000; i += 3)
        {
            uniqueInts3.Add(i);
            result1 += i;
        }
        var uniqueInts5 = new List<int>();
        for (var o = 0; o < 1000; o += 5)
        {
            uniqueInts5.Add(o);
            result2 += o;
        }
        result3 += result1 + result2;
        Console.WriteLine(result3);
        Console.ReadLine();
    }

static void Main（字符串[]args）
{
var结果1=0；
var result2=0；
var结果3=0；
var uniqueInts3=新列表（）；
对于（变量i=0；i<1000；i+=3）
{
唯一性3.添加（i）；
结果1+=i；
}
var uniqueInts5=新列表（）；
对于（变量o=0；o<1000；o+=5）
{
唯一性5.添加（o）；
结果t2+=o；
}
结果3+=结果1+结果2；
控制台写入线（结果3）；
Console.ReadLine（）；
}

---

如果有人能告诉我该怎么做，我会很高兴的，因为我现在还不确定。

这不是最有效的方法，但应该有效

var sum = 0;

for(int i=0;i<1000;i++)
{
   if(i%3==0||i%5==0) //checks if something is multiple of 3 or 5
      sum+=i; // sums only when it's multiple of 3 or 5
}

最快数学方法版本：

var result = SumDivisbleBy(3,999)+SumDivisbleBy(5,999)-SumDivisbleBy(15,999);

private int SumDivisbleBy(int n, int p)
{
    return n*(p/n)*((p/n)+1)/2;
}

---

它计算所有可被3和5整除的数字之和，然后减去可被15整除的数字之和。说明：

一个简单的方法是循环所有从1到1000的数字，看看它们是3的倍数还是5的倍数，如果是，只需将它们添加到循环外的

结果

变量中即可。由于这是一个项目问题，我将让您自己计算代码。祝你好运

---

另外，请查看，它会对您有所帮助。

在编写Line（）之前尝试此操作以获得结果

var sum=uniqueInts3.Concat（uniqueInts5.Distinct（）.sum（）

这是我的2美分

版本1，使用for循环

int sum = 0;
for(int i = 0; i < 10; i++)
    if (new[] {3, 5}.Any(n => i % n == 0)) 
        sum += i;

可枚举。范围（1，10-1）

创建从0到9（小于10）的整数序列

。其中（..）

是一种过滤原始序列的方法

new[]{3，5}

创建另一个仅包含3和5的序列

.Any（n=>e%n==0）

取3和5，并对原始序列中的每个数字执行。当结果为0时，

Any

方法返回true，这意味着

Where

方法在结果中包含数字

---

最后是总和。

只是为了提供一种替代方法

首先，我们可以观察到3和5的倍数在以下重复序列中有间隔：

2, 1, 3, 1, 2, 3, 3

考虑到这一点，我们可以编写一个方法来计算总量，如下所示：

int sumMultiplesOf3And5UpTo(int n)
{
    int i = 3;
    int j = 0;
    int t = 0;

    int[] increments = new []{2, 1, 3, 1, 2, 3, 3};

    while (i <= n)
    {
        t += i;
        i += increments[j++%7];
    }

    return t;
}

---

我永远不会像这样真正地实施它；这只是一种好奇（也是一种不同方法的例子）。

我玩了一会儿，这就是我的解决方案：

private static int sumMultiples(int max, int small, int big)
{
    int sum = 0;

    int diff_add = big - small;
    int diff = diff_add;
    int next = small;
    while (next < max)
    {
        sum += next;

        if (next + diff < max
            && (next + diff) % small != 0)
        {
            sum += next + diff;
        }
        diff += diff_add;

        next += small;
    }

    return sum;
}

private static int summaultiples（int max、int small、int big）
{
整数和=0；
int diff_add=大-小；
int diff=diff_add；
int next=小；
while（下一个

---

while循环运行的次数最多/很少。

如果在同一个结果中添加所有整数，然后删除重复项，然后对其求和，会怎么样？作为一个非常附带的注释，如果您计划在生成列表时检查重复项，那么使用

HashSet

。请求的范围是1000，而不是10:）我认为在这里使用数组（

new[]{3,5}

）有点过火（只是我的观点）：）我试图通过使用数组证明的是，您可以在不改变算法的情况下将其用作输入参数。对于10/1000的事情，来吧，男人：）10/1000很好！[SpaceSpace]O（1）解决方案必须是赢家。：）@马修沃森：谢谢，但你的观察也令人印象深刻：）

2, 1, 3, 1, 2, 3, 3

int sumMultiplesOf3And5UpTo(int n)
{
    int i = 3;
    int j = 0;
    int t = 0;

    int[] increments = new []{2, 1, 3, 1, 2, 3, 3};

    while (i <= n)
    {
        t += i;
        i += increments[j++%7];
    }

    return t;
}

int sumMultiplesOf3And5UpTo(int n)
{
    int i = 3;
    int t = 0;

    while (true)
    {
        t += i;
        i += 2;
        if (i > n) break;

        t += i;
        i += 1;
        if (i > n) break;

        t += i;
        i += 3;
        if (i > n) break;

        t += i;
        i += 1;
        if (i > n) break;

        t += i;
        i += 2;
        if (i > n) break;

        t += i;
        i += 3;
        if (i > n) break;

        t += i;
        i += 3;
        if (i > n) break;
    }

    return t;
}

private static int sumMultiples(int max, int small, int big)
{
    int sum = 0;

    int diff_add = big - small;
    int diff = diff_add;
    int next = small;
    while (next < max)
    {
        sum += next;

        if (next + diff < max
            && (next + diff) % small != 0)
        {
            sum += next + diff;
        }
        diff += diff_add;

        next += small;
    }

    return sum;
}