Question

问题

检查集合多次包含相同的数字。

如果它确实包含相同数字不止一次，那么我想 保留第一个数字并为其余数字赋予新值，与第一个相同。

list newFitnessList确实包含这些数字：

0. 4054.230995  --> after code= 4054.230995
1. 4041.416004  --> after code= 4041.416004
2. 3926.227397  --> after code= 3926.227397
3. 4722.250903  --> after code= 4722.250903
4. 4722.250903  --> after code= 0
5. 4226.636776  --> after code= 4226.636776
6. 4061.499026  --> after code= 4061.499026
7. 3876.278254  --> after code= 3876.278254
8. 4041.416004  --> after code= 0
9. 4779.468077  --> after code= 4779.468077
10. 4226.636776  --> after code= 0
11. 3876.278254  --> after code= 0
12. 4779.468077  --> after code= 0
13. 3926.227397  --> after code= 0

为了实现上面解释的解决方案，我尝试了以下代码，但没有发生任何事情。列表的输出与之前相同：

public List<double> sortDoppelganger(List<double> inputFitnessList)
{
  List<double> newFitnessList = inputFitnessList.ToList();
  for(int i = 0; i < newFitnessList.Count; i++)
  {
    double Nothing=0;
    double actual = newFitnessList[i];
    for(int j = newFitnessList.Count-1; j >= 0; j--)
    {
      double next = newFitnessList[j];
      if(actual == next)
      {
        next = Nothing;
      }
    }
  }
  return newFitnessList;
}

如果有人知道我的代码有什么问题，我真的很感激。也许最好不要隐藏，我是编程的新手。

阅读说明后：我尝试了两个想法的解释。第一个是@Tim Schmelter的想法，第二个想法来自@ user3185569。

在这里你可以看看我想要实现的目标：

这是蒂姆的建议：

这里有user3185569的建议：

Answer 1

您可以使用Jul Apr Jul Mar Feb查看是否存在重复：

HashSet<double>

此解决方案修改原始列表。如果不合适，请使用public List<double> SortDoppelganger(List<double> inputFitnessList, double replacementValue = 0) { HashSet<double> doppelgangerFinder = new HashSet<double>(); for (int i = 0; i < inputFitnessList.Count; i++) { double value = inputFitnessList[i]; bool istDoppelganger = !doppelgangerFinder.Add(value); if (istDoppelganger) inputFitnessList[i] = replacementValue; } return inputFitnessList; }在开头创建副本。

对于它的价值，这是一个适用于任何类型的通用扩展方法：

var newList = new List<double>(inputFitnessList)

解释：user3185569是对的，我忘了提到你做错了什么。主要问题是您尝试将替换值分配给局部变量public static List<T> ReplaceDuplicates<T>(this IEnumerable<T> sequence, T replacementValue) { HashSet<T> duplicateFinder = new HashSet<T>(); List<T> returnList = new List<T>(); foreach (T item in sequence) { bool isDuplicate = !duplicateFinder.Add(item); returnList.Add(isDuplicate ? replacementValue : item); } return returnList; }：

next

在这种情况下，它与值或引用类型的差异无关。这不起作用的唯一原因是您只修改变量的值。不是变量之前引用的值（double next = newFitnessList[j]; if(actual == next) { next = Nothing; }）。该变量甚至不知道它已链接到列表。它只知道存储的价值。如果它是参考类型，问题将是相同的。通过将其替换为另一个值，该列表根本不会被修改。

简而言之，这将解决主要问题：

newFitnessList[j]

Answer 2

代码问题：

1- next是一个本地值类型变量，因此您实际上不会在列表中更改任何内容。

2-您需要跳过i == j的情况，否则您将所有值都设为0（项目匹配本身）

public static List<double> sortDoppelganger(List<double> inputFitnessList)
{
    List<double> newFitnessList = inputFitnessList.ToList();
    for (int i = 0; i < newFitnessList.Count; i++)
    {
        double Nothing = 0;
        double actual = newFitnessList[i];
        for (int j = newFitnessList.Count - 1; j >= 0; j--)
        {
            if (j == i)
                continue;

            double next = newFitnessList[j];
            if (actual == next)
            {
                newFitnessList[j] = Nothing;
            }
        }
    }
    return newFitnessList;
}

您可能需要将if (actual == next)替换为(Math.Abs(actual - next) < 0.0001)，因为您无法完全信任double。

用法：

var newList = sortDoppelganger(list);

从错误中学习的东西：

当您编写double next = newFitnessList[j];时，您实际上是将列表的索引处的值复制到名为next的本地变量。由于类型是double（值类型），更改next不会更改列表中的任何内容。

但是，如果您使用的是引用类型（例如，客户类而不是double），则更改next属性的值会在列表中更改它们。

Answer 3

Nothing为0，因此将List值设置为0。

您可以使用它来检查重复项：

bool areDduplicates = lstNames.GroupBy(n => n).Any(c => c.Count() > 1);

From here

Answer 4

private static IEnumerable<double> sortDoppelganger(List<double> doubles)
{
  var newList = new List<double>();
  foreach (var t in doubles)
  {
    newList.Add(newList.Contains(t) ? 0.0 : t);
  }
  return newList;
}

Answer 5

private function btnBricknew_clickHandler(event:BaseBrickEvent):void
{      
  view.colorBrick = model.currentColor;
}

检查列表多次包含相同的值

5 个答案:

从错误中学习的东西：