C# 我想知道不同的解决方案，我附上我的解决方案谢谢

他们相信这个解决方案是好的，我已经很久没有编程了，我已经有大约1个月了，我的问题是我打开了什么其他方法来解决下面的问题，我附上我的解决方案

Sample Input 1 2 3 4 5 

Sample Output 10 14 

数字是1、2、3、4和5

使用五个整数中的四个计算以下总和：除1外的所有整数总和为2+3+4+5=14。除2之外的所有项求和，其和为1+3+4+5=13。除3之外的所有项求和，其和为1+2+4+5=12。除4之外的所有项求和，其和为1+2+3+5=11。除5之外的所有值相加，总和为1+2+3+4=10

---

代码：

static void Main（字符串[]args）
{
int[]arr=新的int[]{1,2,3,4,5}；
最小最大和（arr）；
}
静态无效最小和（int[]arr）
{
List arr2=新列表（）；
int sum=0，mn，mx；
int-sum2=0；
int sum3=0；
int sum4=0；
int sum5=0；
对于（int i=0；imx）
{
mx=arr2[j]；
}
if（arr2[j]

描述与输出不匹配。但是，假设描述是正确的

使用五个整数中的四个计算以下总和：

• 将除1之外的所有项相加，相加为

  2+3+4+5=14

• 除2之外的所有项求和，总和为

  1+3+4+5=13

• 除3之外的所有项求和，总和为

  1+2+4+5=12

• 将除4之外的所有项相加，总和为

  1+2+3+5=11

• 将除5之外的所有项相加，总和为

  1+2+3+4=10

您可以执行以下操作

---

您可以只使用2个循环

var arr = new[] { 1, 2, 3, 4, 5 };

for (var i = 0; i < arr.GetLength(0);i++)
{
   var sum = 0;
   for (var j = 0; j < arr.GetLength(0); j++)
      if (i != j) 
         sum += arr[j];
   Console.WriteLine(sum);
}

---

或者如果你喜欢Linq链方法

---

或者如果你喜欢扩展方法

public static IEnumerable<IEnumerable<T>> FunkyIterator<T>(this T[] source)
   => Enumerable.Range(0, source.GetLength(0))
        .Select(i => source.Where((x, j) => i != j));

...

foreach (var iterations in arr.FunkyIterator())
   Console.WriteLine(iterations.Sum());

公共静态IEnumerable FunkyIterator（此T[]源代码）
=>可枚举的.Range（0，source.GetLength（0））
.选择（i=>source.Where（（x，j）=>i！=j））；
...
foreach（arr.FunkyIterator（）中的var迭代）
Console.WriteLine（iterations.Sum（））；

对于这一个，您可以查看统计数据的组合公式，它从n元素中获取所有可能的r元素，C（n，r）

这是获得所有可能组合的方法：

static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> elements, int k)
{
    return k == 0 ? new[] { new T[0] } :
          elements.SelectMany((e, i) => elements.Skip(i + 1)
               .Combinations(k - 1)
               .Select(c => (new[] { e }).Concat(c)));
}

foreach(IEnumerable<int> result in arr.Combinations(3))
{
    Console.WriteLine(result.Sum());
}

然后，您需要对数组中的每个

4

数字求和，如1,2,3,4；1,2,4,5 ; 1,2,3,5 ; ... 因此，您可以将上述方法与名为

Sum（）

的Linq方法一起使用

---

最后但并非最不重要的一点是，我提供的上述方法是一个扩展方法，因此请确保将其放在

静态类中，并且不要忘记添加对
系统的引用。Linq
这种方法怎么样

int[] arr = new int[] { 1, 2, 3, 4, 5 };

var total = arr.Sum();
List<int> sums = new List<int>();
foreach(int i in arr) {
  sums.Add(total - i);
}
var min = sums.Min();
var max = sums.Max();

Console.WriteLine("min = " + min);
Console.WriteLine("max = " + max);

int[]arr=newint[]{1,2,3,4,5}；
var total=arr.Sum（）；
列表总和=新列表（）；
foreach（内部i在arr中）{
加上（总计-i）；
}
var min=sums.min（）；
var max=sums.max（）；
Console.WriteLine（“min=”+min）；
Console.WriteLine（“max=”+max）；

或者，如果您不想使用任何LINQ：

int[] arr = new int[] { 1, 2, 3, 4, 5 };

int total = 0;    
foreach(int i in arr) {
  total += i;
}
int min = 0, max = 0;
for(int i=0; i<arr.Length; i++) {
  int sum = total - arr[i];
  if (i == 0) {
    min = sum;
    max = sum;
  }
  else {
    if (sum < min) {
      min = sum;
    }
    if (sum > max) {
      max = sum;
    }
  }
}

Console.WriteLine("min = " + min);
Console.WriteLine("max = " + max);

int[]arr=newint[]{1,2,3,4,5}；
int-total=0；
foreach（内部i在arr中）{
总数+=i；
}
int min=0，max=0；
对于（int i=0；i max）{
最大值=总和；
}
}
}
Console.WriteLine（“min=”+min）；
Console.WriteLine（“max=”+max）；
我将采用与当前发布的其他两个答案略有不同的方法。我将一步一步地慢慢改进您的解决方案。我要避开林克；别误会，LINQ很酷，你肯定应该学习它，但知道里面发生了什么很有用。有关LINQ的更多信息，请参见上文@General的答案

我注意到的第一件事是，只有当数组中有五个元素时，您的解决方案才有效。我要向大家展示的第一个版本就是消除这个限制的版本

但在此之前，我想编写两个方便的助手函数：
Max
和
Min
。这些函数取一个数组，分别返回最大元素和最小元素

static int Min（int[]arr）
{
int min=int.MaxValue；
foreach（arr中的var val）
{
min=数学最小值（min，val）；
}
返回最小值；
}
静态整数最大值（整数[]arr）
{
int max=int.MinValue；
foreach（arr中的var val）
{
max=Math.max（max，val）；
}
返回最大值；
}

有了这些，我们可以编写一个版本的函数来处理任意大小的数组

///增加了处理长度超过5个元素的数组的功能。
静态void MinMaxSum1（int[]arr）
{
//此数组将保存在以下情况下获得的总和：
//输入中相应的元素
//数组未包含在总和中。
//所以sums[0]是第零个元素的和
//他被遗漏了。
int[]总和=新的int[arr.Length]；
//skip是我们将省略的元素的索引
//总数
对于（int skip=0；skip


static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> elements, int k)
{
    return k == 0 ? new[] { new T[0] } :
          elements.SelectMany((e, i) => elements.Skip(i + 1)
               .Combinations(k - 1)
               .Select(c => (new[] { e }).Concat(c)));
}

int[] arr = new int[] { 1, 2, 3, 4, 5 };

foreach(IEnumerable<int> result in arr.Combinations(4))
{
    Console.WriteLine(result.Sum());
}

foreach(IEnumerable<int> result in arr.Combinations(3))
{
    Console.WriteLine(result.Sum());
}

int[] arr = new int[] { 1, 2, 3, 4, 5 };

var total = arr.Sum();
List<int> sums = new List<int>();
foreach(int i in arr) {
  sums.Add(total - i);
}
var min = sums.Min();
var max = sums.Max();

Console.WriteLine("min = " + min);
Console.WriteLine("max = " + max);

int[] arr = new int[] { 1, 2, 3, 4, 5 };

int total = 0;    
foreach(int i in arr) {
  total += i;
}
int min = 0, max = 0;
for(int i=0; i<arr.Length; i++) {
  int sum = total - arr[i];
  if (i == 0) {
    min = sum;
    max = sum;
  }
  else {
    if (sum < min) {
      min = sum;
    }
    if (sum > max) {
      max = sum;
    }
  }
}

Console.WriteLine("min = " + min);
Console.WriteLine("max = " + max);